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); }
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); }
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); }
static PyObject * tp_str(PyObject *self) { char buf[20]; PyOS_snprintf(buf, sizeof(buf), "%p", ((AddressObject *) self)->ptr); return PyString_FromString(buf); }
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); }
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; }
const char * Py_GetVersion(void) { static char version[250]; PyOS_snprintf(version, sizeof(version), "%.80s", PY_VERSION); return version; }
static PyObject * int_repr(PyIntObject *v) { char buf[64]; PyOS_snprintf(buf, sizeof(buf), "%ld", v->ob_ival); return PyString_FromString(buf); }
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; }
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); }
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; }
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); }
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; }
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); }
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); }
static void ps(void) { char buffer[100]; PyOS_snprintf(buffer, sizeof(buffer), "ps -l -p %d </dev/null | sed 1d\n", getpid()); system(buffer); }
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); }
static PyObject * pylog_repr(PyLogObject *s) { char buf[512]; PyOS_snprintf(buf, sizeof(buf), "<Log object ... TODO>"); return PyBytes_FromString(buf); }
/* 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); }
const char * Py_GetBuildInfo(void) { static char buildinfo[50]; PyOS_snprintf(buildinfo, sizeof(buildinfo), "#%d, %.20s, %.9s", BUILD, DATE, TIME); return buildinfo; }
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); }
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; }
/* * 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); }
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); } }
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); }
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); }
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; }
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); }