/* decode a c string into a Python unicode in the connection encoding * * len can be < 0: in this case it will be calculated * * If no connection or encoding is available, default to utf8 */ PyObject * conn_decode(connectionObject *self, const char *str, Py_ssize_t len) { if (len < 0) { len = strlen(str); } if (self) { if (self->cdecoder) { return self->cdecoder(str, len, NULL); } else if (self->pydecoder) { PyObject *b = NULL; PyObject *t = NULL; PyObject *rv = NULL; if (!(b = Bytes_FromStringAndSize(str, len))) { goto error; } if (!(t = PyObject_CallFunctionObjArgs(self->pydecoder, b, NULL))) { goto error; } if (!(rv = PyTuple_GetItem(t, 0))) { goto error; } Py_INCREF(rv); /* PyTuple_GetItem gives a borrowes one */ error: Py_XDECREF(t); Py_XDECREF(b); return rv; } else { return PyUnicode_FromStringAndSize(str, len); } } else { return PyUnicode_FromStringAndSize(str, len); } }
static PyObject * psyco_lobj_read(lobjectObject *self, PyObject *args) { PyObject *res; int where, end; Py_ssize_t size = -1; char *buffer; if (!PyArg_ParseTuple(args, "|" CONV_CODE_PY_SSIZE_T, &size)) return NULL; EXC_IF_LOBJ_CLOSED(self); EXC_IF_LOBJ_LEVEL0(self); EXC_IF_LOBJ_UNMARKED(self); if (size < 0) { if ((where = lobject_tell(self)) < 0) return NULL; if ((end = lobject_seek(self, 0, SEEK_END)) < 0) return NULL; if (lobject_seek(self, where, SEEK_SET) < 0) return NULL; size = end - where; } if ((buffer = PyMem_Malloc(size)) == NULL) { PyErr_NoMemory(); return NULL; } if ((size = lobject_read(self, buffer, size)) < 0) { PyMem_Free(buffer); return NULL; } if (self->mode & LOBJECT_BINARY) { res = Bytes_FromStringAndSize(buffer, size); } else { res = PyUnicode_Decode(buffer, size, self->conn->codec, NULL); } PyMem_Free(buffer); return res; }
PyObject *_PGFT_Render_PixelArray(FreeTypeInstance *ft, PgFontObject *fontobj, const FontRenderMode *mode, PGFT_String *text, int invert, int *_width, int *_height) { FT_Byte *buffer = 0; PyObject *array = 0; FontSurface surf; Layout *font_text; unsigned width; unsigned height; FT_Vector offset; FT_Pos underline_top; FT_Fixed underline_size; int array_size; /* build font text */ font_text = _PGFT_LoadLayout(ft, fontobj, mode, text); if (!font_text) { return 0; } if (font_text->length == 0) { /* Nothing to render */ *_width = 0; *_height = _PGFT_Font_GetHeight(ft, fontobj); return Bytes_FromStringAndSize("", 0); } _PGFT_GetRenderMetrics(mode, font_text, &width, &height, &offset, &underline_top, &underline_size); array_size = width * height; if (array_size == 0) { /* Empty array */ *_width = 0; *_height = height; return Bytes_FromStringAndSize("", 0); } /* Create an uninitialized string whose buffer can be directly set. */ array = Bytes_FromStringAndSize(0, array_size); if (!array) { return 0; } buffer = (FT_Byte *)Bytes_AS_STRING(array); if (invert) { memset(buffer, SDL_ALPHA_OPAQUE, (size_t)array_size); } else { memset(buffer, SDL_ALPHA_TRANSPARENT, (size_t)array_size); } surf.buffer = buffer; surf.width = width; surf.height = height; surf.pitch = (int)surf.width; surf.format = 0; surf.render_gray = __render_glyph_GRAY1; surf.render_mono = __render_glyph_MONO_as_GRAY1; surf.fill = __fill_glyph_GRAY1; render(ft, font_text, mode, invert ? &mono_transparent : &mono_opaque, &surf, width, height, &offset, underline_top, underline_size); *_width = width; *_height = height; return array; }
static PyObject * qstring_quote(qstringObject *self) { PyObject *str = NULL; char *s, *buffer = NULL; Py_ssize_t len, qlen; const char *encoding = default_encoding; PyObject *rv = NULL; /* if the wrapped object is an unicode object we can encode it to match conn->encoding but if the encoding is not specified we don't know what to do and we raise an exception */ if (self->conn) { encoding = self->conn->codec; } Dprintf("qstring_quote: encoding to %s", encoding); if (PyUnicode_Check(self->wrapped) && encoding) { str = PyUnicode_AsEncodedString(self->wrapped, encoding, NULL); Dprintf("qstring_quote: got encoded object at %p", str); if (str == NULL) goto exit; } #if PY_MAJOR_VERSION < 3 /* if the wrapped object is a simple string, we don't know how to (re)encode it, so we pass it as-is */ else if (PyString_Check(self->wrapped)) { str = self->wrapped; /* INCREF to make it ref-wise identical to unicode one */ Py_INCREF(str); } #endif /* if the wrapped object is not a string, this is an error */ else { PyErr_SetString(PyExc_TypeError, "can't quote non-string object (or missing encoding)"); goto exit; } /* encode the string into buffer */ Bytes_AsStringAndSize(str, &s, &len); if (!(buffer = psycopg_escape_string(self->conn, s, len, NULL, &qlen))) { goto exit; } if (qlen > (size_t) PY_SSIZE_T_MAX) { PyErr_SetString(PyExc_IndexError, "PG buffer too large to fit in Python buffer."); goto exit; } rv = Bytes_FromStringAndSize(buffer, qlen); exit: PyMem_Free(buffer); Py_XDECREF(str); return rv; }
PyObject * Bytes_Format(PyObject *format, PyObject *args) { char *fmt, *res; Py_ssize_t arglen, argidx; Py_ssize_t reslen, rescnt, fmtcnt; int args_owned = 0; PyObject *result; PyObject *dict = NULL; if (format == NULL || !Bytes_Check(format) || args == NULL) { PyErr_BadInternalCall(); return NULL; } fmt = Bytes_AS_STRING(format); fmtcnt = Bytes_GET_SIZE(format); reslen = rescnt = fmtcnt + 100; result = Bytes_FromStringAndSize((char *)NULL, reslen); if (result == NULL) return NULL; res = Bytes_AsString(result); if (PyTuple_Check(args)) { arglen = PyTuple_GET_SIZE(args); argidx = 0; } else { arglen = -1; argidx = -2; } if (Py_TYPE(args)->tp_as_mapping && !PyTuple_Check(args) && !PyObject_TypeCheck(args, &Bytes_Type)) dict = args; while (--fmtcnt >= 0) { if (*fmt != '%') { if (--rescnt < 0) { rescnt = fmtcnt + 100; reslen += rescnt; if (_Bytes_Resize(&result, reslen)) return NULL; res = Bytes_AS_STRING(result) + reslen - rescnt; --rescnt; } *res++ = *fmt++; } else { /* Got a format specifier */ Py_ssize_t width = -1; int c = '\0'; PyObject *v = NULL; PyObject *temp = NULL; char *pbuf; Py_ssize_t len; fmt++; if (*fmt == '(') { char *keystart; Py_ssize_t keylen; PyObject *key; int pcount = 1; if (dict == NULL) { PyErr_SetString(PyExc_TypeError, "format requires a mapping"); goto error; } ++fmt; --fmtcnt; keystart = fmt; /* Skip over balanced parentheses */ while (pcount > 0 && --fmtcnt >= 0) { if (*fmt == ')') --pcount; else if (*fmt == '(') ++pcount; fmt++; } keylen = fmt - keystart - 1; if (fmtcnt < 0 || pcount > 0) { PyErr_SetString(PyExc_ValueError, "incomplete format key"); goto error; } key = Text_FromUTF8AndSize(keystart, keylen); if (key == NULL) goto error; if (args_owned) { Py_DECREF(args); args_owned = 0; } args = PyObject_GetItem(dict, key); Py_DECREF(key); if (args == NULL) { goto error; } args_owned = 1; arglen = -1; argidx = -2; } while (--fmtcnt >= 0) { c = *fmt++; break; } if (fmtcnt < 0) { PyErr_SetString(PyExc_ValueError, "incomplete format"); goto error; } if (c != '%') { v = getnextarg(args, arglen, &argidx); if (v == NULL) goto error; } switch (c) { case '%': pbuf = "%"; len = 1; break; case 's': /* only bytes! */ if (!Bytes_CheckExact(v)) { PyErr_Format(PyExc_ValueError, "only bytes values expected, got %s", Py_TYPE(v)->tp_name); goto error; } temp = v; Py_INCREF(v); pbuf = Bytes_AS_STRING(temp); len = Bytes_GET_SIZE(temp); break; default: PyErr_Format(PyExc_ValueError, "unsupported format character '%c' (0x%x) " "at index " FORMAT_CODE_PY_SSIZE_T, c, c, (Py_ssize_t)(fmt - 1 - Bytes_AsString(format))); goto error; } if (width < len) width = len; if (rescnt < width) { reslen -= rescnt; rescnt = width + fmtcnt + 100; reslen += rescnt; if (reslen < 0) { Py_DECREF(result); Py_XDECREF(temp); return PyErr_NoMemory(); } if (_Bytes_Resize(&result, reslen)) { Py_XDECREF(temp); return NULL; } res = Bytes_AS_STRING(result) + reslen - rescnt; } Py_MEMCPY(res, pbuf, len); res += len; rescnt -= len; while (--width >= len) { --rescnt; *res++ = ' '; } if (dict && (argidx < arglen) && c != '%') { PyErr_SetString(PyExc_TypeError, "not all arguments converted during string formatting"); Py_XDECREF(temp); goto error; } Py_XDECREF(temp); } /* '%' */ } /* until end */ if (argidx < arglen && !dict) { PyErr_SetString(PyExc_TypeError, "not all arguments converted during string formatting"); goto error; } if (args_owned) { Py_DECREF(args); } if (_Bytes_Resize(&result, reslen - rescnt)) return NULL; return result; error: Py_DECREF(result); if (args_owned) { Py_DECREF(args); } return NULL; }