Esempio n. 1
0
static PyObject *
_asctime(struct tm *timeptr)
{
    /* Inspired by Open Group reference implementation available at
     * http://pubs.opengroup.org/onlinepubs/009695399/functions/asctime.html */
    static char wday_name[7][3] = {
        "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
    };
    static char mon_name[12][3] = {
        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
    };
    char buf[20]; /* 'Sun Sep 16 01:03:52\0' */
    int n;

    n = PyOS_snprintf(buf, sizeof(buf), "%.3s %.3s%3d %.2d:%.2d:%.2d",
                      wday_name[timeptr->tm_wday],
                      mon_name[timeptr->tm_mon],
                      timeptr->tm_mday, timeptr->tm_hour,
                      timeptr->tm_min, timeptr->tm_sec);
    /* XXX: since the fields used by snprintf above are validated in checktm,
     * the following condition should never trigger. We keep the check because
     * historically fixed size buffer used in asctime was the source of
     * crashes. */
    if (n + 1 != sizeof(buf)) {
        PyErr_SetString(PyExc_ValueError, "unconvertible time");
        return NULL;
    }

    return PyUnicode_FromFormat("%s %d", buf, 1900 + timeptr->tm_year);
}
Esempio n. 2
0
PyObject *
argCountToString(PyObject *self, PyObject *args)
{
	char str[6];
	PyOS_snprintf(str, 5, "(%u)", PyTuple_GET_SIZE(args));
	return PyString_FromString(str);
}
SWIGRUNTIME PyObject *
PySwigObject_hex(PySwigObject *v)
{
  char buf[100];
  PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
  return PyString_FromString(buf);
}
Esempio n. 4
0
static PyObject *
strop_atof(PyObject *self, PyObject *args)
{
    char *s, *end;
    double x;
    char buffer[256]; /* For errors */

    WARN;
    if (!PyArg_ParseTuple(args, "s:atof", &s))
        return NULL;
    while (*s && isspace(Py_CHARMASK(*s)))
        s++;
    if (s[0] == '\0') {
        PyErr_SetString(PyExc_ValueError, "empty string for atof()");
        return NULL;
    }

    PyFPE_START_PROTECT("strop_atof", return 0)
    x = PyOS_string_to_double(s, &end, PyExc_OverflowError);
    PyFPE_END_PROTECT(x)
    if (x == -1 && PyErr_Occurred())
        return NULL;
    while (*end && isspace(Py_CHARMASK(*end)))
        end++;
    if (*end != '\0') {
        PyOS_snprintf(buffer, sizeof(buffer),
                      "invalid literal for atof(): %.200s", s);
        PyErr_SetString(PyExc_ValueError, buffer);
        return NULL;
    }
    return PyFloat_FromDouble(x);
}
Esempio n. 5
0
static PyObject *
tp_str(PyObject *self)
{
  char buf[20];
  PyOS_snprintf(buf, sizeof(buf), "%p", ((AddressObject *) self)->ptr);
  return PyString_FromString(buf);
}
Esempio n. 6
0
static PyObject*
PyLocale_getdefaultlocale(PyObject* self)
{
    char encoding[100];
    char locale[100];

    PyOS_snprintf(encoding, sizeof(encoding), "cp%d", GetACP());

    if (GetLocaleInfo(LOCALE_USER_DEFAULT,
                      LOCALE_SISO639LANGNAME,
                      locale, sizeof(locale))) {
        int i = strlen(locale);
        locale[i++] = '_';
        if (GetLocaleInfo(LOCALE_USER_DEFAULT,
                          LOCALE_SISO3166CTRYNAME,
                          locale+i, sizeof(locale)-i))
            return Py_BuildValue("ss", locale, encoding);
    }

    /* If we end up here, this windows version didn't know about
       ISO639/ISO3166 names (it's probably Windows 95).  Return the
       Windows language identifier instead (a hexadecimal number) */

    locale[0] = '0';
    locale[1] = 'x';
    if (GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTLANGUAGE,
                      locale+2, sizeof(locale)-2)) {
        return Py_BuildValue("ss", locale, encoding);
    }

    /* cannot determine the language code (very unlikely) */
    Py_INCREF(Py_None);
    return Py_BuildValue("Os", Py_None, encoding);
}
Esempio n. 7
0
static PyObject *
set_hook(const char *funcname, PyObject **hook_var, PyObject *args)
{
    PyObject *function = Py_None;
    char buf[80];
    PyOS_snprintf(buf, sizeof(buf), "|O:set_%.50s", funcname);
    if (!PyArg_ParseTuple(args, buf, &function))
        return NULL;
    if (function == Py_None) {
        Py_CLEAR(*hook_var);
    }
    else if (PyCallable_Check(function)) {
        PyObject *tmp = *hook_var;
        Py_INCREF(function);
        *hook_var = function;
        Py_XDECREF(tmp);
    }
    else {
        PyErr_Format(PyExc_TypeError,
                     "set_%.50s(func): argument not callable",
                     funcname);
        return NULL;
    }
    Py_RETURN_NONE;
}
Esempio n. 8
0
const char *
Py_GetVersion(void)
{
	static char version[250];
	PyOS_snprintf(version, sizeof(version), "%.80s", PY_VERSION);
	return version;
}
Esempio n. 9
0
static PyObject *
int_repr(PyIntObject *v)
{
	char buf[64];
	PyOS_snprintf(buf, sizeof(buf), "%ld", v->ob_ival);
	return PyString_FromString(buf);
}
Esempio n. 10
0
static int supports_code_page(UINT cp) {
  if (cp == 0) {
    cp = GetACP();
  }

  /* Shortcut, because we know that these encodings are bundled by default--
   * see FreezeTool.py and Python's encodings/aliases.py */
  if (cp != 0 && cp != 1252 && cp != 367 && cp != 437 && cp != 850 && cp != 819) {
    const struct _frozen *moddef;
    char codec[100];

    /* Check if the codec was frozen into the program.  We can't check this
     * using _PyCodec_Lookup, since Python hasn't been initialized yet. */
    PyOS_snprintf(codec, sizeof(codec), "encodings.cp%u", (unsigned int)cp);

    moddef = PyImport_FrozenModules;
    while (moddef->name) {
      if (strcmp(moddef->name, codec) == 0) {
        return 1;
      }
      ++moddef;
    }
    return 0;
  }

  return 1;
}
Esempio n. 11
0
	static PyObject *
		buffer_repr(PyIOCPBufferObject *s)
	{
		char buf[512];
		PyOS_snprintf( buf, sizeof(buf), "<iocp buffer object, addr=%x, length=%d >", s->ptr_start, s->len );
		return PyString_FromString(buf);
	}
Esempio n. 12
0
int xerbla_(char *srname, integer *info)
{
        const char* format = "On entry to %.*s" \
                " parameter number %d had an illegal value";
        char buf[57 + 6 + 4]; /* 57 for strlen(format),
                                 6 for name, 4 for param. num. */

        int len = 0; /* length of subroutine name*/
#ifdef WITH_THREAD
        PyGILState_STATE save;
#endif

        while( len<6 && srname[len]!='\0' )
                len++;
        while( len && srname[len-1]==' ' )
                len--;

        PyOS_snprintf(buf, sizeof(buf), format, len, srname, *info);
#ifdef WITH_THREAD
        save = PyGILState_Ensure();
        PyErr_SetString(PyExc_ValueError, buf);
        PyGILState_Release(save);
#endif
        return 0;
}
Esempio n. 13
0
static PyObject *
form_repr(formobject *f)
{
	char buf[100];
	PyOS_snprintf(buf, sizeof(buf), "<FORMS_form at %p, window=%ld>",
		      f, f->ob_form->window);
	return PyString_FromString(buf);
}
Esempio n. 14
0
const char *
Py_GetVersion(void)
{
	static char version[250];
	PyOS_snprintf(version, sizeof(version), "%.80s (%.80s) %.80s",
		      PY_VERSION, Py_GetBuildInfo(), Py_GetCompiler());
	return version;
}
Esempio n. 15
0
dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
				    const char *pathname, FILE *fp)
{
	char funcname[258];

	PyOS_snprintf(funcname, sizeof(funcname), "init%.200s", shortname);
	return dl_loadmod(Py_GetProgramName(), pathname, funcname);
}
Esempio n. 16
0
static PyObject *
int_hex(PyIntObject *v)
{
	char buf[100];
	long x = v -> ob_ival;
	PyOS_snprintf(buf, sizeof(buf), "0x%lx", x);
	return PyString_FromString(buf);
}
Esempio n. 17
0
static void
ps(void)
{
    char buffer[100];
    PyOS_snprintf(buffer, sizeof(buffer),
                  "ps -l -p %d </dev/null | sed 1d\n", getpid());
    system(buffer);
}
Esempio n. 18
0
static PyObject *
generic_repr(genericobject *g)
{
	char buf[100];
	PyOS_snprintf(buf, sizeof(buf), "<FORMS_object at %p, objclass=%d>",
		      g, g->ob_generic->objclass);
	return PyString_FromString(buf);
}
Esempio n. 19
0
static PyObject *
pylog_repr(PyLogObject *s)
{
    char buf[512];
    PyOS_snprintf(buf, sizeof(buf),
                "<Log object ... TODO>");
    return PyBytes_FromString(buf);
}
Esempio n. 20
0
/* returns new ref string formatted */
static PyObject *
Mat22_repr(Mat22 *self)
{
    char buf[BUF_SIZE];
    PyOS_snprintf(buf, BUF_SIZE, MAT22_FORMAT, 
            self->col1->x, self->col2->x, self->col1->y, self->col2->y);
    return PyString_FromString(buf);
}
Esempio n. 21
0
const char *
Py_GetBuildInfo(void)
{
	static char buildinfo[50];
	PyOS_snprintf(buildinfo, sizeof(buildinfo),
		      "#%d, %.20s, %.9s", BUILD, DATE, TIME);
	return buildinfo;
}
Esempio n. 22
0
static PyObject*
connectPool_repr(PyConnectPoolObject *v)
{
    //printf("connectPool_repr\n");
    char buf[64 + NAME_MAX];
    PyOS_snprintf(buf, sizeof(buf), "connect to %s in port %d with %d busy and %d free",
                  v->db, v->port, PySequence_Length(v->cons_busy), PySequence_Length(v->cons_free));
    return PyString_FromString(buf);
}
Esempio n. 23
0
static int __Pyx_check_binary_version(void) {
    char ctversion[4], rtversion[4];
    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
        char message[200];
        PyOS_snprintf(message, sizeof(message),
                      "compiletime version %s of module '%.100s' "
                      "does not match runtime version %s",
                      ctversion, __Pyx_MODULE_NAME, rtversion);
        #if PY_VERSION_HEX < 0x02050000
        return PyErr_Warn(NULL, message);
        #else
        return PyErr_WarnEx(NULL, message, 1);
        #endif
    }
    return 0;
}
Esempio n. 24
0
File: voidptr.c Progetto: Werkov/SIP
/*
 * Implement hex() for the type.
 */
static PyObject *sipVoidPtr_hex(PyObject *self)
{
    char buf[2 + 16 + 1];

    PyOS_snprintf(buf, sizeof (buf), "0x%.*lx", (int)(sizeof (void *) * 2),
            (unsigned long)((sipVoidPtrObject *)self)->voidptr);

    return PyString_FromString(buf);
}
Esempio n. 25
0
static void
complex_to_buf(char *buf, int bufsz, PyComplexObject *v, int precision)
{
	char format[32];
	if (v->cval.real == 0.) {
		PyOS_snprintf(format, sizeof(format), "%%.%ig", precision);
		PyOS_ascii_formatd(buf, bufsz - 1, format, v->cval.imag);
		strncat(buf, "j", 1);
	} else {
		char re[64], im[64];
		/* Format imaginary part with sign, real part without */
		PyOS_snprintf(format, sizeof(format), "%%.%ig", precision);
		PyOS_ascii_formatd(re, sizeof(re), format, v->cval.real);
		PyOS_snprintf(format, sizeof(format), "%%+.%ig", precision);
		PyOS_ascii_formatd(im, sizeof(im), format, v->cval.imag);
		PyOS_snprintf(buf, bufsz, "(%s%sj)", re, im);
	}
}
Esempio n. 26
0
static PyObject *
BBox_repr(PlanarBBoxObject *self)
{
    char buf[255];
    buf[0] = 0; /* paranoid */
    PyOS_snprintf(buf, 255, "BoundingBox([(%lg, %lg), (%lg, %lg)])",
		self->min.x, self->min.y, self->max.x, self->max.y);
    return PyUnicode_FromString(buf);
}
Esempio n. 27
0
static PyObject *
dbmopen(PyObject *self, PyObject *args)
{
    char *name;
    char *flags = "r";
    int iflags;
    int mode = 0666;

    if (!PyArg_ParseTuple(args, "s|si:open", &name, &flags, &mode))
        return NULL;
    switch (flags[0]) {
    case 'r':
        iflags = GDBM_READER;
        break;
    case 'w':
        iflags = GDBM_WRITER;
        break;
    case 'c':
        iflags = GDBM_WRCREAT;
        break;
    case 'n':
        iflags = GDBM_NEWDB;
        break;
    default:
        PyErr_SetString(DbmError,
                        "First flag must be one of 'r', 'w', 'c' or 'n'");
        return NULL;
    }
    for (flags++; *flags != '\0'; flags++) {
        char buf[40];
        switch (*flags) {
#ifdef GDBM_FAST
            case 'f':
                iflags |= GDBM_FAST;
                break;
#endif
#ifdef GDBM_SYNC
            case 's':
                iflags |= GDBM_SYNC;
                break;
#endif
#ifdef GDBM_NOLOCK
            case 'u':
                iflags |= GDBM_NOLOCK;
                break;
#endif
            default:
                PyOS_snprintf(buf, sizeof(buf), "Flag '%c' is not supported.",
                	      *flags);
                PyErr_SetString(DbmError, buf);
                return NULL;
        }
    }

    return newdbmobject(name, iflags, mode);
}
Esempio n. 28
0
static char *
converterr(char *expected, PyObject *arg, char *msgbuf, size_t bufsize)
{
	assert(expected != NULL);
	assert(arg != NULL); 
	PyOS_snprintf(msgbuf, bufsize,
		      "must be %.50s, not %.50s", expected,
		      arg == Py_None ? "None" : arg->ob_type->tp_name);
	return msgbuf;
}
Esempio n. 29
0
static PyObject *
Poly__repr__(polypaths_planar_overridePolygonObject *self)
{
	char props[256];
	
	props[0] = 0;
	if (self->flags & POLY_CONVEX_KNOWN_FLAG) {
		if (!(self->flags & POLY_CONVEX_FLAG)
			&& self->flags & POLY_SIMPLE_KNOWN_FLAG) {
			PyOS_snprintf(props, 255, ", is_convex=%s, is_simple=%s",
				self->flags & POLY_CONVEX_FLAG ? "True" : "False",
				self->flags & POLY_SIMPLE_FLAG ? "True" : "False");
		} else {
			PyOS_snprintf(props, 255, ", is_convex=%s", 
				self->flags & POLY_CONVEX_FLAG ? "True" : "False");
		}
	}
	return Seq2__repr__((polypaths_planar_overrideSeq2Object *)self, "Polygon", props);
}
static PyObject *
proxy_repr(PyWeakReference *proxy)
{
    char buf[160];
    PyOS_snprintf(buf, sizeof(buf),
		  "<weakproxy at %p to %.100s at %p>", proxy,
		  PyWeakref_GET_OBJECT(proxy)->ob_type->tp_name,
		  PyWeakref_GET_OBJECT(proxy));
    return PyString_FromString(buf);
}