static int SplitQName(PyObject *qualifiedName, PyObject **prefix, PyObject **localName) { int i; Py_UNICODE colon = ':'; Py_ssize_t len = PyUnicode_GET_SIZE(qualifiedName); const Py_UNICODE *p = PyUnicode_AS_UNICODE(qualifiedName); for (i = 0; i < len; i++) { if (p[i] == colon) { PyObject *u, *v; u = PyUnicode_FromUnicode(p, (Py_ssize_t)i); if (u == NULL) { return 0; } /* skip over the colon */ i++; v = PyUnicode_FromUnicode((p + i), (Py_ssize_t)(len - i)); if (v == NULL) { Py_DECREF(u); return 0; } *prefix = u; *localName = v; return 1; } } /* No prefix */ *prefix = Py_None; Py_INCREF(Py_None); *localName = qualifiedName; Py_INCREF(qualifiedName); return 1; }
PyObject * PyIMEngine::py_get_surrounding_text (PyIMEngineObject *self, PyObject *args) { PyObject *tuple; int maxlen_before = -1; int maxlen_after = -1; if (!PyArg_ParseTuple (args, "|ii:get_surrounding_text", &maxlen_before, &maxlen_after)) return NULL; WideString text; int cursor; int provided = self->engine.get_surrounding_text(text, cursor, maxlen_before, maxlen_after); tuple = PyTuple_New (2); if (!provided) { text = L""; cursor = 0; } #if Py_UNICODE_SIZE == 4 PyTuple_SET_ITEM (tuple, 0, PyUnicode_FromUnicode ((Py_UNICODE *)text.c_str(), text.length())); #else gunichar2 *utf16_str = g_ucs4_to_utf16 (text.c_str(), -1, NULL, NULL, NULL); PyTuple_SET_ITEM (tuple, 0, PyUnicode_FromUnicode ((Py_UNICODE *)utf16_str, text.length())); #endif PyTuple_SET_ITEM (tuple, 1, PyInt_FromLong ((long) cursor)); return tuple; }
EXPORT PyObject *PyUnicode_FromUnicodeString(const UnicodeString *string) { if (!string) { Py_INCREF(Py_None); return Py_None; } else if (sizeof(Py_UNICODE) == sizeof(UChar)) return PyUnicode_FromUnicode((const Py_UNICODE *) string->getBuffer(), (int) string->length()); else { int len = string->length(); PyObject *u = PyUnicode_FromUnicode(NULL, len); if (u) { Py_UNICODE *pchars = PyUnicode_AS_UNICODE(u); const UChar *chars = string->getBuffer(); for (int i = 0; i < len; i++) pchars[i] = chars[i]; } return u; } }
PyObject *PyCodec_ReplaceErrors(PyObject *exc) { PyObject *restuple; Py_ssize_t start; Py_ssize_t end; Py_ssize_t i; if (PyObject_IsInstance(exc, PyExc_UnicodeEncodeError)) { PyObject *res; Py_UNICODE *p; if (PyUnicodeEncodeError_GetStart(exc, &start)) return NULL; if (PyUnicodeEncodeError_GetEnd(exc, &end)) return NULL; res = PyUnicode_FromUnicode(NULL, end-start); if (res == NULL) return NULL; for (p = PyUnicode_AS_UNICODE(res), i = start; i<end; ++p, ++i) *p = '?'; restuple = Py_BuildValue("(On)", res, end); Py_DECREF(res); return restuple; } else if (PyObject_IsInstance(exc, PyExc_UnicodeDecodeError)) { Py_UNICODE res = Py_UNICODE_REPLACEMENT_CHARACTER; if (PyUnicodeDecodeError_GetEnd(exc, &end)) return NULL; return Py_BuildValue("(u#n)", &res, (Py_ssize_t)1, end); } else if (PyObject_IsInstance(exc, PyExc_UnicodeTranslateError)) { PyObject *res; Py_UNICODE *p; if (PyUnicodeTranslateError_GetStart(exc, &start)) return NULL; if (PyUnicodeTranslateError_GetEnd(exc, &end)) return NULL; res = PyUnicode_FromUnicode(NULL, end-start); if (res == NULL) return NULL; for (p = PyUnicode_AS_UNICODE(res), i = start; i<end; ++p, ++i) *p = Py_UNICODE_REPLACEMENT_CHARACTER; restuple = Py_BuildValue("(On)", res, end); Py_DECREF(res); return restuple; } else { wrong_exception_type(exc); return NULL; } }
/* * READER */ static int parse_save_field(ReaderObj *self) { PyObject *field; field = PyUnicode_FromUnicode(self->field, self->field_len); if (field == NULL) return -1; self->field_len = 0; if (self->numeric_field) { PyObject *tmp; self->numeric_field = 0; tmp = PyNumber_Float(field); if (tmp == NULL) { Py_DECREF(field); return -1; } Py_DECREF(field); field = tmp; } PyList_Append(self->fields, field); Py_DECREF(field); return 0; }
static PyObject* record_getstring(msiobj* record, PyObject* args) { unsigned int field; unsigned int status; WCHAR buf[2000]; WCHAR *res = buf; DWORD size = sizeof(buf); PyObject* string; if (!PyArg_ParseTuple(args, "I:GetString", &field)) return NULL; status = MsiRecordGetStringW(record->h, field, res, &size); if (status == ERROR_MORE_DATA) { res = (WCHAR*) malloc((size + 1)*sizeof(WCHAR)); if (res == NULL) return PyErr_NoMemory(); status = MsiRecordGetStringW(record->h, field, res, &size); } if (status != ERROR_SUCCESS) return msierror((int) status); string = PyUnicode_FromUnicode(res, size); if (buf != res) free(res); return string; }
static PyObject* uuidcreate(PyObject* obj, PyObject*args) { UUID result; unsigned short *cresult; PyObject *oresult; /* May return ok, local only, and no address. For local only, the documentation says we still get a uuid. For RPC_S_UUID_NO_ADDRESS, it's not clear whether we can use the result. */ if (UuidCreate(&result) == RPC_S_UUID_NO_ADDRESS) { PyErr_SetString(PyExc_NotImplementedError, "processing 'no address' result"); return NULL; } if (UuidToStringW(&result, &cresult) == RPC_S_OUT_OF_MEMORY) { PyErr_SetString(PyExc_MemoryError, "out of memory in uuidgen"); return NULL; } oresult = PyUnicode_FromUnicode(cresult, wcslen(cresult)); RpcStringFreeW(&cresult); return oresult; }
static int xns_init(PyXPathNamespaceObject *self, PyElementObject *parentNode, PyObject *prefix, PyObject *namespaceURI) { if ((self == NULL || !PyXPathNamespace_Check(self)) || (parentNode == NULL || !PyElement_Check(parentNode)) || (prefix == NULL || !DOMString_NullCheck(prefix)) || (namespaceURI == NULL || !DOMString_Check(namespaceURI))) { PyErr_BadInternalCall(); return -1; } if (prefix == Py_None) { prefix = PyUnicode_FromUnicode(NULL, (Py_ssize_t)0); if (prefix == NULL) return -1; } else { Py_INCREF(prefix); } self->nodeName = prefix; Py_INCREF(namespaceURI); self->nodeValue = namespaceURI; Node_SET_PARENT(self, (PyNodeObject *) parentNode); return 0; }
static int __init__(PyObject *self, PyObject *args, PyObject *kwds) { ligolw_RowDumper *rowdumper = (ligolw_RowDumper *) self; Py_UNICODE default_delimiter = ','; rowdumper->delimiter = NULL; if(!PyArg_ParseTuple(args, "OO|U", &rowdumper->attributes, &rowdumper->formats, &rowdumper->delimiter)) return -1; if(rowdumper->delimiter) Py_INCREF(rowdumper->delimiter); else rowdumper->delimiter = PyUnicode_FromUnicode(&default_delimiter, 1); rowdumper->attributes = llwtokenizer_build_attributes(rowdumper->attributes); rowdumper->formats = llwtokenizer_build_formats(rowdumper->formats); if(!rowdumper->delimiter || !rowdumper->attributes || !rowdumper->formats) /* memory clean-up happens in __del__() */ return -1; if(PyTuple_GET_SIZE(rowdumper->attributes) != PyTuple_GET_SIZE(rowdumper->formats)) { /* memory clean-up happens in __del__() */ PyErr_SetString(PyExc_ValueError, "len(attributes) != len(formats)"); return -1; } rowdumper->rows_converted = 0; rowdumper->iter = Py_None; Py_INCREF(rowdumper->iter); rowdumper->tokens = Py_None; Py_INCREF(rowdumper->tokens); return 0; }
void grid2utf(T const& grid_type, boost::python::list& l, std::vector<typename T::lookup_type>& key_order) { using keys_type = std::map< typename T::lookup_type, typename T::value_type>; using keys_iterator = typename keys_type::iterator; typename T::data_type const& data = grid_type.data(); typename T::feature_key_type const& feature_keys = grid_type.get_feature_keys(); typename T::feature_key_type::const_iterator feature_pos; keys_type keys; // start counting at utf8 codepoint 32, aka space character std::uint16_t codepoint = 32; std::size_t array_size = data.width(); for (std::size_t y = 0; y < data.height(); ++y) { std::uint16_t idx = 0; const std::unique_ptr<Py_UNICODE[]> line(new Py_UNICODE[array_size]); typename T::value_type const* row = data.get_row(y); for (std::size_t x = 0; x < data.width(); ++x) { typename T::value_type feature_id = row[x]; feature_pos = feature_keys.find(feature_id); if (feature_pos != feature_keys.end()) { mapnik::grid::lookup_type val = feature_pos->second; keys_iterator key_pos = keys.find(val); if (key_pos == keys.end()) { // Create a new entry for this key. Skip the codepoints that // can't be encoded directly in JSON. if (codepoint == 34) ++codepoint; // Skip " else if (codepoint == 92) ++codepoint; // Skip backslash if (feature_id == mapnik::grid::base_mask) { keys[""] = codepoint; key_order.push_back(""); } else { keys[val] = codepoint; key_order.push_back(val); } line[idx++] = static_cast<Py_UNICODE>(codepoint); ++codepoint; } else { line[idx++] = static_cast<Py_UNICODE>(key_pos->second); } } // else, shouldn't get here... } l.append(boost::python::object( boost::python::handle<>( PyUnicode_FromUnicode(line.get(), array_size)))); } }
static PyObject* escape_unicode(PyUnicodeObject *in) { PyUnicodeObject *out; Py_UNICODE *inp = in->str; const Py_UNICODE *inp_end = in->str + in->length; Py_UNICODE *next_escp; Py_UNICODE *outp; Py_ssize_t delta=0, erepl=0, delta_len=0; /* First we need to figure out how long the escaped string will be */ while (*(inp) || inp < inp_end) { if (*inp < ESCAPED_CHARS_TABLE_SIZE && escaped_chars_delta_len[*inp]) { delta += escaped_chars_delta_len[*inp]; ++erepl; } ++inp; } /* Do we need to escape anything at all? */ if (!erepl) { Py_INCREF(in); return (PyObject*)in; } out = (PyUnicodeObject*)PyUnicode_FromUnicode(NULL, in->length + delta); if (!out) return NULL; outp = out->str; inp = in->str; while (erepl-- > 0) { /* look for the next substitution */ next_escp = inp; while (next_escp < inp_end) { if (*next_escp < ESCAPED_CHARS_TABLE_SIZE && (delta_len = escaped_chars_delta_len[*next_escp])) { ++delta_len; break; } ++next_escp; } if (next_escp > inp) { /* copy unescaped chars between inp and next_escp */ Py_UNICODE_COPY(outp, inp, next_escp-inp); outp += next_escp - inp; } /* escape 'next_escp' */ Py_UNICODE_COPY(outp, escaped_chars_repl[*next_escp], delta_len); outp += delta_len; inp = next_escp + 1; } if (inp < inp_end) Py_UNICODE_COPY(outp, inp, in->length - (inp - in->str)); return (PyObject*)out; }
PyObject * PyObject_Unicode(PyObject *v) { PyObject *res; PyObject *func; PyObject *str; static PyObject *unicodestr; if (v == NULL) { res = PyString_FromString("<NULL>"); if (res == NULL) return NULL; str = PyUnicode_FromEncodedObject(res, NULL, "strict"); Py_DECREF(res); return str; } else if (PyUnicode_CheckExact(v)) { Py_INCREF(v); return v; } /* XXX As soon as we have a tp_unicode slot, we should check this before trying the __unicode__ method. */ if (unicodestr == NULL) { unicodestr= PyString_InternFromString("__unicode__"); if (unicodestr == NULL) return NULL; } func = PyObject_GetAttr(v, unicodestr); if (func != NULL) { res = PyEval_CallObject(func, (PyObject *)NULL); Py_DECREF(func); } else { PyErr_Clear(); if (PyUnicode_Check(v)) { /* For a Unicode subtype that's didn't overwrite __unicode__, return a true Unicode object with the same data. */ return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(v), PyUnicode_GET_SIZE(v)); } if (PyString_CheckExact(v)) { Py_INCREF(v); res = v; } else { if (v->ob_type->tp_str != NULL) res = (*v->ob_type->tp_str)(v); else res = PyObject_Repr(v); } } if (res == NULL) return NULL; if (!PyUnicode_Check(res)) { str = PyUnicode_FromEncodedObject(res, NULL, "strict"); Py_DECREF(res); res = str; } return res; }
PyObject * fudgepyc_convertStringToPython ( FudgeString source ) { PyObject * target = 0; fudge_byte * buffer; size_t written, bufsize; bufsize = FudgeString_getSize ( source ) * sizeof ( Py_UNICODE ); if ( ! ( buffer = ( fudge_byte * ) PyMem_Malloc ( bufsize ) ) ) return 0; /* See comment in fudgepyc_convertPythonToString for explanation */ switch ( sizeof ( Py_UNICODE ) ) { case 2: written = FudgeString_copyToUTF16 ( buffer, bufsize, source ); break; case 4: written = FudgeString_copyToUTF32 ( buffer, bufsize, source ); break; default: exception_raise_any ( PyExc_RuntimeError, "Cannot decode Fudge string; Python " "interpreter not using UCS2 or UCS4 for" "internal unicode encoding" ); return 0; } target = PyUnicode_FromUnicode ( ( Py_UNICODE * ) buffer, written / sizeof ( Py_UNICODE ) ); PyMem_Free ( buffer ); return target; }
static PyObject *PyLoadModule(PyObject *self, PyObject *args) { #ifdef UNICODE static char *fmt="u"; #else static char *fmt="s"; #endif TCHAR *modName=NULL; if (!PyArg_ParseTuple(args, fmt, &modName)) return NULL; HINSTANCE hinst = LoadLibrary(modName); if (hinst == NULL) { Py_INCREF(Py_None); return Py_None; } TCHAR buf[_MAX_PATH]; if (GetModuleFileName(hinst, buf, sizeof(buf)/sizeof(buf[0]))==0) { Py_INCREF(Py_None); return Py_None; } #ifdef UNICODE return PyUnicode_FromUnicode(buf, wcslen(buf)); #else return PyString_FromString(buf); #endif }
PyObject* PyUnicode_FromSQLWCHAR(const SQLWCHAR* sz, Py_ssize_t cch) { // Create a Python Unicode object from a zero-terminated SQLWCHAR. if (SQLWCHAR_SIZE == Py_UNICODE_SIZE) { // The ODBC Unicode and Python Unicode types are the same size. Cast the ODBC type to the Python type and use // a fast function. return PyUnicode_FromUnicode((const Py_UNICODE*)sz, cch); } #ifdef HAVE_WCHAR_H if (WCHAR_T_SIZE == SQLWCHAR_SIZE) { // The ODBC Unicode is the same as wchar_t. Python provides a function for that. return PyUnicode_FromWideChar((const wchar_t*)sz, cch); } #endif // There is no conversion, so we will copy it ourselves with a simple cast. if (Py_UNICODE_SIZE < SQLWCHAR_SIZE) { // We are casting from a larger size to a smaller one, so we'll make sure they all fit. for (Py_ssize_t i = 0; i < cch; i++) { if (((Py_ssize_t)sz[i]) > MAX_PY_UNICODE) { PyErr_Format(PyExc_ValueError, "Cannot convert from SQLWCHAR %zd to Unicode. Value is too large.", (Py_ssize_t)sz[i]); return 0; } } } Object result(PyUnicode_FromUnicode(0, cch)); if (!result) return 0; Py_UNICODE* pch = PyUnicode_AS_UNICODE(result.Get()); for (Py_ssize_t i = 0; i < cch; i++) pch[i] = (Py_UNICODE)sz[i]; return result.Detach(); }
void grid2utf2(T const& grid_type, boost::python::list& l, std::vector<typename T::lookup_type>& key_order, unsigned int resolution) { using keys_type = std::map< typename T::lookup_type, typename T::value_type>; using keys_iterator = typename keys_type::const_iterator; typename T::data_type const& data = grid_type.data(); typename T::feature_key_type const& feature_keys = grid_type.get_feature_keys(); typename T::feature_key_type::const_iterator feature_pos; keys_type keys; // start counting at utf8 codepoint 32, aka space character uint16_t codepoint = 32; mapnik::grid::data_type target(data.width()/resolution,data.height()/resolution); mapnik::scale_grid(target,grid_type.data(),0.0,0.0); unsigned array_size = target.width(); for (unsigned y = 0; y < target.height(); ++y) { uint16_t idx = 0; const std::unique_ptr<Py_UNICODE[]> line(new Py_UNICODE[array_size]); mapnik::grid::value_type * row = target.getRow(y); unsigned x; for (x = 0; x < target.width(); ++x) { feature_pos = feature_keys.find(row[x]); if (feature_pos != feature_keys.end()) { mapnik::grid::lookup_type val = feature_pos->second; keys_iterator key_pos = keys.find(val); if (key_pos == keys.end()) { // Create a new entry for this key. Skip the codepoints that // can't be encoded directly in JSON. if (codepoint == 34) ++codepoint; // Skip " else if (codepoint == 92) ++codepoint; // Skip backslash keys[val] = codepoint; key_order.push_back(val); line[idx++] = static_cast<Py_UNICODE>(codepoint); ++codepoint; } else { line[idx++] = static_cast<Py_UNICODE>(key_pos->second); } } // else, shouldn't get here... } l.append(boost::python::object( boost::python::handle<>( PyUnicode_FromUnicode(line.get(), array_size)))); } }
static PyObject* MakeConnectionString(PyObject* existing, PyObject* parts) { // Creates a connection string from an optional existing connection string plus a dictionary of keyword value // pairs. // // existing // Optional Unicode connection string we will be appending to. Used when a partial connection string is passed // in, followed by keyword parameters: // // connect("driver={x};database={y}", user='******') // // parts // A dictionary of text keywords and text values that will be appended. I(PyUnicode_Check(existing)); Py_ssize_t length = 0; // length in *characters* if (existing) length = Text_Size(existing) + 1; // + 1 to add a trailing semicolon Py_ssize_t pos = 0; PyObject* key = 0; PyObject* value = 0; while (PyDict_Next(parts, &pos, &key, &value)) { length += Text_Size(key) + 1 + Text_Size(value) + 1; // key=value; } PyObject* result = PyUnicode_FromUnicode(0, length); if (!result) return 0; Py_UNICODE* buffer = PyUnicode_AS_UNICODE(result); Py_ssize_t offset = 0; if (existing) { offset += TextCopyToUnicode(&buffer[offset], existing); buffer[offset++] = (Py_UNICODE)';'; } pos = 0; while (PyDict_Next(parts, &pos, &key, &value)) { offset += TextCopyToUnicode(&buffer[offset], key); buffer[offset++] = (Py_UNICODE)'='; offset += TextCopyToUnicode(&buffer[offset], value); buffer[offset++] = (Py_UNICODE)';'; } I(offset == length); return result; }
static PyObject *wpDbResult_getstring(wpDbResult *self, PyObject *args) { unsigned int pos; if (!PyArg_ParseTuple(args, "I:dbresult.getstring(position)", &pos)) { return 0; } QString value = self->result->getString(pos); return PyUnicode_FromUnicode((Py_UNICODE*)value.ucs2(), value.length()); }
PyObject * PyErr_SetFromErrnoWithUnicodeFilename(PyObject *exc, Py_UNICODE *filename) { PyObject *name = filename ? PyUnicode_FromUnicode(filename, wcslen(filename)) : NULL; PyObject *result = PyErr_SetFromErrnoWithFilenameObject(exc, name); Py_XDECREF(name); return result; }
static PyObject * get_nullchar_as_None(Py_UNICODE c) { if (c == '\0') { Py_INCREF(Py_None); return Py_None; } else return PyUnicode_FromUnicode((Py_UNICODE *)&c, 1); }
PyObject *PyCodec_BackslashReplaceErrors(PyObject *exc) { if (PyObject_IsInstance(exc, PyExc_UnicodeEncodeError)) { PyObject *restuple; PyObject *object; Py_ssize_t start; Py_ssize_t end; PyObject *res; Py_UNICODE *p; Py_UNICODE *startp; Py_UNICODE *outp; int ressize; if (PyUnicodeEncodeError_GetStart(exc, &start)) return NULL; if (PyUnicodeEncodeError_GetEnd(exc, &end)) return NULL; if (!(object = PyUnicodeEncodeError_GetObject(exc))) return NULL; startp = PyUnicode_AS_UNICODE(object); for (p = startp+start, ressize = 0; p < startp+end; ++p) { #ifdef Py_UNICODE_WIDE if (*p >= 0x00010000) ressize += 1+1+8; else #endif if (*p >= 0x100) { ressize += 1+1+4; } else ressize += 1+1+2; } res = PyUnicode_FromUnicode(NULL, ressize); if (res==NULL) return NULL; for (p = startp+start, outp = PyUnicode_AS_UNICODE(res); p < startp+end; ++p) { Py_UNICODE c = *p; *outp++ = '\\'; #ifdef Py_UNICODE_WIDE if (c >= 0x00010000) { *outp++ = 'U'; *outp++ = hexdigits[(c>>28)&0xf]; *outp++ = hexdigits[(c>>24)&0xf]; *outp++ = hexdigits[(c>>20)&0xf]; *outp++ = hexdigits[(c>>16)&0xf]; *outp++ = hexdigits[(c>>12)&0xf]; *outp++ = hexdigits[(c>>8)&0xf]; } else #endif if (c >= 0x100) { *outp++ = 'u'; *outp++ = hexdigits[(c>>12)&0xf]; *outp++ = hexdigits[(c>>8)&0xf]; }
static PyObject *_pyhangulic_flush(PY_HANGULIC *self, PyObject *args) { #ifndef Py_UNICODE_WIDE int i; Py_UNICODE *buf; #endif /* !Py_UNICODE_WIDE */ int len; const ucschar *str; str = hangul_ic_flush(self->hic); len = ucscharlen(str); #ifdef Py_UNICODE_WIDE return PyUnicode_FromUnicode((Py_UNICODE*)str, len); #else /* Py_UNICODE_WIDE */ buf = alloca(sizeof(Py_UNICODE) * len); for (i = 0; i < len; i++) buf[i] = str[i]; return PyUnicode_FromUnicode(buf, len); #endif /* Py_UNICODE_WIDE */ }
PyObject* JPyString::fromUnicode(const jchar* str, int len) { Py_UNICODE* value = new Py_UNICODE[len+1]; value[len] = 0; for (int i = 0; i < len; i++) { value[i] = (Py_UNICODE)str[i]; } PY_CHECK( PyObject* obj = PyUnicode_FromUnicode(value, len) ); delete[] value; return obj; }
static PyObject * filters_uwebsafe(PyObject * self, PyObject *args) { PyObject * com; Py_UNICODE * input_buffer; Py_UNICODE *buffer; PyObject * res; int ic=0, ib=0; int len; Py_UNICODE c; if (!(com = unicode_arg(args))) return NULL; input_buffer = PyUnicode_AS_UNICODE(com); len = PyUnicode_GetSize(com); buffer = (Py_UNICODE*)malloc(6*len*sizeof(Py_UNICODE)); for(ic = 0, ib = 0; ic < len; ic++, ib++) { c = input_buffer[ic]; if (c == '&') { buffer[ib++] = (Py_UNICODE)'&'; buffer[ib++] = (Py_UNICODE)'a'; buffer[ib++] = (Py_UNICODE)'m'; buffer[ib++] = (Py_UNICODE)'p'; buffer[ib] = (Py_UNICODE)';'; } else if(c == (Py_UNICODE)'<') { buffer[ib++] = (Py_UNICODE)'&'; buffer[ib++] = (Py_UNICODE)'l'; buffer[ib++] = (Py_UNICODE)'t'; buffer[ib] = (Py_UNICODE)';'; } else if(c == (Py_UNICODE)'>') { buffer[ib++] = (Py_UNICODE)'&'; buffer[ib++] = (Py_UNICODE)'g'; buffer[ib++] = (Py_UNICODE)'t'; buffer[ib] = (Py_UNICODE)';'; } else if(c == (Py_UNICODE)'"') { buffer[ib++] = (Py_UNICODE)'&'; buffer[ib++] = (Py_UNICODE)'q'; buffer[ib++] = (Py_UNICODE)'u'; buffer[ib++] = (Py_UNICODE)'o'; buffer[ib++] = (Py_UNICODE)'t'; buffer[ib] = (Py_UNICODE)';'; } else { buffer[ib] = input_buffer[ic]; } } res = PyUnicode_FromUnicode(buffer, ib); free(buffer); return res; }
static PyUnicodeObject *prepareString(Splitter *self,PyUnicodeObject *o) { PyUnicodeObject *u; u = (PyUnicodeObject*) PyUnicode_FromUnicode(o->str, o->length); if (u != NULL){ if (self->casefolding) fixlower(u); } return u; }
static PyObject *node_to_string(PyObject *node) { PyObject *nodeType, *result, *descendants; nodeType = PyObject_GetAttrString(node, "nodeType"); if (nodeType == NULL) { PyErr_Clear(); return PyUnicode_FromUnicode(NULL, 0); } /* convert DOM node to string */ switch (PyInt_AsLong(nodeType)) { case DOCUMENT_NODE: case ELEMENT_NODE: /* The concatenation of all text descendants in document order */ descendants = PyList_New(0); if (node_descendants(node, descendants) == NULL) { Py_DECREF(descendants); return NULL; } result = PyUnicode_Join(PyUnicode_FromUnicode(NULL, 0), descendants); Py_DECREF(descendants); break; case ATTRIBUTE_NODE: case XPATH_NAMESPACE_NODE: result = PyObject_GetAttrString(node, "value"); break; case PROCESSING_INSTRUCTION_NODE: case COMMENT_NODE: case TEXT_NODE: result = PyObject_GetAttrString(node, "data"); break; default: result = PyUnicode_FromUnicode(NULL, 0); } Py_DECREF(nodeType); return result; }
PyObject *PyErr_SetFromWindowsErrWithUnicodeFilename( int ierr, const Py_UNICODE *filename) { PyObject *name = filename ? PyUnicode_FromUnicode(filename, wcslen(filename)) : NULL; PyObject *result = PyErr_SetExcFromWindowsErrWithFilenameObject( PyExc_WindowsError, ierr, name); Py_XDECREF(name); return result; }
static PyObject * unquote_internal_unicode(PyObject *string, int plus) { PyObject *result; Py_UNICODE *su, *ru; Py_ssize_t j, slen, tlen, sentinel; if (!PyUnicode_CheckExact(string)) { if (!(string = PyObject_Unicode(string))) return NULL; } else Py_INCREF(string); su = PyUnicode_AS_UNICODE(string); slen = tlen = PyUnicode_GET_SIZE(string); for (j=0, sentinel=slen-2; j<sentinel; ++j) { if ( WTF_IS_LATIN1(su[j]) && (su[j] & 0xFF) == '%' && WTF_IS_LATIN1(su[j+1]) && WTF_IS_HEX_DIGIT(su[j+1]) && WTF_IS_LATIN1(su[j+2]) && WTF_IS_HEX_DIGIT(su[j+2])) { tlen -= 2; j += 2; } } if (slen == tlen && !plus) /* shortcut: nothing to unquote */ return string; if (!(result = PyUnicode_FromUnicode(NULL, tlen))) goto done; ru = PyUnicode_AS_UNICODE(result); for (j=0, sentinel=slen-2; j<slen; ++j) { if ( j < sentinel && WTF_IS_LATIN1(su[j]) && (su[j] & 0xFF) == '%' && WTF_IS_LATIN1(su[j+1]) && WTF_IS_HEX_DIGIT(su[j+1]) && WTF_IS_LATIN1(su[j+2]) && WTF_IS_HEX_DIGIT(su[j+2])) { *ru++ = (WTF_HEX_VALUE(su[j+1]) << 4) + (WTF_HEX_VALUE(su[j+2])); j += 2; } else if (plus && su[j] == (unsigned char)'+') { *ru++ = (unsigned char)' '; } else { *ru++ = su[j]; } } done: Py_DECREF(string); return result; }
static PyObject* MakeConnectionString(PyObject* existing, PyObject* parts) { // Creates a connection string from an optional existing connection string plus a dictionary of keyword value // pairs. The keywords must be String objects and the values must be Unicode objects. Py_ssize_t length = 0; if (existing) length = PyUnicode_GET_SIZE(existing) + 1; // + 1 to add a trailing Py_ssize_t pos = 0; PyObject* key = 0; PyObject* value = 0; while (PyDict_Next(parts, &pos, &key, &value)) { length += PyString_GET_SIZE(key) + 1 + PyUnicode_GET_SIZE(value) + 1; // key=value; } PyObject* result = PyUnicode_FromUnicode(0, length); if (!result) return 0; Py_UNICODE* buffer = PyUnicode_AS_UNICODE(result); Py_ssize_t offset = 0; if (existing) { memcpy(&buffer[offset], PyUnicode_AS_UNICODE(existing), PyUnicode_GET_SIZE(existing) * sizeof(Py_UNICODE)); offset += PyUnicode_GET_SIZE(existing); buffer[offset++] = (Py_UNICODE)';'; } pos = 0; while (PyDict_Next(parts, &pos, &key, &value)) { const char* szKey = PyString_AS_STRING(key); for (int i = 0; i < PyString_GET_SIZE(key); i++) buffer[offset++] = (Py_UNICODE)szKey[i]; buffer[offset++] = (Py_UNICODE)'='; memcpy(&buffer[offset], PyUnicode_AS_UNICODE(value), PyUnicode_GET_SIZE(value) * sizeof(Py_UNICODE)); offset += PyUnicode_GET_SIZE(value); buffer[offset++] = (Py_UNICODE)';'; } I(offset == length); return result; }
static PyObject* html_check_spelling(PyObject *self, PyObject *args) { #if PY_VERSION_HEX >= 0x03030000 #error Not implemented for python >= 3.3 #endif PyObject *ans = NULL, *temp = NULL, *items = NULL, *text = NULL, *fmt = NULL, *locale = NULL, *sfmt = NULL, *_store_locale = NULL, *t = NULL, *utmp = NULL; long text_len = 0, start = 0, length = 0, ppos = 0; int store_locale = 0, ok = 0; Py_ssize_t i = 0, j = 0; if (!PyArg_ParseTuple(args, "OlOOOO", &text, &text_len, &fmt, &locale, &sfmt, &_store_locale)) return NULL; store_locale = PyObject_IsTrue(_store_locale); temp = PyObject_GetAttrString(locale, "langcode"); if (temp == NULL) goto error; items = PyObject_CallFunctionObjArgs(split, text, temp, NULL); Py_DECREF(temp); temp = NULL; if (items == NULL) goto error; ans = PyTuple_New((2 * PyList_GET_SIZE(items)) + 1); if (ans == NULL) { PyErr_NoMemory(); goto error; } #define APPEND(x, y) t = Py_BuildValue("lO", (x), y); if (t == NULL) goto error; PyTuple_SET_ITEM(ans, j, t); j += 1; for (i = 0, j = 0; i < PyList_GET_SIZE(items); i++) { temp = PyList_GET_ITEM(items, i); start = PyInt_AS_LONG(PyTuple_GET_ITEM(temp, 0)); length = PyInt_AS_LONG(PyTuple_GET_ITEM(temp, 1)); temp = NULL; if (start > ppos) { APPEND(start - ppos, fmt) } ppos = start + length; utmp = PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(text) + start, length); if (utmp == NULL) { PyErr_NoMemory(); goto error; } temp = PyObject_CallFunctionObjArgs(recognized, utmp, locale, NULL); Py_DECREF(utmp); utmp = NULL; if (temp == NULL) goto error; ok = PyObject_IsTrue(temp); Py_DECREF(temp); temp = NULL; if (ok) { APPEND(length, fmt) } else { if (store_locale) { temp = PyObject_CallFunctionObjArgs(spell_property, sfmt, locale, NULL); if (temp == NULL) goto error; APPEND(length, temp); Py_DECREF(temp); temp = NULL; } else { APPEND(length, sfmt); } } }