char * PyTokenizer_RestoreEncoding(struct tok_state* tok, int len, int *offset) { char *text = NULL; if (tok->encoding) { /* convert source to original encondig */ PyObject *lineobj = dec_utf8(tok->encoding, tok->buf, len); if (lineobj != NULL) { int linelen = PyString_Size(lineobj); const char *line = PyString_AsString(lineobj); text = PyObject_MALLOC(linelen + 1); if (text != NULL && line != NULL) { if (linelen) strncpy(text, line, linelen); text[linelen] = '\0'; } Py_DECREF(lineobj); /* adjust error offset */ if (*offset > 1) { PyObject *offsetobj = dec_utf8(tok->encoding, tok->buf, *offset-1); if (offsetobj) { *offset = PyString_Size(offsetobj) + 1; Py_DECREF(offsetobj); } } } } return text; }
/* pycalcsims16(window, data1, offset1, data2, offset2); */ static PyObject* pycalcsims16(PyObject* self, PyObject* args) { int window; PyObject* data1; PyObject* data2; int offset1; int offset2; if (!PyArg_ParseTuple(args, "iOiOi", &window, &data1, &offset1, &data2, &offset2)) { return NULL; } if (!PyString_CheckExact(data1) || !PyString_CheckExact(data2)) { PyErr_SetString(PyExc_TypeError, "Must be string"); return NULL; } int length1 = PyString_Size(data1) / sizeof(short); int length2 = PyString_Size(data2) / sizeof(short); if (window < 0 || offset1 < 0 || length1 < offset1+window || offset2 < 0 || length2 < offset2+window) { PyErr_SetString(PyExc_ValueError, "Invalid offset/window"); return NULL; } short* seq1 = (short*)PyString_AsString(data1); short* seq2 = (short*)PyString_AsString(data2); double sim = calcsims16(window, &seq1[offset1], &seq2[offset2]); return PyFloat_FromDouble(sim); }
// comparison function for use with qsort int ctrlp_comp_alpha(const void *a, const void *b) { matchobj_t a_val = *(matchobj_t *)a; matchobj_t b_val = *(matchobj_t *)b; char *a_p = PyString_AsString(a_val.str); long a_len = PyString_Size(a_val.str); char *b_p = PyString_AsString(b_val.str); long b_len = PyString_Size(b_val.str); int order = 0; if (a_len > b_len) { order = strncmp(a_p, b_p, b_len); if (order == 0) order = 1; // shorter string (b) wins } else if (a_len < b_len) { order = strncmp(a_p, b_p, a_len); if (order == 0) order = -1; // shorter string (a) wins } else { order = strncmp(a_p, b_p, a_len); } return order; }
// --------------------------------------------------------------------------------- int SetExtraData( AVCodecContext *cCodec, PyObject* cObj ) { PyObject* obj =PyDict_GetItemString(cObj,EXTRA_DATA); if (!obj || !PyString_Check(obj)) return 0; cCodec->extradata= av_malloc( PyString_Size( obj )); if( !cCodec->extradata ) return -1; cCodec->extradata_size= PyString_Size( obj ); memcpy( cCodec->extradata, PyString_AsString( obj ), cCodec->extradata_size ); return 1; }
// @object PySBinaryArray|A sequence of strings containing binary data. BOOL PyMAPIObject_AsSBinaryArray(PyObject *ob, SBinaryArray *pba) { BOOL bSeq = TRUE; int seqLen; if (PyString_Check(ob)) { seqLen = 1; bSeq = FALSE; } else if (PySequence_Check(ob)) { seqLen = PySequence_Length(ob); } else { PyErr_SetString(PyExc_TypeError, "SBinaryArray must be a sequence of strings"); return FALSE; } DWORD cBytes = (seqLen * sizeof(SBinary)); SBinary *pBin; HRESULT hr = MAPIAllocateBuffer(cBytes, (void **)&pBin); pba->lpbin = pBin; if (FAILED(hr)) { OleSetOleError(hr); return FALSE; } pba->cValues = seqLen; if (bSeq) { for (ULONG i=0; i<(ULONG)seqLen; i++) { PyObject *obItem = PySequence_GetItem(ob, i); if (obItem==NULL) { MAPIFreeBuffer(pba); return FALSE; } if (!PyString_Check(obItem)) { PyErr_SetString(PyExc_TypeError, "SBinary must be a string"); Py_DECREF(obItem); MAPIFreeBuffer(pba); return FALSE; } pBin[i].cb = PyString_Size(obItem); pBin[i].lpb = (LPBYTE )PyString_AsString(obItem); Py_DECREF(obItem); } } else { if (!PyString_Check(ob)) { PyErr_SetString(PyExc_TypeError, "SBinary must be a string"); MAPIFreeBuffer(pba); return FALSE; } // Simple string pBin[0].cb = PyString_Size(ob); pBin[0].lpb = (LPBYTE)PyString_AsString(ob); } return TRUE; }
static PyObject *secure_compare(PyObject *self, PyObject *args) { PyObject *temp_string_one; PyObject *temp_string_two; Py_ssize_t string_size; volatile const unsigned char *left; volatile const unsigned char *right; volatile unsigned char sentinel = 0; int i; /* for use in loops */ /* How many arguments were provided to the function */ if (PyTuple_Size(args) != 2) { PyErr_SetString(PyExc_ValueError, "You must only supply 2 arguments"); return NULL; } /* Can we parse them? */ if (!PyArg_ParseTuple(args, "OO", &temp_string_one, &temp_string_two)) { PyErr_SetString(PyExc_TypeError, "Unable To Parse Function Arguments"); return NULL; } /* Are they Python Strings */ if (!(PyString_CheckExact(temp_string_one)) || !(PyString_CheckExact(temp_string_two))) { PyErr_SetString(PyExc_TypeError, "You must supply 2 string objects"); return NULL; } /* Are they the same size? */ if (PyString_Size(temp_string_one) != PyString_Size(temp_string_two)) { Py_RETURN_FALSE; } left = (const volatile unsigned char *) PyString_AsString(temp_string_one); right = (const volatile unsigned char *) PyString_AsString(temp_string_two); string_size = PyString_Size(temp_string_one); for(i = 0; i < string_size; i++) { sentinel |= *left++ ^ *right++; } return constant_byte_compare(sentinel, 0); }
/* uwsgi MARSHAL|33 */ int uwsgi_request_marshal(struct uwsgi_server *uwsgi, struct wsgi_request *wsgi_req) { PyObject *func_result; PyObject *umm = PyDict_GetItemString(uwsgi->embedded_dict, "message_manager_marshal"); if (umm) { PyObject *ummo = PyMarshal_ReadObjectFromString(wsgi_req->buffer, wsgi_req->uh.pktsize); if (ummo) { if (!PyTuple_SetItem(uwsgi->embedded_args, 0, ummo)) { if (!PyTuple_SetItem(uwsgi->embedded_args, 1, PyInt_FromLong(wsgi_req->uh.modifier2))) { func_result = PyEval_CallObject(umm, uwsgi->embedded_args); if (PyErr_Occurred()) { PyErr_Print(); } if (func_result) { PyObject *marshalled = PyMarshal_WriteObjectToString(func_result, 1); if (!marshalled) { PyErr_Print(); } else { if (PyString_Size(marshalled) <= 0xFFFF) { wsgi_req->uh.pktsize = (uint16_t) PyString_Size(marshalled); if (write(wsgi_req->poll.fd, wsgi_req, 4) == 4) { if (write(wsgi_req->poll.fd, PyString_AsString(marshalled), wsgi_req->uh.pktsize) != wsgi_req->uh.pktsize) { uwsgi_error("write()"); } } else { uwsgi_error("write()"); } } else { fprintf(stderr, "marshalled object is too big. skip\n"); } Py_DECREF(marshalled); } Py_DECREF(func_result); } } } //Py_DECREF(ummo); } } PyErr_Clear(); return 0; }
static jsval to_javascript_object(JSContext *context, PyObject *value) { if (PyString_Check(value)) { JSString *obj = JS_NewStringCopyN(context, PyString_AsString(value), PyString_Size(value)); return STRING_TO_JSVAL(obj); } else if (PyUnicode_Check(value)) { PyObject *encoded = PyUnicode_AsUTF8String(value); JSString *obj = JS_NewStringCopyN(context, PyString_AsString(encoded), PyString_Size(encoded)); Py_DECREF(encoded); return STRING_TO_JSVAL(obj); } else if (PyFloat_Check(value)) { return DOUBLE_TO_JSVAL(PyFloat_AsDouble(value)); } else if (PyInt_Check(value)) { return INT_TO_JSVAL(PyInt_AsLong(value)); } else if (PyLong_Check(value)) { return INT_TO_JSVAL(PyLong_AsLong(value)); } else if (PyList_Check(value)) { JSObject *obj = JS_NewArrayObject(context, 0, NULL); int i; for (i = 0; i < PyList_Size(value); i++) { jsval item = to_javascript_object(context, PyList_GetItem(value, i)); JS_SetElement(context, obj, i, &item); } return OBJECT_TO_JSVAL(obj); } else if (PyTuple_Check(value)) { JSObject *obj = JS_NewArrayObject(context, 0, NULL); int i; for (i = 0; i < PyTuple_Size(value); i++) { jsval item = to_javascript_object(context, PyTuple_GetItem(value, i)); JS_SetElement(context, obj, i, &item); } return OBJECT_TO_JSVAL(obj); } else if (PyDict_Check(value)) { JSObject *obj = JS_NewObject(context, NULL, NULL, NULL); populate_javascript_object(context, obj, value); return OBJECT_TO_JSVAL(obj); } else if (PyDateTime_Check(value)) { JSObject *obj = JS_NewDateObject(context, PyDateTime_GET_YEAR(value), PyDateTime_GET_MONTH(value) - 1, PyDateTime_GET_DAY(value), PyDateTime_DATE_GET_HOUR(value), PyDateTime_DATE_GET_MINUTE(value), PyDateTime_DATE_GET_SECOND(value)); return OBJECT_TO_JSVAL(obj); } else { return JSVAL_NULL; } }
PyObject *py_uwsgi_write(PyObject * self, PyObject * args) { PyObject *data; char *content; size_t content_len; struct wsgi_request *wsgi_req = py_current_wsgi_req(); data = PyTuple_GetItem(args, 0); if (PyString_Check(data)) { content = PyString_AsString(data); content_len = PyString_Size(data); UWSGI_RELEASE_GIL uwsgi_response_write_body_do(wsgi_req, content, content_len); UWSGI_GET_GIL // this is a special case for the write callable // no need to honout write-errors-exception-only if (wsgi_req->write_errors > uwsgi.write_errors_tolerance && !uwsgi.disable_write_exception) { uwsgi_py_write_set_exception(wsgi_req); return NULL; } } Py_INCREF(Py_None); return Py_None; }
static PyObject *uwsgi_Input_readlines(uwsgi_Input *self, PyObject *args) { long hint = 0; if (!PyArg_ParseTuple(args, "|l:readline", &hint)) { return NULL; } PyObject *res = PyList_New(0); for(;;) { PyObject *line = uwsgi_Input_getline(self, hint); if (!line) { Py_DECREF(res); return NULL; } if (PyString_Size(line) == 0) { Py_DECREF(line); return res; } PyList_Append(res, line); Py_DECREF(line); } return res; }
/* Note that this always assumes in and out are sys.stdin and sys.stdout. */ static char *bits_readline_function(FILE *in, FILE *out, char *prompt) { PyObject *pyret; Py_ssize_t len; char *temp; char *ret; (void)in; (void)out; pyret = PyObject_CallFunction(readline_callback, "s", prompt); if (!pyret) return NULL; if (!PyString_Check(pyret)) { PyErr_Format(PyExc_TypeError, "Python readline callback returned a non-string"); return NULL; } temp = PyString_AsString(pyret); if (!temp) return NULL; len = PyString_Size(pyret); ret = PyMem_Malloc(len+1); if (!ret) { PyErr_NoMemory(); return NULL; } return memcpy(ret, temp, len+1); }
BOOL py_to_DEVICEMODE(DEVICEMODE *devmode, PyObject *dict) { PyObject *obj, *dict_copy = PyDict_Copy(dict); BOOL result = False; if (!(obj = PyDict_GetItemString(dict_copy, "private"))) goto done; if (!PyString_Check(obj)) goto done; devmode->dev_private = PyString_AsString(obj); devmode->driverextra = PyString_Size(obj); PyDict_DelItemString(dict_copy, "private"); if (!to_struct(devmode, dict_copy, py_DEVICEMODE)) goto done; result = True; done: Py_DECREF(dict_copy); return result; }
static PyObject * CSVParser_iternext_filelike(CSVParser *self) { char *buf; char c; PyObject *fields = NULL; PyObject *lineobj = NULL; long i; long linelen; Logq_Engine_reset(self->engine); while(!self->engine->is_success){ if (parse_reset(self) < 0) return NULL; do { lineobj = PyIter_Next(self->pyfile); if (lineobj == NULL) { /* End of input OR exception */ if (!PyErr_Occurred() && (self->field_len != 0 || self->state == IN_QUOTED_FIELD)) { if (parse_save_field(self) >= 0 ) break; } return NULL; } ++self->line_num; buf = PyString_AsString(lineobj); linelen = PyString_Size(lineobj); if (buf == NULL || linelen < 0) { return NULL; } for(i=0; i<linelen; ++i){ c = buf[i]; if (c == '\0') { Py_DECREF(lineobj); PyErr_Format(csv_error_obj, "line contains NULL byte"); goto err; } if (parse_process_char(self, c) < 0) { Py_DECREF(lineobj); goto err; } //query fail. go next line if (self->state == QUERY_FAIL){ if(buf[linelen-1]=='\n'){ self->state = START_RECORD; } break; } } Py_DECREF(lineobj); } while (self->state != START_RECORD); } fields = self->fields; self->fields = NULL; err: return fields; }
static PyObject * pygimp_bilinear(PyObject *self, PyObject *args, PyObject *kwargs) { gdouble x, y; gdouble values[4]; PyObject *py_values; static char *kwlist[] = { "x", "y", "values", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ddO:bilinear", kwlist, &x, &y, &py_values)) return NULL; if (PyString_Check(py_values)) { if (PyString_Size(py_values) == 4) { guchar ret; ret = gimp_bilinear_8(x, y, (guchar *)PyString_AsString(py_values)); return PyString_FromStringAndSize((char *)&ret, 1); } } else if (PySequence_Check(py_values)) { if (PySequence_Size(py_values) == 4) { int i; for (i = 0; i < 4; i++) { PyObject *v; v = PySequence_GetItem(py_values, i); values[i] = PyFloat_AsDouble(v); Py_DECREF(v); } return PyFloat_FromDouble(gimp_bilinear(x, y, values)); } } PyErr_SetString(PyExc_TypeError, "values is not a sequence of 4 items"); return NULL; }
int c4_PyStream::Read(void *buffer_, int length_) { PyObject *o = PyObject_CallMethod(_stream, "read", "i", length_); int n = o != 0 ? PyString_Size(o): 0; if (n > 0) memcpy(buffer_, PyString_AsString(o), n); return n; }
static PyObject * find_builtin_names(void) { PyObject *builtins, *names, *key, *value; int pos = 0; builtins = PyEval_GetBuiltins(); if (builtins == NULL || !PyDict_Check(builtins)) { PyErr_SetString(PyExc_SystemError, "no builtins dict!"); return NULL; } names = PyDict_New(); if (names == NULL) return NULL; while (PyDict_Next(builtins, &pos, &key, &value)) { if (PyString_Check(key) && PyString_Size(key) > 0 && PyString_AS_STRING(key)[0] != '_') { if (PyDict_SetItem(names, key, Py_None) < 0) { Py_DECREF(names); return NULL; } } } return names; }
static int __Pyx_Print(PyObject *arg_tuple, int newline) { PyObject *f; PyObject* v; int i; if (!(f = __Pyx_GetStdout())) return -1; for (i=0; i < PyTuple_GET_SIZE(arg_tuple); i++) { if (PyFile_SoftSpace(f, 1)) { if (PyFile_WriteString(" ", f) < 0) return -1; } v = PyTuple_GET_ITEM(arg_tuple, i); if (PyFile_WriteObject(v, f, Py_PRINT_RAW) < 0) return -1; if (PyString_Check(v)) { char *s = PyString_AsString(v); Py_ssize_t len = PyString_Size(v); if (len > 0 && isspace(Py_CHARMASK(s[len-1])) && s[len-1] != ' ') PyFile_SoftSpace(f, 0); } } if (newline) { if (PyFile_WriteString("\n", f) < 0) return -1; PyFile_SoftSpace(f, 0); } return 0; }
// String conversions // Convert a Python string object to a BSTR - allow embedded NULLs, etc. static BOOL PyString_AsBstr(PyObject *stringObject, BSTR *pResult) { int size=PyString_Size(stringObject); const char *buf = PyString_AsString(stringObject); if (buf==NULL) return FALSE; /* We assume that we dont need more 'wide characters' for the result then the number of bytes in the input. Often we will need less, as the input may contain multi-byte chars, but we should never need more */ LPWSTR wstr = (LPWSTR)malloc(size*sizeof(WCHAR)); if (wstr==NULL) { PyErr_SetString(PyExc_MemoryError, "No memory for wide string buffer"); return FALSE; } /* convert and get the final character size */ size = MultiByteToWideChar(CP_ACP, 0, buf, size, wstr, size); *pResult = SysAllocStringLen(wstr, size); if (*pResult==NULL) PyErr_SetString(PyExc_MemoryError, "allocating BSTR"); free(wstr); return *pResult != NULL; }
// Convert a Python object to a "char *" - allow embedded NULLs, None, etc. BOOL PyWinObject_AsString(PyObject *stringObject, char **pResult, BOOL bNoneOK /*= FALSE*/, DWORD *pResultLen /* = NULL */) { PyObject *tempObject = NULL; if (stringObject==Py_None) { if (!bNoneOK) { PyErr_SetString(PyExc_TypeError, "None is not a valid string in this context"); return FALSE; } *pResult = NULL; if (pResultLen) *pResultLen = 0; return TRUE; } // Convert the string if a WIDE string. if (PyUnicode_Check(stringObject)) stringObject = tempObject = PyUnicode_EncodeMBCS(PyUnicode_AS_UNICODE(stringObject), PyUnicode_GET_SIZE(stringObject), NULL); if (!PyString_Check(stringObject)) { PyErr_Format(PyExc_TypeError, "The object must be a string or unicode object (got '%s')", stringObject->ob_type->tp_name); return FALSE; } char *temp = PyString_AsString(stringObject); int len = PyString_Size(stringObject); *pResult = (char *)PyMem_Malloc(len+1); if (*pResult) { memcpy(*pResult, temp, len+1); if (pResultLen) *pResultLen = len; } Py_XDECREF(tempObject); return (*pResult != NULL); }
struct matcher_entry *matchers_get_response(u_char *data, u_int datalen, struct ctx *ctx, u_int type, u_int src_port, u_int dst_port) { struct matcher_entry *matcher; #ifdef HAVE_PYTHON PyObject *args; PyObject *value; Py_ssize_t rdatalen; char *rdata; #endif if(!(matcher = matchers_match((const char *)data, datalen, ctx, type, src_port, dst_port))) { logger(DBG, "No matchers found for data"); return NULL; } #ifdef HAVE_PYTHON if(matcher->pyfunc) { logger(DBG, "We have a Python code to construct response"); args = PyTuple_New(2); PyTuple_SetItem(args,0,PyString_FromStringAndSize((const char *)data, datalen)); // here is data PyTuple_SetItem(args,1,PyInt_FromSsize_t(datalen)); value = PyObject_CallObject(matcher->pyfunc, args); if(value == NULL) { PyErr_Print(); logger(WARN, "Python function returns no data!"); return NULL; } rdata = PyString_AsString(value); rdatalen = PyString_Size(value); if(rdata != NULL && rdatalen > 0) { matcher->response_len = (u_int) rdatalen; if(matcher->response) { // We already have previous response, free it free(matcher->response); } matcher->response = malloc(matcher->response_len); memcpy(matcher->response, (u_char *) rdata, rdatalen); } else { PyErr_Print(); logger(WARN, "Python cannot convert return string"); return NULL; } return matcher; } #endif if(matcher->response) { logger(DBG, "We have a plain text response"); return matcher; } logger(WARN, "There is no response data!"); return NULL; }
PyObject * Filter_SubFileDecode(PyObject * self, PyObject * args) { PyObject * target; PyObject * delim_object; SubFileDecodeState * state; int length; if (!PyArg_ParseTuple(args, "OS", &target, &delim_object)) return NULL; length = PyString_Size(delim_object); if (length < 1) return PyErr_Format(PyExc_ValueError, "empty delimiter"); state = PyMem_Malloc(sizeof (SubFileDecodeState) + length * sizeof(int)); if (!state) return PyErr_NoMemory(); state->delim_object = delim_object; Py_INCREF(state->delim_object); state->delim = PyString_AsString(delim_object); state->chars_matched = 0; state->length = length; init_shift(state); return Filter_NewDecoder(target, "SubFileDecode", 0, read_subfile, NULL, dealloc_subfile, state); }
PyObject* vm_set_mem(JitCpu *self, PyObject* args) { PyObject *py_addr; PyObject *py_buffer; Py_ssize_t py_length; char * buffer; uint64_t size; uint64_t addr; int ret = 0x1337; if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer)) return NULL; PyGetInt(py_addr, addr); if(!PyString_Check(py_buffer)) RAISE(PyExc_TypeError,"arg must be str"); size = PyString_Size(py_buffer); PyString_AsStringAndSize(py_buffer, &buffer, &py_length); ret = vm_write_mem(&(((VmMngr*)self->pyvm)->vm_mngr), addr, buffer, size); if (ret < 0) RAISE(PyExc_TypeError,"arg must be str"); check_automod(self, addr, size*8); Py_INCREF(Py_None); return Py_None; }
/* {{{ pip_pyobject_to_zval(PyObject *obj) Converts the given PyObject into an equivalent zval */ zval * pip_pyobject_to_zval(PyObject *obj) { zval *ret; if (obj == NULL) { return NULL; } /* Initialize the return value */ MAKE_STD_ZVAL(ret); if (PyInt_Check(obj)) { ZVAL_LONG(ret, PyInt_AsLong(obj)); } else if (PyLong_Check(obj)) { ZVAL_LONG(ret, PyLong_AsLong(obj)); } else if (PyFloat_Check(obj)) { ZVAL_DOUBLE(ret, PyFloat_AsDouble(obj)); } else if (PyString_Check(obj)) { ZVAL_STRINGL(ret, PyString_AsString(obj), PyString_Size(obj), 1); } else if (obj == Py_None) { ZVAL_NULL(ret); } else if (PyTuple_Check(obj) || PyList_Check(obj)) { ret = pip_sequence_to_hash(obj); } else if (PyDict_Check(obj)) { ret = pip_mapping_to_hash(obj); } else { ret = pip_pyobject_to_zobject(obj); } return ret; }
static int LogCount_sethash(LogCount *self, PyObject *value, void *closure) { if (!value) { PyErr_SetString(PyExc_TypeError, "cannot delete the hash attribute"); return -1; } if (! PyString_Check(value)) { PyErr_SetString(PyExc_TypeError, "hash attribute must be a string"); return -1; } int len = PyString_Size(value); if (len % sizeof(int)) { PyErr_SetString(PyExc_ValueError, "hash attribute must be a string whose length is even mod 4"); return -1; } int nhash = len / sizeof(int); if (nhash != self->lc.nhash) { logcount_finish(&self->lc); logcount_init(&self->lc, nhash); } memcpy(self->lc.hashes, PyString_AsString(value), len); return 0; }
static int Pixels__setitem__ (PixelsObject *self, int i, PyObject *val) { dbg(); if (i < 0) i = i + self->length; if (i >= self->length || i < 0) { PyErr_SetString (PyExc_IndexError, "pixel index out of range"); return -1; } if (PyInt_Check(val)) { self->pixels[i] = (int) PyInt_AsLong (val); return 0; } if (!PyString_Check(val) || PyString_Size(val) != 1) { PyErr_SetString (PyExc_TypeError, "assignment value isn't a character"); return -1; } self->pixels[i] = PyString_AsString(val)[0]; return 0; }
static TDB_DATA PyString_AsTDB_DATA(PyObject *data) { TDB_DATA ret; ret.dptr = (unsigned char *)PyString_AsString(data); ret.dsize = PyString_Size(data); return ret; }
/* Replace any occurances of "\r\n?" in the input string with "\n". This converts DOS and Mac line endings to Unix line endings. Also append a trailing "\n" to be compatible with PyParser_SimpleParseFile(). Returns a new reference. */ static PyObject * normalize_line_endings(PyObject *source) { char *buf, *q, *p = PyString_AsString(source); PyObject *fixed_source; if (!p) return NULL; /* one char extra for trailing \n and one for terminating \0 */ buf = (char *)PyMem_Malloc(PyString_Size(source) + 2); if (buf == NULL) { PyErr_SetString(PyExc_MemoryError, "zipimport: no memory to allocate " "source buffer"); return NULL; } /* replace "\r\n?" by "\n" */ for (q = buf; *p != '\0'; p++) { if (*p == '\r') { *q++ = '\n'; if (*(p + 1) == '\n') p++; } else *q++ = *p; } *q++ = '\n'; /* add trailing \n */ *q = '\0'; fixed_source = PyString_FromString(buf); PyMem_Free(buf); return fixed_source; }
static CORBA_TypeCode get_union_tc(CORBA_TypeCode tc, PyObject *discrim) { CORBA_TypeCode subtc = NULL; glong discriminator, i; if (PyString_Check(discrim)) { if (PyString_Size(discrim) != 1) return NULL; discriminator = *(CORBA_octet *)PyString_AsString(discrim); } else { discriminator = PyInt_AsLong(discrim); if (PyErr_Occurred()) return NULL; } for (i = 0; i < tc->sub_parts; i++) { if (i == tc->default_index) continue; if (tc->sublabels[i] == discriminator) { subtc = tc->subtypes[i]; break; } } if (i == tc->sub_parts) { if (tc->default_index >= 0) subtc = tc->subtypes[tc->default_index]; else subtc = TC_null; } return subtc; }
/** Convert a Python decimal.Decimal to MySQL DECIMAL. Convert a Python decimal.Decimal to MySQL DECIMAL. This function also removes the 'L' suffix from the resulting string when using Python v2. @param obj PyObject to be converted @return Converted decimal as string @retval PyBytes Python v3 @retval PyString Python v2 */ PyObject* pytomy_decimal(PyObject *obj) { #ifdef PY3 return PyBytes_FromString((const char *)PyUnicode_1BYTE_DATA( PyObject_Str(obj))); #else PyObject *numeric, *new_num; int tmp_size; char *tmp; numeric= PyObject_Str(obj); tmp= PyString_AsString(numeric); tmp_size= (int)PyString_Size(numeric); if (tmp[tmp_size - 1] == 'L') { new_num= PyString_FromStringAndSize(tmp, tmp_size); _PyString_Resize(&new_num, tmp_size - 1); return new_num; } else { return numeric; } #endif }
/* New reference. */ static PyObject * normalize_module(PyObject *filename) { PyObject *module; const char *mod_str; Py_ssize_t len; int rc = PyObject_IsTrue(filename); if (rc == -1) return NULL; else if (rc == 0) return PyString_FromString("<unknown>"); mod_str = PyString_AsString(filename); if (mod_str == NULL) return NULL; len = PyString_Size(filename); if (len < 0) return NULL; if (len >= 3 && strncmp(mod_str + (len - 3), ".py", 3) == 0) { module = PyString_FromStringAndSize(mod_str, len-3); } else { module = filename; Py_INCREF(module); } return module; }