PyObject* WebPEncode_wrapper(PyObject* self, PyObject* args) { int width; int height; int lossless; float quality_factor; uint8_t* rgb; uint8_t* icc_bytes; uint8_t* exif_bytes; uint8_t* xmp_bytes; uint8_t* output; char* mode; Py_ssize_t size; Py_ssize_t icc_size; Py_ssize_t exif_size; Py_ssize_t xmp_size; size_t ret_size; if (!PyArg_ParseTuple(args, PY_ARG_BYTES_LENGTH"iiifss#s#s#", (char**)&rgb, &size, &width, &height, &lossless, &quality_factor, &mode, &icc_bytes, &icc_size, &exif_bytes, &exif_size, &xmp_bytes, &xmp_size)) { return NULL; } if (strcmp(mode, "RGBA")==0){ if (size < width * height * 4){ Py_RETURN_NONE; } #if WEBP_ENCODER_ABI_VERSION >= 0x0100 if (lossless) { ret_size = WebPEncodeLosslessRGBA(rgb, width, height, 4 * width, &output); } else #endif { ret_size = WebPEncodeRGBA(rgb, width, height, 4 * width, quality_factor, &output); } } else if (strcmp(mode, "RGB")==0){ if (size < width * height * 3){ Py_RETURN_NONE; } #if WEBP_ENCODER_ABI_VERSION >= 0x0100 if (lossless) { ret_size = WebPEncodeLosslessRGB(rgb, width, height, 3 * width, &output); } else #endif { ret_size = WebPEncodeRGB(rgb, width, height, 3 * width, quality_factor, &output); } } else { Py_RETURN_NONE; } #ifndef HAVE_WEBPMUX if (ret_size > 0) { PyObject *ret = PyBytes_FromStringAndSize((char*)output, ret_size); free(output); return ret; } #else { /* I want to truncate the *_size items that get passed into WebP data. Pypy2.1.0 had some issues where the Py_ssize_t items had data in the upper byte. (Not sure why, it shouldn't have been there) */ int i_icc_size = (int)icc_size; int i_exif_size = (int)exif_size; int i_xmp_size = (int)xmp_size; WebPData output_data = {0}; WebPData image = { output, ret_size }; WebPData icc_profile = { icc_bytes, i_icc_size }; WebPData exif = { exif_bytes, i_exif_size }; WebPData xmp = { xmp_bytes, i_xmp_size }; WebPMuxError err; int dbg = 0; int copy_data = 0; // value 1 indicates given data WILL be copied to the mux // and value 0 indicates data will NOT be copied. WebPMux* mux = WebPMuxNew(); WebPMuxSetImage(mux, &image, copy_data); if (dbg) { /* was getting %ld icc_size == 0, icc_size>0 was true */ fprintf(stderr, "icc size %d, %d \n", i_icc_size, i_icc_size > 0); } if (i_icc_size > 0) { if (dbg) { fprintf(stderr, "Adding ICC Profile\n"); } err = WebPMuxSetChunk(mux, "ICCP", &icc_profile, copy_data); if (err != WEBP_MUX_OK) { return HandleMuxError(err, "ICCP"); } } if (dbg) { fprintf(stderr, "exif size %d \n", i_exif_size); } if (i_exif_size > 0) { if (dbg) { fprintf(stderr, "Adding Exif Data\n"); } err = WebPMuxSetChunk(mux, "EXIF", &exif, copy_data); if (err != WEBP_MUX_OK) { return HandleMuxError(err, "EXIF"); } } if (dbg) { fprintf(stderr, "xmp size %d \n", i_xmp_size); } if (i_xmp_size > 0) { if (dbg){ fprintf(stderr, "Adding XMP Data\n"); } err = WebPMuxSetChunk(mux, "XMP ", &xmp, copy_data); if (err != WEBP_MUX_OK) { return HandleMuxError(err, "XMP "); } } WebPMuxAssemble(mux, &output_data); WebPMuxDelete(mux); free(output); ret_size = output_data.size; if (ret_size > 0) { PyObject *ret = PyBytes_FromStringAndSize((char*)output_data.bytes, ret_size); WebPDataClear(&output_data); return ret; } } #endif Py_RETURN_NONE; }
int create_public_key_digest(RSA *private_key_rsa, PyObject **py_public_key_digest, int *public_key_digest_len) { unsigned int err; unsigned char *public_key_der = NULL; size_t der_len; unsigned char *key_digest; size_t key_digest_size; PyObject *py_digest = NULL; int r; EVP_PKEY *public_key = NULL; RSA *public_key_rsa = NULL; assert(private_key_rsa); assert(py_public_key_digest); public_key = EVP_PKEY_new(); JUMP_IF_NULL(public_key, openssl_error); public_key_rsa = RSAPublicKey_dup(private_key_rsa); JUMP_IF_NULL(public_key_rsa, openssl_error); r = EVP_PKEY_set1_RSA(public_key, public_key_rsa); RSA_free(public_key_rsa); public_key_rsa = NULL; JUMP_IF_NEG(r, openssl_error); r = i2d_PUBKEY(public_key, &public_key_der); EVP_PKEY_free(public_key); public_key = NULL; if (r < 0) { free(public_key_der); goto openssl_error; } der_len = r; r = create_key_digest(public_key_der, der_len, &key_digest, &key_digest_size); free(public_key_der); public_key_der = NULL; JUMP_IF_NEG(r, error); py_digest = PyBytes_FromStringAndSize((char *) key_digest, key_digest_size); JUMP_IF_NULL(py_digest, error); *py_public_key_digest = py_digest; if (public_key_digest_len) *public_key_digest_len = key_digest_size; return 0; openssl_error: err = ERR_get_error(); PyErr_Format(g_PyExc_CCNKeyError, "Unable to generate digest from the key:" " %s", ERR_reason_error_string(err)); error: if (public_key_rsa) RSA_free(public_key_rsa); if (public_key) EVP_PKEY_free(public_key); if (public_key_der) free(public_key_der); return -1; }
static PyObject * pylzma_decomp_flush(CDecompressionObject *self, PyObject *args) { PyObject *result=NULL; int res; SizeT avail_out, outsize; unsigned char *tmp; SizeT inProcessed, outProcessed; ELzmaStatus status; if (self->max_length != -1) { avail_out = self->max_length - self->total_out; } else { avail_out = BLOCK_SIZE; } if (avail_out == 0) { // no more remaining data return PyBytes_FromString(""); } result = PyBytes_FromStringAndSize(NULL, avail_out); if (result == NULL) { return NULL; } tmp = (unsigned char *) PyBytes_AS_STRING(result); outsize = 0; while (1) { Py_BEGIN_ALLOW_THREADS if (self->unconsumed_length == 0) { // No remaining data inProcessed = 0; outProcessed = avail_out; res = LzmaDec_DecodeToBuf(&self->state, tmp, &outProcessed, (Byte *) "", &inProcessed, LZMA_FINISH_ANY, &status); } else { // Decompress remaining data inProcessed = self->unconsumed_length; outProcessed = avail_out; res = LzmaDec_DecodeToBuf(&self->state, tmp, &outProcessed, self->unconsumed_tail, &inProcessed, LZMA_FINISH_ANY, &status); self->unconsumed_length -= inProcessed; if (self->unconsumed_length > 0) memmove(self->unconsumed_tail, self->unconsumed_tail + inProcessed, self->unconsumed_length); else FREE_AND_NULL(self->unconsumed_tail); } Py_END_ALLOW_THREADS if (res != SZ_OK) { PyErr_SetString(PyExc_ValueError, "data error during decompression"); DEC_AND_NULL(result); goto exit; } if (!outProcessed && self->max_length != -1 && self->total_out < self->max_length) { PyErr_SetString(PyExc_ValueError, "data error during decompression"); DEC_AND_NULL(result); goto exit; } self->total_out += outProcessed; outsize += outProcessed; if (outProcessed < avail_out || (outProcessed == avail_out && self->max_length != -1)) { break; } if (self->max_length != -1) { PyErr_SetString(PyExc_ValueError, "not enough input data for decompression"); DEC_AND_NULL(result); goto exit; } avail_out -= outProcessed; // Output buffer is full, might be more data for decompression if (_PyBytes_Resize(&result, outsize+BLOCK_SIZE) != 0) { goto exit; } avail_out += BLOCK_SIZE; tmp = (unsigned char *) PyBytes_AS_STRING(result) + outsize; } if (outsize != PyBytes_GET_SIZE(result)) { _PyBytes_Resize(&result, outsize); } exit: return result; }
static PyObject* pyCreatableStub_getData(pyCreatableStub* self) { return PyBytes_FromStringAndSize((const char*)self->fThis->getData(), self->fThis->getLength()); }
/* Reads a buffer of file entry data at a specific offset from EWF file(s) * Returns a Python object holding the data if successful or NULL on error */ PyObject *pyewf_file_entry_read_buffer_at_offset( pyewf_file_entry_t *pyewf_file_entry, PyObject *arguments, PyObject *keywords ) { libcerror_error_t *error = NULL; PyObject *string_object = NULL; static char *function = "pyewf_file_entry_read_buffer_at_offset"; static char *keyword_list[] = { "size", "offset", NULL }; char *buffer = NULL; off64_t read_offset = 0; ssize_t read_count = 0; int read_size = 0; if( pyewf_file_entry == NULL ) { PyErr_Format( PyExc_TypeError, "%s: invalid pyewf file_entry.", function ); return( NULL ); } if( pyewf_file_entry->file_entry == NULL ) { PyErr_Format( PyExc_TypeError, "%s: invalid pyewf file_entry - missing libewf file_entry.", function ); return( NULL ); } if( PyArg_ParseTupleAndKeywords( arguments, keywords, "i|L", keyword_list, &read_size, &read_offset ) == 0 ) { return( NULL ); } if( read_size < 0 ) { PyErr_Format( PyExc_ValueError, "%s: invalid argument read size value less than zero.", function ); return( NULL ); } /* Make sure the data fits into a memory buffer */ if( read_size > INT_MAX ) { PyErr_Format( PyExc_ValueError, "%s: invalid argument read size value exceeds maximum.", function ); return( NULL ); } if( read_offset < 0 ) { PyErr_Format( PyExc_ValueError, "%s: invalid argument read offset value less than zero.", function ); return( NULL ); } /* Make sure the data fits into a memory buffer */ #if PY_MAJOR_VERSION >= 3 string_object = PyBytes_FromStringAndSize( NULL, read_size ); buffer = PyBytes_AsString( string_object ); #else string_object = PyString_FromStringAndSize( NULL, read_size ); buffer = PyString_AsString( string_object ); #endif Py_BEGIN_ALLOW_THREADS read_count = libewf_file_entry_read_buffer_at_offset( pyewf_file_entry->file_entry, (uint8_t *) buffer, (size_t) read_size, (off64_t) read_offset, &error ); Py_END_ALLOW_THREADS if( read_count <= -1 ) { pyewf_error_raise( error, PyExc_IOError, "%s: unable to read data.", function ); libcerror_error_free( &error ); Py_DecRef( (PyObject *) string_object ); return( NULL ); } /* Need to resize the string here in case read_size was not fully read. */ #if PY_MAJOR_VERSION >= 3 if( _PyBytes_Resize( &string_object, (Py_ssize_t) read_count ) != 0 ) #else if( _PyString_Resize( &string_object, (Py_ssize_t) read_count ) != 0 ) #endif { Py_DecRef( (PyObject *) string_object ); return( NULL ); } return( string_object ); }
/** * Construct a Python bytes (str) instance from `std::string`. * * Caller is responsible to DECREF the returned instance. */ inline PyObject* pb_bytes_from_string(const std::string &s) { scoped_gil lk; return PyBytes_FromStringAndSize(s.c_str(), s.size()); }
PyObject * pylzma_compress(PyObject *self, PyObject *args, PyObject *kwargs) { PyObject *result = NULL; CLzmaEncProps props; CLzmaEncHandle encoder=NULL; CMemoryOutStream outStream; CMemoryInStream inStream; Byte header[LZMA_PROPS_SIZE]; size_t headerSize = LZMA_PROPS_SIZE; int res; // possible keywords for this function static char *kwlist[] = {"data", "dictionary", "fastBytes", "literalContextBits", "literalPosBits", "posBits", "algorithm", "eos", "multithreading", "matchfinder", NULL}; int dictionary = 23; // [0,27], default 23 (8MB) int fastBytes = 128; // [5,273], default 128 int literalContextBits = 3; // [0,8], default 3 int literalPosBits = 0; // [0,4], default 0 int posBits = 2; // [0,4], default 2 int eos = 1; // write "end of stream" marker? int multithreading = 1; // use multithreading if available? char *matchfinder = NULL; // matchfinder algorithm int algorithm = 2; char *data; int length; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|iiiiiiiis", kwlist, &data, &length, &dictionary, &fastBytes, &literalContextBits, &literalPosBits, &posBits, &algorithm, &eos, &multithreading, &matchfinder)) return NULL; outStream.data = NULL; CHECK_RANGE(dictionary, 0, 27, "dictionary must be between 0 and 27"); CHECK_RANGE(fastBytes, 5, 273, "fastBytes must be between 5 and 273"); CHECK_RANGE(literalContextBits, 0, 8, "literalContextBits must be between 0 and 8"); CHECK_RANGE(literalPosBits, 0, 4, "literalPosBits must be between 0 and 4"); CHECK_RANGE(posBits, 0, 4, "posBits must be between 0 and 4"); CHECK_RANGE(algorithm, 0, 2, "algorithm must be between 0 and 2"); if (matchfinder != NULL) { #if (PY_VERSION_HEX >= 0x02050000) PyErr_WarnEx(PyExc_DeprecationWarning, "matchfinder selection is deprecated and will be ignored", 1); #else PyErr_Warn(PyExc_DeprecationWarning, "matchfinder selection is deprecated and will be ignored"); #endif } encoder = LzmaEnc_Create(&allocator); if (encoder == NULL) return PyErr_NoMemory(); CreateMemoryInStream(&inStream, (Byte *) data, length); CreateMemoryOutStream(&outStream); LzmaEncProps_Init(&props); props.dictSize = 1 << dictionary; props.lc = literalContextBits; props.lp = literalPosBits; props.pb = posBits; props.algo = algorithm; props.fb = fastBytes; // props.btMode = 1; // props.numHashBytes = 4; // props.mc = 32; props.writeEndMark = eos ? 1 : 0; props.numThreads = multithreading ? 2 : 1; LzmaEncProps_Normalize(&props); res = LzmaEnc_SetProps(encoder, &props); if (res != SZ_OK) { PyErr_Format(PyExc_TypeError, "could not set encoder properties: %d", res); goto exit; } Py_BEGIN_ALLOW_THREADS LzmaEnc_WriteProperties(encoder, header, &headerSize); if (outStream.s.Write(&outStream, header, headerSize) != headerSize) { res = SZ_ERROR_WRITE; } else { res = LzmaEnc_Encode(encoder, &outStream.s, &inStream.s, NULL, &allocator, &allocator); } Py_END_ALLOW_THREADS if (res != SZ_OK) { PyErr_Format(PyExc_TypeError, "Error during compressing: %d", res); goto exit; } result = PyBytes_FromStringAndSize((const char *) outStream.data, outStream.size); exit: if (encoder != NULL) { LzmaEnc_Destroy(encoder, &allocator, &allocator); } if (outStream.data != NULL) { free(outStream.data); } return result; }
static PyObject *parse_qsl(PyObject *self, PyObject *args) { PyObject *pairs; int i, len; PyObject *qso; char unicode = 0; char *qs = NULL; int keep_blank_values = 0; int strict_parsing = 0; /* XXX not implemented */ if (! PyArg_ParseTuple(args, "O|ii", &qso, &keep_blank_values, &strict_parsing)) return NULL; /* error */ if (PyUnicode_Check(qso)) unicode = 1; MP_ANYSTR_AS_STR(qs, qso, 1); if (!qs) { Py_DECREF(qso); /* MP_ANYSTR_AS_STR */ return NULL; } /* split query string by '&' and ';' into a list of pairs */ pairs = PyList_New(0); if (pairs == NULL) { Py_DECREF(qso); /* MP_ANYSTR_AS_STR */ return NULL; } i = 0; len = strlen(qs); while (i < len) { PyObject *pair, *key, *val; char *cpair, *ckey, *cval; int plen, j, p, k, v; pair = PyBytes_FromStringAndSize(NULL, len); if (pair == NULL) return NULL; /* split by '&' or ';' */ cpair = PyBytes_AS_STRING(pair); j = 0; while ((qs[i] != '&') && (qs[i] != ';') && (i < len)) { /* replace '+' with ' ' */ cpair[j] = (qs[i] == '+') ? ' ' : qs[i]; i++; j++; } if (j == 0) { Py_XDECREF(pair); i++; continue; } cpair[j] = '\0'; _PyBytes_Resize(&pair, j); cpair = PyBytes_AS_STRING(pair); /* split the "abc=def" pair */ plen = strlen(cpair); key = PyBytes_FromStringAndSize(NULL, plen); if (key == NULL) { Py_DECREF(qso); /* MP_ANYSTR_AS_STR */ return NULL; } val = PyBytes_FromStringAndSize(NULL, plen); if (val == NULL) { Py_DECREF(qso); /* MP_ANYSTR_AS_STR */ return NULL; } ckey = PyBytes_AS_STRING(key); cval = PyBytes_AS_STRING(val); p = 0; k = 0; v = 0; while (p < plen) { if (cpair[p] != '=') { ckey[k] = cpair[p]; k++; p++; } else { p++; /* skip '=' */ while (p < plen) { cval[v] = cpair[p]; v++; p++; } } } ckey[k] = '\0'; cval[v] = '\0'; if (keep_blank_values || (v > 0)) { ap_unescape_url(ckey); ap_unescape_url(cval); _PyBytes_Resize(&key, strlen(ckey)); _PyBytes_Resize(&val, strlen(cval)); if (key && val) { PyObject *listitem = NULL; if (unicode) { PyObject *ukey, *uval; ukey = PyUnicode_DecodeLatin1(ckey, strlen(ckey), NULL); uval = PyUnicode_DecodeLatin1(cval, strlen(cval), NULL); listitem = Py_BuildValue("(O,O)", ukey, uval); Py_DECREF(ukey); Py_DECREF(uval); } else listitem = Py_BuildValue("(O,O)", key, val); if(listitem) { PyList_Append(pairs, listitem); Py_DECREF(listitem); } } } Py_XDECREF(pair); Py_XDECREF(key); Py_XDECREF(val); i++; } Py_DECREF(qso); return pairs; }
static PyObject *parse_qs(PyObject *self, PyObject *args) { PyObject *pairs, *dict; int i, n, len, lsize; char *qs; PyObject *qso; char unicode = 0; int keep_blank_values = 0; int strict_parsing = 0; /* XXX not implemented */ if (! PyArg_ParseTuple(args, "O|ii", &qso, &keep_blank_values, &strict_parsing)) return NULL; /* error */ if (PyUnicode_Check(qso)) unicode = 1; MP_ANYSTR_AS_STR(qs, qso, 1); if (!qs) { Py_DECREF(qso); /* MP_ANYSTR_AS_STR */ return NULL; } /* split query string by '&' and ';' into a list of pairs */ pairs = PyList_New(0); if (pairs == NULL) { Py_DECREF(qso); return NULL; } i = 0; len = strlen(qs); while (i < len) { PyObject *pair; char *cpair; int j = 0; pair = PyBytes_FromStringAndSize(NULL, len); if (pair == NULL) { Py_DECREF(qso); return NULL; } /* split by '&' or ';' */ cpair = PyBytes_AS_STRING(pair); while ((qs[i] != '&') && (qs[i] != ';') && (i < len)) { /* replace '+' with ' ' */ cpair[j] = (qs[i] == '+') ? ' ' : qs[i]; i++; j++; } if (j) { _PyBytes_Resize(&pair, j); if (pair) PyList_Append(pairs, pair); } Py_XDECREF(pair); i++; } Py_DECREF(qso); /* MP_ANYSTR_AS_STR */ /* * now we have a list of "abc=def" string (pairs), let's split * them all by '=' and put them in a dictionary. */ dict = PyDict_New(); if (dict == NULL) return NULL; lsize = PyList_Size(pairs); n = 0; while (n < lsize) { PyObject *pair, *key, *val; char *cpair, *ckey, *cval; int k, v; pair = PyList_GET_ITEM(pairs, n); cpair = PyBytes_AS_STRING(pair); len = strlen(cpair); key = PyBytes_FromStringAndSize(NULL, len); if (key == NULL) return NULL; val = PyBytes_FromStringAndSize(NULL, len); if (val == NULL) return NULL; ckey = PyBytes_AS_STRING(key); cval = PyBytes_AS_STRING(val); i = 0; k = 0; v = 0; while (i < len) { if (cpair[i] != '=') { ckey[k] = cpair[i]; k++; i++; } else { i++; /* skip '=' */ while (i < len) { cval[v] = cpair[i]; v++; i++; } } } ckey[k] = '\0'; cval[v] = '\0'; if (keep_blank_values || (v > 0)) { ap_unescape_url(ckey); ap_unescape_url(cval); _PyBytes_Resize(&key, strlen(ckey)); _PyBytes_Resize(&val, strlen(cval)); if (key && val) { ckey = PyBytes_AS_STRING(key); cval = PyBytes_AS_STRING(val); if (unicode) { PyObject *list, *ukey, *uval; ukey = PyUnicode_DecodeLatin1(ckey, strlen(ckey), NULL); uval = PyUnicode_DecodeLatin1(ckey, strlen(cval), NULL); list = PyDict_GetItem(dict, ukey); if (list) { PyList_Append(list, uval); Py_DECREF(uval); } else { list = Py_BuildValue("[O]", uval); PyDict_SetItem(dict, ukey, list); Py_DECREF(ukey); Py_DECREF(list); } } else { PyObject *list; list = PyDict_GetItem(dict, key); if (list) PyList_Append(list, val); else { list = Py_BuildValue("[O]", val); PyDict_SetItem(dict, key, list); Py_DECREF(list); } } } } Py_XDECREF(key); Py_XDECREF(val); n++; } Py_DECREF(pairs); return dict; }
static PyObject * _io__IOBase_readline_impl(PyObject *self, Py_ssize_t limit) /*[clinic end generated code: output=4479f79b58187840 input=d0c596794e877bff]*/ { /* For backwards compatibility, a (slowish) readline(). */ int has_peek = 0; PyObject *buffer, *result; Py_ssize_t old_size = -1; _Py_IDENTIFIER(peek); if (_PyObject_HasAttrId(self, &PyId_peek)) has_peek = 1; buffer = PyByteArray_FromStringAndSize(NULL, 0); if (buffer == NULL) return NULL; while (limit < 0 || PyByteArray_GET_SIZE(buffer) < limit) { Py_ssize_t nreadahead = 1; PyObject *b; if (has_peek) { PyObject *readahead = _PyObject_CallMethodId(self, &PyId_peek, "i", 1); if (readahead == NULL) { /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals() when EINTR occurs so we needn't do it ourselves. */ if (_PyIO_trap_eintr()) { continue; } goto fail; } if (!PyBytes_Check(readahead)) { PyErr_Format(PyExc_IOError, "peek() should have returned a bytes object, " "not '%.200s'", Py_TYPE(readahead)->tp_name); Py_DECREF(readahead); goto fail; } if (PyBytes_GET_SIZE(readahead) > 0) { Py_ssize_t n = 0; const char *buf = PyBytes_AS_STRING(readahead); if (limit >= 0) { do { if (n >= PyBytes_GET_SIZE(readahead) || n >= limit) break; if (buf[n++] == '\n') break; } while (1); } else { do { if (n >= PyBytes_GET_SIZE(readahead)) break; if (buf[n++] == '\n') break; } while (1); } nreadahead = n; } Py_DECREF(readahead); } b = _PyObject_CallMethodId(self, &PyId_read, "n", nreadahead); if (b == NULL) { /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals() when EINTR occurs so we needn't do it ourselves. */ if (_PyIO_trap_eintr()) { continue; } goto fail; } if (!PyBytes_Check(b)) { PyErr_Format(PyExc_IOError, "read() should have returned a bytes object, " "not '%.200s'", Py_TYPE(b)->tp_name); Py_DECREF(b); goto fail; } if (PyBytes_GET_SIZE(b) == 0) { Py_DECREF(b); break; } old_size = PyByteArray_GET_SIZE(buffer); if (PyByteArray_Resize(buffer, old_size + PyBytes_GET_SIZE(b)) < 0) { Py_DECREF(b); goto fail; } memcpy(PyByteArray_AS_STRING(buffer) + old_size, PyBytes_AS_STRING(b), PyBytes_GET_SIZE(b)); Py_DECREF(b); if (PyByteArray_AS_STRING(buffer)[PyByteArray_GET_SIZE(buffer) - 1] == '\n') break; } result = PyBytes_FromStringAndSize(PyByteArray_AS_STRING(buffer), PyByteArray_GET_SIZE(buffer)); Py_DECREF(buffer); return result; fail: Py_DECREF(buffer); return NULL; }
python::object getCairoDrawingText(const RDKit::MolDraw2DCairo &self) { std::string res = self.getDrawingText(); python::object retval = python::object( python::handle<>(PyBytes_FromStringAndSize(res.c_str(), res.length()))); return retval; }
PyObject * PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names, PyObject *lineno_obj) { Py_ssize_t i, j, codelen; int nops, h, adj; int tgt, tgttgt, opcode; unsigned char *codestr = NULL; unsigned char *lineno; int *addrmap = NULL; int new_line, cum_orig_line, last_line, tabsiz; PyObject **const_stack = NULL; Py_ssize_t *load_const_stack = NULL; Py_ssize_t const_stack_top = -1; Py_ssize_t const_stack_size = 0; int in_consts = 0; /* whether we are in a LOAD_CONST sequence */ unsigned int *blocks = NULL; char *name; /* Bail out if an exception is set */ if (PyErr_Occurred()) goto exitError; /* Bypass optimization when the lineno table is too complex */ assert(PyBytes_Check(lineno_obj)); lineno = (unsigned char*)PyBytes_AS_STRING(lineno_obj); tabsiz = PyBytes_GET_SIZE(lineno_obj); if (memchr(lineno, 255, tabsiz) != NULL) goto exitUnchanged; /* Avoid situations where jump retargeting could overflow */ assert(PyBytes_Check(code)); codelen = PyBytes_GET_SIZE(code); if (codelen > 32700) goto exitUnchanged; /* Make a modifiable copy of the code string */ codestr = (unsigned char *)PyMem_Malloc(codelen); if (codestr == NULL) goto exitError; codestr = (unsigned char *)memcpy(codestr, PyBytes_AS_STRING(code), codelen); /* Verify that RETURN_VALUE terminates the codestring. This allows the various transformation patterns to look ahead several instructions without additional checks to make sure they are not looking beyond the end of the code string. */ if (codestr[codelen-1] != RETURN_VALUE) goto exitUnchanged; /* Mapping to new jump targets after NOPs are removed */ addrmap = (int *)PyMem_Malloc(codelen * sizeof(int)); if (addrmap == NULL) goto exitError; blocks = markblocks(codestr, codelen); if (blocks == NULL) goto exitError; assert(PyList_Check(consts)); CONST_STACK_CREATE(); for (i=0 ; i<codelen ; i += CODESIZE(codestr[i])) { reoptimize_current: opcode = codestr[i]; if (!in_consts) { CONST_STACK_RESET(); } in_consts = 0; switch (opcode) { /* Replace UNARY_NOT POP_JUMP_IF_FALSE with POP_JUMP_IF_TRUE */ case UNARY_NOT: if (codestr[i+1] != POP_JUMP_IF_FALSE || !ISBASICBLOCK(blocks,i,4)) continue; j = GETARG(codestr, i+1); codestr[i] = POP_JUMP_IF_TRUE; SETARG(codestr, i, j); codestr[i+3] = NOP; goto reoptimize_current; /* not a is b --> a is not b not a in b --> a not in b not a is not b --> a is b not a not in b --> a in b */ case COMPARE_OP: j = GETARG(codestr, i); if (j < 6 || j > 9 || codestr[i+3] != UNARY_NOT || !ISBASICBLOCK(blocks,i,4)) continue; SETARG(codestr, i, (j^1)); codestr[i+3] = NOP; break; /* Replace LOAD_GLOBAL/LOAD_NAME None/True/False with LOAD_CONST None/True/False */ case LOAD_NAME: case LOAD_GLOBAL: j = GETARG(codestr, i); name = _PyUnicode_AsString(PyTuple_GET_ITEM(names, j)); h = load_global(codestr, i, name, consts); if (h < 0) goto exitError; else if (h == 0) continue; CONST_STACK_PUSH_OP(i); break; /* Skip over LOAD_CONST trueconst POP_JUMP_IF_FALSE xx. This improves "while 1" performance. */ case LOAD_CONST: CONST_STACK_PUSH_OP(i); j = GETARG(codestr, i); if (codestr[i+3] != POP_JUMP_IF_FALSE || !ISBASICBLOCK(blocks,i,6) || !PyObject_IsTrue(PyList_GET_ITEM(consts, j))) continue; memset(codestr+i, NOP, 6); CONST_STACK_RESET(); break; /* Try to fold tuples of constants (includes a case for lists and sets which are only used for "in" and "not in" tests). Skip over BUILD_SEQN 1 UNPACK_SEQN 1. Replace BUILD_SEQN 2 UNPACK_SEQN 2 with ROT2. Replace BUILD_SEQN 3 UNPACK_SEQN 3 with ROT3 ROT2. */ case BUILD_TUPLE: case BUILD_LIST: case BUILD_SET: j = GETARG(codestr, i); if (j == 0) break; h = CONST_STACK_OP_LASTN(j); assert((h >= 0 || CONST_STACK_LEN() < j)); if (h >= 0 && j > 0 && j <= CONST_STACK_LEN() && ((opcode == BUILD_TUPLE && ISBASICBLOCK(blocks, h, i-h+3)) || ((opcode == BUILD_LIST || opcode == BUILD_SET) && codestr[i+3]==COMPARE_OP && ISBASICBLOCK(blocks, h, i-h+6) && (GETARG(codestr,i+3)==6 || GETARG(codestr,i+3)==7))) && tuple_of_constants(&codestr[i], j, consts, CONST_STACK_LASTN(j))) { assert(codestr[i] == LOAD_CONST); memset(&codestr[h], NOP, i - h); CONST_STACK_POP(j); CONST_STACK_PUSH_OP(i); break; } if (codestr[i+3] != UNPACK_SEQUENCE || !ISBASICBLOCK(blocks,i,6) || j != GETARG(codestr, i+3) || opcode == BUILD_SET) continue; if (j == 1) { memset(codestr+i, NOP, 6); } else if (j == 2) { codestr[i] = ROT_TWO; memset(codestr+i+1, NOP, 5); CONST_STACK_RESET(); } else if (j == 3) { codestr[i] = ROT_THREE; codestr[i+1] = ROT_TWO; memset(codestr+i+2, NOP, 4); CONST_STACK_RESET(); } break; /* Fold binary ops on constants. LOAD_CONST c1 LOAD_CONST c2 BINOP --> LOAD_CONST binop(c1,c2) */ case BINARY_POWER: case BINARY_MULTIPLY: case BINARY_TRUE_DIVIDE: case BINARY_FLOOR_DIVIDE: case BINARY_MODULO: case BINARY_ADD: case BINARY_SUBTRACT: case BINARY_SUBSCR: case BINARY_LSHIFT: case BINARY_RSHIFT: case BINARY_AND: case BINARY_XOR: case BINARY_OR: /* NOTE: LOAD_CONST is saved at `i-2` since it has an arg while BINOP hasn't */ h = CONST_STACK_OP_LASTN(2); assert((h >= 0 || CONST_STACK_LEN() < 2)); if (h >= 0 && ISBASICBLOCK(blocks, h, i-h+1) && fold_binops_on_constants(&codestr[i], consts, CONST_STACK_LASTN(2))) { i -= 2; memset(&codestr[h], NOP, i - h); assert(codestr[i] == LOAD_CONST); CONST_STACK_POP(2); CONST_STACK_PUSH_OP(i); } break; /* Fold unary ops on constants. LOAD_CONST c1 UNARY_OP --> LOAD_CONST unary_op(c) */ case UNARY_NEGATIVE: case UNARY_INVERT: case UNARY_POSITIVE: h = CONST_STACK_OP_LASTN(1); assert((h >= 0 || CONST_STACK_LEN() < 1)); if (h >= 0 && ISBASICBLOCK(blocks, h, i-h+1) && fold_unaryops_on_constants(&codestr[i-3], consts, CONST_STACK_TOP())) { i -= 2; assert(codestr[i] == LOAD_CONST); CONST_STACK_POP(1); CONST_STACK_PUSH_OP(i); } break; /* Simplify conditional jump to conditional jump where the result of the first test implies the success of a similar test or the failure of the opposite test. Arises in code like: "if a and b:" "if a or b:" "a and b or c" "(a and b) and c" x:JUMP_IF_FALSE_OR_POP y y:JUMP_IF_FALSE_OR_POP z --> x:JUMP_IF_FALSE_OR_POP z x:JUMP_IF_FALSE_OR_POP y y:JUMP_IF_TRUE_OR_POP z --> x:POP_JUMP_IF_FALSE y+3 where y+3 is the instruction following the second test. */ case JUMP_IF_FALSE_OR_POP: case JUMP_IF_TRUE_OR_POP: tgt = GETJUMPTGT(codestr, i); j = codestr[tgt]; if (CONDITIONAL_JUMP(j)) { /* NOTE: all possible jumps here are absolute! */ if (JUMPS_ON_TRUE(j) == JUMPS_ON_TRUE(opcode)) { /* The second jump will be taken iff the first is. */ tgttgt = GETJUMPTGT(codestr, tgt); /* The current opcode inherits its target's stack behaviour */ codestr[i] = j; SETARG(codestr, i, tgttgt); goto reoptimize_current; } else { /* The second jump is not taken if the first is (so jump past it), and all conditional jumps pop their argument when they're not taken (so change the first jump to pop its argument when it's taken). */ if (JUMPS_ON_TRUE(opcode)) codestr[i] = POP_JUMP_IF_TRUE; else codestr[i] = POP_JUMP_IF_FALSE; SETARG(codestr, i, (tgt + 3)); goto reoptimize_current; } } /* Intentional fallthrough */ /* Replace jumps to unconditional jumps */ case POP_JUMP_IF_FALSE: case POP_JUMP_IF_TRUE: case FOR_ITER: case JUMP_FORWARD: case JUMP_ABSOLUTE: case CONTINUE_LOOP: case SETUP_LOOP: case SETUP_EXCEPT: case SETUP_FINALLY: case SETUP_WITH: tgt = GETJUMPTGT(codestr, i); /* Replace JUMP_* to a RETURN into just a RETURN */ if (UNCONDITIONAL_JUMP(opcode) && codestr[tgt] == RETURN_VALUE) { codestr[i] = RETURN_VALUE; memset(codestr+i+1, NOP, 2); continue; } if (!UNCONDITIONAL_JUMP(codestr[tgt])) continue; tgttgt = GETJUMPTGT(codestr, tgt); if (opcode == JUMP_FORWARD) /* JMP_ABS can go backwards */ opcode = JUMP_ABSOLUTE; if (!ABSOLUTE_JUMP(opcode)) tgttgt -= i + 3; /* Calc relative jump addr */ if (tgttgt < 0) /* No backward relative jumps */ continue; codestr[i] = opcode; SETARG(codestr, i, tgttgt); break; case EXTENDED_ARG: if (codestr[i+3] != MAKE_FUNCTION) goto exitUnchanged; /* don't visit MAKE_FUNCTION as GETARG will be wrong */ i += 3; break; /* Replace RETURN LOAD_CONST None RETURN with just RETURN */ /* Remove unreachable JUMPs after RETURN */ case RETURN_VALUE: if (i+4 >= codelen) continue; if (codestr[i+4] == RETURN_VALUE && ISBASICBLOCK(blocks,i,5)) memset(codestr+i+1, NOP, 4); else if (UNCONDITIONAL_JUMP(codestr[i+1]) && ISBASICBLOCK(blocks,i,4)) memset(codestr+i+1, NOP, 3); break; } } /* Fixup linenotab */ for (i=0, nops=0 ; i<codelen ; i += CODESIZE(codestr[i])) { addrmap[i] = i - nops; if (codestr[i] == NOP) nops++; } cum_orig_line = 0; last_line = 0; for (i=0 ; i < tabsiz ; i+=2) { cum_orig_line += lineno[i]; new_line = addrmap[cum_orig_line]; assert (new_line - last_line < 255); lineno[i] =((unsigned char)(new_line - last_line)); last_line = new_line; } /* Remove NOPs and fixup jump targets */ for (i=0, h=0 ; i<codelen ; ) { opcode = codestr[i]; switch (opcode) { case NOP: i++; continue; case JUMP_ABSOLUTE: case CONTINUE_LOOP: case POP_JUMP_IF_FALSE: case POP_JUMP_IF_TRUE: case JUMP_IF_FALSE_OR_POP: case JUMP_IF_TRUE_OR_POP: j = addrmap[GETARG(codestr, i)]; SETARG(codestr, i, j); break; case FOR_ITER: case JUMP_FORWARD: case SETUP_LOOP: case SETUP_EXCEPT: case SETUP_FINALLY: case SETUP_WITH: j = addrmap[GETARG(codestr, i) + i + 3] - addrmap[i] - 3; SETARG(codestr, i, j); break; } adj = CODESIZE(opcode); while (adj--) codestr[h++] = codestr[i++]; } assert(h + nops == codelen); code = PyBytes_FromStringAndSize((char *)codestr, h); CONST_STACK_DELETE(); PyMem_Free(addrmap); PyMem_Free(codestr); PyMem_Free(blocks); return code; exitError: code = NULL; exitUnchanged: CONST_STACK_DELETE(); if (blocks != NULL) PyMem_Free(blocks); if (addrmap != NULL) PyMem_Free(addrmap); if (codestr != NULL) PyMem_Free(codestr); Py_XINCREF(code); return code; }
static PyObject * py_decodepackbits(PyObject *obj, PyObject *args) { int n; char e; char *decoded = NULL; char *encoded = NULL; char *encoded_end = NULL; char *encoded_pos = NULL; unsigned int encoded_len; unsigned int decoded_len; PyObject *byteobj = NULL; PyObject *result = NULL; if (!PyArg_ParseTuple(args, "O", &byteobj)) return NULL; if (!PyBytes_Check(byteobj)) { PyErr_Format(PyExc_TypeError, "expected byte string as input"); goto _fail; } Py_INCREF(byteobj); encoded = PyBytes_AS_STRING(byteobj); encoded_len = (unsigned int)PyBytes_GET_SIZE(byteobj); /* release GIL: byte/string objects are immutable */ Py_BEGIN_ALLOW_THREADS /* determine size of decoded string */ encoded_pos = encoded; encoded_end = encoded + encoded_len; decoded_len = 0; while (encoded_pos < encoded_end) { n = (int)*encoded_pos++; if (n >= 0) { n++; if (encoded_pos+n > encoded_end) n = (int)(encoded_end - encoded_pos); encoded_pos += n; decoded_len += n; } else if (n > -128) { encoded_pos++; decoded_len += 1-n; } } Py_END_ALLOW_THREADS result = PyBytes_FromStringAndSize(0, decoded_len); if (result == NULL) { PyErr_Format(PyExc_MemoryError, "failed to allocate decoded string"); goto _fail; } decoded = PyBytes_AS_STRING(result); Py_BEGIN_ALLOW_THREADS /* decode string */ encoded_end = encoded + encoded_len; while (encoded < encoded_end) { n = (int)*encoded++; if (n >= 0) { n++; if (encoded+n > encoded_end) n = (int)(encoded_end - encoded); /* memmove(decoded, encoded, n); decoded += n; encoded += n; */ while (n--) *decoded++ = *encoded++; } else if (n > -128) { n = 1 - n; e = *encoded++; /* memset(decoded, e, n); decoded += n; */ while (n--) *decoded++ = e; } } Py_END_ALLOW_THREADS Py_DECREF(byteobj); return result; _fail: Py_XDECREF(byteobj); Py_XDECREF(result); return NULL; }
PyObject* WebPDecode_wrapper(PyObject* self, PyObject* args) { PyBytesObject* webp_string; const uint8_t* webp; Py_ssize_t size; PyObject *ret = Py_None, *bytes = NULL, *pymode = NULL, *icc_profile = NULL, *exif = NULL; WebPDecoderConfig config; VP8StatusCode vp8_status_code = VP8_STATUS_OK; char* mode = "RGB"; if (!PyArg_ParseTuple(args, "S", &webp_string)) { return NULL; } if (!WebPInitDecoderConfig(&config)) { Py_RETURN_NONE; } PyBytes_AsStringAndSize((PyObject*) webp_string, (char**)&webp, &size); vp8_status_code = WebPGetFeatures(webp, size, &config.input); if (vp8_status_code == VP8_STATUS_OK) { // If we don't set it, we don't get alpha. // Initialized to MODE_RGB if (config.input.has_alpha) { config.output.colorspace = MODE_RGBA; mode = "RGBA"; } #ifndef HAVE_WEBPMUX vp8_status_code = WebPDecode(webp, size, &config); #else { int copy_data = 0; WebPData data = { webp, size }; WebPMuxFrameInfo image; WebPData icc_profile_data = {0}; WebPData exif_data = {0}; WebPMux* mux = WebPMuxCreate(&data, copy_data); if (NULL == mux) goto end; if (WEBP_MUX_OK != WebPMuxGetFrame(mux, 1, &image)) { WebPMuxDelete(mux); goto end; } webp = image.bitstream.bytes; size = image.bitstream.size; vp8_status_code = WebPDecode(webp, size, &config); if (WEBP_MUX_OK == WebPMuxGetChunk(mux, "ICCP", &icc_profile_data)) icc_profile = PyBytes_FromStringAndSize((const char*)icc_profile_data.bytes, icc_profile_data.size); if (WEBP_MUX_OK == WebPMuxGetChunk(mux, "EXIF", &exif_data)) exif = PyBytes_FromStringAndSize((const char*)exif_data.bytes, exif_data.size); WebPDataClear(&image.bitstream); WebPMuxDelete(mux); } #endif } if (vp8_status_code != VP8_STATUS_OK) goto end; if (config.output.colorspace < MODE_YUV) { bytes = PyBytes_FromStringAndSize((char*)config.output.u.RGBA.rgba, config.output.u.RGBA.size); } else { // Skipping YUV for now. Need Test Images. // UNDONE -- unclear if we'll ever get here if we set mode_rgb* bytes = PyBytes_FromStringAndSize((char*)config.output.u.YUVA.y, config.output.u.YUVA.y_size); } #if PY_VERSION_HEX >= 0x03000000 pymode = PyUnicode_FromString(mode); #else pymode = PyString_FromString(mode); #endif ret = Py_BuildValue("SiiSSS", bytes, config.output.width, config.output.height, pymode, NULL == icc_profile ? Py_None : icc_profile, NULL == exif ? Py_None : exif); end: WebPFreeDecBuffer(&config.output); Py_XDECREF(bytes); Py_XDECREF(pymode); Py_XDECREF(icc_profile); Py_XDECREF(exif); if (Py_None == ret) Py_RETURN_NONE; return ret; }
static object getstate(const IM& im) { const int N = im.W()*im.H()*im.C()*sizeof(value_type); return object( handle<>( PyBytes_FromStringAndSize( (const char*)im.data(), N ) ) ); }
static void __Pyx_AddTraceback(const char *funcname) { PyObject *py_srcfile = 0; PyObject *py_funcname = 0; PyObject *py_globals = 0; PyObject *empty_string = 0; PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(__pyx_filename); #else py_srcfile = PyUnicode_FromString(__pyx_filename); #endif if (!py_srcfile) goto bad; if (__pyx_clineno) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, __pyx_clineno); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, __pyx_clineno); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_globals = PyModule_GetDict(__pyx_m); if (!py_globals) goto bad; #if PY_MAJOR_VERSION < 3 empty_string = PyString_FromStringAndSize("", 0); #else empty_string = PyBytes_FromStringAndSize("", 0); #endif if (!empty_string) goto bad; py_code = PyCode_New( 0, /*int argcount,*/ #if PY_MAJOR_VERSION >= 3 0, /*int kwonlyargcount,*/ #endif 0, /*int nlocals,*/ 0, /*int stacksize,*/ 0, /*int flags,*/ empty_string, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ __pyx_lineno, /*int firstlineno,*/ empty_string /*PyObject *lnotab*/ ); if (!py_code) goto bad; py_frame = PyFrame_New( PyThreadState_GET(), /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ py_globals, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; py_frame->f_lineno = __pyx_lineno; PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); Py_XDECREF(empty_string); Py_XDECREF(py_code); Py_XDECREF(py_frame); }
static PyObject *bytes_unmarshal_alloc(const void *data, Py_ssize_t size, PeerObject &peer) noexcept { return PyBytes_FromStringAndSize(nullptr, size); }
static PyObject* pyGenericPhysical_getTMDBuffer(pyGenericPhysical* self, void*) { return PyBytes_FromStringAndSize((const char*)self->fThis->getTMDBuffer(), self->fThis->getTMDSize()); }
/* Given a path to a Zip file and a toc_entry, return the (uncompressed) data as a new reference. */ static PyObject * get_data(PyObject *archive, PyObject *toc_entry) { PyObject *raw_data = NULL, *data, *decompress; char *buf; FILE *fp; PyObject *datapath; unsigned short compress, time, date; unsigned int crc; Py_ssize_t data_size, file_size, bytes_size; long file_offset, header_size; unsigned char buffer[30]; const char *errmsg = NULL; if (!PyArg_ParseTuple(toc_entry, "OHnnlHHI", &datapath, &compress, &data_size, &file_size, &file_offset, &time, &date, &crc)) { return NULL; } if (data_size < 0) { PyErr_Format(ZipImportError, "negative data size"); return NULL; } fp = _Py_fopen_obj(archive, "rb"); if (!fp) { return NULL; } /* Check to make sure the local file header is correct */ if (fseek(fp, file_offset, 0) == -1) { goto file_error; } if (fread(buffer, 1, 30, fp) != 30) { goto eof_error; } if (get_uint32(buffer) != 0x04034B50u) { /* Bad: Local File Header */ errmsg = "bad local file header"; goto invalid_header; } header_size = (unsigned int)30 + get_uint16(buffer + 26) /* file name */ + get_uint16(buffer + 28) /* extra field */; if (file_offset > LONG_MAX - header_size) { errmsg = "bad local file header size"; goto invalid_header; } file_offset += header_size; /* Start of file data */ if (data_size > LONG_MAX - 1) { fclose(fp); PyErr_NoMemory(); return NULL; } bytes_size = compress == 0 ? data_size : data_size + 1; if (bytes_size == 0) { bytes_size++; } raw_data = PyBytes_FromStringAndSize((char *)NULL, bytes_size); if (raw_data == NULL) { goto error; } buf = PyBytes_AsString(raw_data); if (fseek(fp, file_offset, 0) == -1) { goto file_error; } if (fread(buf, 1, data_size, fp) != (size_t)data_size) { PyErr_SetString(PyExc_OSError, "zipimport: can't read data"); goto error; } fclose(fp); fp = NULL; if (compress != 0) { buf[data_size] = 'Z'; /* saw this in zipfile.py */ data_size++; } buf[data_size] = '\0'; if (compress == 0) { /* data is not compressed */ data = PyBytes_FromStringAndSize(buf, data_size); Py_DECREF(raw_data); return data; } /* Decompress with zlib */ decompress = get_decompress_func(); if (decompress == NULL) { PyErr_SetString(ZipImportError, "can't decompress data; " "zlib not available"); goto error; } data = PyObject_CallFunction(decompress, "Oi", raw_data, -15); Py_DECREF(decompress); Py_DECREF(raw_data); return data; eof_error: set_file_error(archive, !ferror(fp)); goto error; file_error: PyErr_Format(ZipImportError, "can't read Zip file: %R", archive); goto error; invalid_header: assert(errmsg != NULL); PyErr_Format(ZipImportError, "%s: %R", errmsg, archive); goto error; error: if (fp != NULL) { fclose(fp); } Py_XDECREF(raw_data); return NULL; }
static PyObject* DAWGIterator_next(PyObject* self) { if (UNLIKELY(iter->version != iter->dawg->version)) { PyErr_SetString(PyExc_ValueError, "underlaying graph has changed, iterator is not valid anymore"); return NULL; } while (true) { StackItem* item = (StackItem*)list_pop_first(&iter->stack); if (item == NULL or item->node == NULL) return NULL; /* Stop iteration */ const size_t index = item->depth; if (iter->matchtype != MATCH_AT_LEAST_PREFIX and index > iter->pattern_length) { continue; } bool output; switch (iter->matchtype) { case MATCH_EXACT_LENGTH: output = (index == iter->pattern_length); break; case MATCH_AT_MOST_PREFIX: output = (index <= iter->pattern_length); break; case MATCH_AT_LEAST_PREFIX: default: output = (index >= iter->pattern_length); break; } iter->state = item->node; if ((index >= iter->pattern_length) or (iter->use_wildcard and iter->pattern[index] == iter->wildcard)) { const int n = iter->state->n; int i; for (i=0; i < n; i++) { StackItem* new_item = (StackItem*)list_item_new(sizeof(StackItem)); if (not new_item) { PyErr_NoMemory(); return NULL; } new_item->node = iter->state->next[i].child; new_item->letter= iter->state->next[i].letter; new_item->depth = index + 1; list_push_front(&iter->stack, (ListItem*)new_item); } } else { // process single letter const DAWG_LETTER_TYPE ch = iter->pattern[index]; DAWGNode* node = dawgnode_get_child(iter->state, ch); if (node) { StackItem* new_item = (StackItem*)list_item_new(sizeof(StackItem)); if (UNLIKELY(new_item == NULL)) { PyErr_NoMemory(); return NULL; } new_item->node = node; new_item->letter= ch; new_item->depth = index + 1; list_push_front(&iter->stack, (ListItem*)new_item); } } iter->buffer[item->depth] = item->letter; if (output and iter->state->eow) #ifdef DAWG_UNICODE return PyUnicode_FromUnicode(iter->buffer + 1, item->depth); #else return PyBytes_FromStringAndSize((char*)(iter->buffer + 1), item->depth); #endif } }
static PyObject *pylzma_decomp_decompress(CCompatDecompressionObject *self, PyObject *args) { PyObject *result=NULL; char *data; int length, old_length, start_total_out, res, max_length=BLOCK_SIZE; if (!PyArg_ParseTuple(args, "s#|i", &data, &length, &max_length)) return NULL; if (max_length < 0) { PyErr_SetString(PyExc_ValueError, "bufsize must be greater than zero"); return NULL; } start_total_out = self->stream.totalOut; if (self->unconsumed_length > 0) { self->unconsumed_tail = (char *)realloc(self->unconsumed_tail, self->unconsumed_length + length); self->stream.next_in = (Byte *)self->unconsumed_tail; memcpy(self->stream.next_in + self->unconsumed_length, data, length); } else self->stream.next_in = (Byte *)data; self->stream.avail_in = self->unconsumed_length + length; if (max_length && max_length < length) length = max_length; if (!(result = PyBytes_FromStringAndSize(NULL, length))) return NULL; self->stream.next_out = (unsigned char *) PyBytes_AS_STRING(result); self->stream.avail_out = length; Py_BEGIN_ALLOW_THREADS res = lzmaCompatDecode(&self->stream); Py_END_ALLOW_THREADS while (res == LZMA_OK && self->stream.avail_out == 0) { if (max_length && length >= max_length) break; old_length = length; length <<= 1; if (max_length && length > max_length) length = max_length; if (_PyBytes_Resize(&result, length) < 0) goto exit; self->stream.avail_out = length - old_length; self->stream.next_out = (Byte *) PyBytes_AS_STRING(result) + old_length; Py_BEGIN_ALLOW_THREADS res = lzmaCompatDecode(&self->stream); Py_END_ALLOW_THREADS } if (res == LZMA_NOT_ENOUGH_MEM) { // out of memory during decompression PyErr_NoMemory(); DEC_AND_NULL(result); goto exit; } else if (res == LZMA_DATA_ERROR) { PyErr_SetString(PyExc_ValueError, "data error during decompression"); DEC_AND_NULL(result); goto exit; } else if (res != LZMA_OK && res != LZMA_STREAM_END) { PyErr_Format(PyExc_ValueError, "unknown return code from lzmaDecode: %d", res); DEC_AND_NULL(result); goto exit; } /* Not all of the compressed data could be accomodated in the output buffer of specified size. Return the unconsumed tail in an attribute.*/ if (max_length != 0) { if (self->stream.avail_in > 0) { if (self->stream.avail_in != self->unconsumed_length) self->unconsumed_tail = (char *)realloc(self->unconsumed_tail, self->stream.avail_in); if (!self->unconsumed_tail) { PyErr_NoMemory(); DEC_AND_NULL(result); goto exit; } memcpy(self->unconsumed_tail, self->stream.next_in, self->stream.avail_in); } else FREE_AND_NULL(self->unconsumed_tail); self->unconsumed_length = self->stream.avail_in; } /* The end of the compressed data has been reached, so set the unused_data attribute to a string containing the remainder of the data in the string. Note that this is also a logical place to call inflateEnd, but the old behaviour of only calling it on flush() is preserved. */ if (res == LZMA_STREAM_END) { Py_XDECREF(self->unused_data); /* Free original empty string */ self->unused_data = PyBytes_FromStringAndSize((char *) self->stream.next_in, self->stream.avail_in); if (self->unused_data == NULL) { PyErr_NoMemory(); DEC_AND_NULL(result); goto exit; } } _PyBytes_Resize(&result, self->stream.totalOut - start_total_out); exit: return result; }
/* * dst must be of PyTuple_Type with at least natts items slots. */ static int _unpack_tuple_data(PyObject *dst, uint16_t natts, const char *data, Py_ssize_t data_len) { PyObject *ob; uint16_t cnatt = 0; uint32_t attsize = 0; uint32_t position = 0; while (cnatt < natts) { /* * Need enough data for the attribute size. */ if (position + 4 > data_len) { PyErr_Format(PyExc_ValueError, "not enough data available for attribute %d's size header: " "needed %d bytes, but only %lu remain at position %lu", cnatt, 4, data_len - position, position ); return(-1); } memcpy(&attsize, data + position, 4); attsize = local_ntohl(attsize); position += 4; /* * NULL. */ if (attsize == (uint32_t) 0xFFFFFFFFL) { Py_INCREF(Py_None); PyTuple_SET_ITEM(dst, cnatt, Py_None); } else { if ((position + attsize) < position) { /* * Likely a "limitation" over the pure-Python version, *but* * the message content size is limited to 0xFFFFFFFF-4 anyways, * so it is unexpected for an attsize to cause wrap-around. */ PyErr_Format(PyExc_ValueError, "tuple data caused position (uint32_t) " "to wrap on attribute %d, position %lu + size %lu", cnatt, position, attsize ); return(-1); } if (position + attsize > data_len) { PyErr_Format(PyExc_ValueError, "not enough data for attribute %d, size %lu, " "as only %lu bytes remain in message", cnatt, attsize, data_len - position ); return(-1); } ob = PyBytes_FromStringAndSize(data + position, attsize); if (ob == NULL) { /* * Probably an OOM error. */ return(-1); } PyTuple_SET_ITEM(dst, cnatt, ob); position += attsize; } cnatt++; } if (position != data_len) { PyErr_Format(PyExc_ValueError, "invalid tuple(D) message, %lu remaining " "bytes after processing %d attributes", data_len - position, cnatt ); return(-1); } return(0); }
static PyObject * Per_get_serial(cPersistentObject *self) { return PyBytes_FromStringAndSize(self->serial, 8); }
/* * Given a tuple of bytes and None objects, join them into a * a single bytes object with sizes. */ static PyObject * _pack_tuple_data(PyObject *tup) { PyObject *rob; Py_ssize_t natts; Py_ssize_t catt; char *buf = NULL; char *bufpos = NULL; Py_ssize_t bufsize = 0; if (!PyTuple_Check(tup)) { PyErr_Format( PyExc_TypeError, "pack_tuple_data requires a tuple, given %s", PyObject_TypeName(tup) ); return(NULL); } natts = PyTuple_GET_SIZE(tup); if (natts == 0) return(PyBytes_FromString("")); /* discover buffer size and valid att types */ for (catt = 0; catt < natts; ++catt) { PyObject *ob; ob = PyTuple_GET_ITEM(tup, catt); if (ob == Py_None) { bufsize = bufsize + 4; } else if (PyBytes_CheckExact(ob)) { bufsize = bufsize + PyBytes_GET_SIZE(ob) + 4; } else { PyErr_Format( PyExc_TypeError, "cannot serialize attribute %d, expected bytes() or None, got %s", (int) catt, PyObject_TypeName(ob) ); return(NULL); } } buf = malloc(bufsize); if (buf == NULL) { PyErr_Format( PyExc_MemoryError, "failed to allocate %d bytes of memory for packing tuple data", bufsize ); return(NULL); } bufpos = buf; for (catt = 0; catt < natts; ++catt) { PyObject *ob; ob = PyTuple_GET_ITEM(tup, catt); if (ob == Py_None) { uint32_t attsize = 0xFFFFFFFFL; /* Indicates NULL */ memcpy(bufpos, &attsize, 4); bufpos = bufpos + 4; } else { Py_ssize_t size = PyBytes_GET_SIZE(ob); uint32_t msg_size; if (size > 0xFFFFFFFE) { PyErr_Format(PyExc_OverflowError, "data size of %d is greater than attribute capacity", catt ); } msg_size = local_ntohl((uint32_t) size); memcpy(bufpos, &msg_size, 4); bufpos = bufpos + 4; memcpy(bufpos, PyBytes_AS_STRING(ob), PyBytes_GET_SIZE(ob)); bufpos = bufpos + PyBytes_GET_SIZE(ob); } } rob = PyBytes_FromStringAndSize(buf, bufsize); free(buf); return(rob); }
//------------------------------------------------------------------------------------- PyObject* Proxy::pyGetClientDatas() { const std::string& datas = this->getClientDatas(); return PyBytes_FromStringAndSize(datas.data(), datas.size()); }
/* define bytes version of xmlescape */ static PyObject *xmlescape_bytes(PyObject *str, int doquot, int doapos) { Py_ssize_t oldsize; unsigned char *olddata; int maxchar = 127; Py_ssize_t i; Py_ssize_t newsize = 0; unsigned char *newdata; oldsize = PyBytes_GET_SIZE(str); olddata = (unsigned char *)PyBytes_AS_STRING(str); for (i = 0; i < oldsize; ++i) { unsigned char ch = olddata[i]; if (ch == '<') newsize += 4; /* < */ else if (ch == '>') /* Note that we always replace '>' with its entity, not just in case it is part of ']]>' */ newsize += 4; /* > */ else if (ch == '&') newsize += 5; /* & */ else if ((ch == '"') && doquot) newsize += 6; /* " */ else if ((ch == '\'') && doapos) newsize += 5; /* ' */ else if (ch <= 0x8) newsize += 4; else if ((ch >= 0xB) && (ch <= 0x1F) && (ch != 0xD)) newsize += 5; else if ((ch >= 0x7F) && (ch <= 0x9F) && (ch != 0x85)) newsize += 6; else { newsize++; if (ch > maxchar) maxchar = ch; } } if (oldsize==newsize) { /* nothing to replace => return original */ Py_INCREF(str); return str; } else { int index = 0; PyObject *result = PyBytes_FromStringAndSize(NULL, newsize); newdata = (unsigned char *)PyBytes_AS_STRING(result); if (result == NULL) return NULL; for (i = 0; i < oldsize; ++i) { unsigned char ch = olddata[i]; if (ch == '<') { newdata[index++] = '&'; newdata[index++] = 'l'; newdata[index++] = 't'; newdata[index++] = ';'; } else if (ch == '>') { newdata[index++] = '&'; newdata[index++] = 'g'; newdata[index++] = 't'; newdata[index++] = ';'; } else if (ch == '&') { newdata[index++] = '&'; newdata[index++] = 'a'; newdata[index++] = 'm'; newdata[index++] = 'p'; newdata[index++] = ';'; } else if ((ch == '"') && doquot) { newdata[index++] = '&'; newdata[index++] = 'q'; newdata[index++] = 'u'; newdata[index++] = 'o'; newdata[index++] = 't'; newdata[index++] = ';'; } else if ((ch == '\'') && doapos) { newdata[index++] = '&'; newdata[index++] = '#'; newdata[index++] = '3'; newdata[index++] = '9'; newdata[index++] = ';'; } else if (ch <= 0x8) { newdata[index++] = '&'; newdata[index++] = '#'; newdata[index++] = '0'+ch; newdata[index++] = ';'; } else if ((ch >= 0xB) && (ch <= 0x1F) && (ch != 0xD)) { newdata[index++] = '&'; newdata[index++] = '#'; newdata[index++] = '0'+ch/10; newdata[index++] = '0'+ch%10; newdata[index++] = ';'; } else if ((ch >= 0x7F) && (ch <= 0x9F) && (ch != 0x85)) { newdata[index++] = '&'; newdata[index++] = '#'; newdata[index++] = '0'+ch/100; newdata[index++] = '0'+(ch/10)%10; newdata[index++] = '0'+ch%10; newdata[index++] = ';'; } else newdata[index++] = ch; } return result; } }
/* "fib.pyx":5 * while b<n: * print b, * a,b = b,b+a # <<<<<<<<<<<<<< */ __pyx_t_2 = __pyx_v_b; __Pyx_INCREF(__pyx_t_2); __pyx_t_1 = PyNumber_Add(__pyx_v_b, __pyx_v_a); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_v_a); __pyx_v_a = __pyx_t_2; __pyx_t_2 = 0; __Pyx_DECREF(__pyx_v_b); __pyx_v_b = __pyx_t_1; __pyx_t_1 = 0; } __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("fib.fib", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_a); __Pyx_XDECREF(__pyx_v_b); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, __Pyx_NAMESTR("fib"), 0, /* m_doc */ -1, /* m_size */ __pyx_methods /* m_methods */, NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s____main__, __pyx_k____main__, sizeof(__pyx_k____main__), 0, 0, 1, 1}, {&__pyx_n_s____test__, __pyx_k____test__, sizeof(__pyx_k____test__), 0, 0, 1, 1}, {&__pyx_n_s__fib, __pyx_k__fib, sizeof(__pyx_k__fib), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static int __Pyx_InitCachedBuiltins(void) { return 0; } static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants"); __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; return 0; __pyx_L1_error:; return -1; } #if PY_MAJOR_VERSION < 3 PyMODINIT_FUNC initfib(void); /*proto*/ PyMODINIT_FUNC initfib(void) #else PyMODINIT_FUNC PyInit_fib(void); /*proto*/ PyMODINIT_FUNC PyInit_fib(void) #endif { PyObject *__pyx_t_1 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_fib(void)"); if ( __Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #ifdef __pyx_binding_PyCFunctionType_USED if (__pyx_binding_PyCFunctionType_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4(__Pyx_NAMESTR("fib"), __pyx_methods, 0, 0, PYTHON_API_VERSION); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (!__pyx_m) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; #if PY_MAJOR_VERSION < 3 Py_INCREF(__pyx_m); #endif __pyx_b = PyImport_AddModule(__Pyx_NAMESTR(__Pyx_BUILTIN_MODULE_NAME)); if (!__pyx_b) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; if (__Pyx_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; /*--- Initialize various global constants etc. ---*/ if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_module_is_main_fib) { if (__Pyx_SetAttrString(__pyx_m, "__name__", __pyx_n_s____main__) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; } /*--- Builtin init code ---*/ if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Constants init code ---*/ if (unlikely(__Pyx_InitCachedConstants() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Global init code ---*/ /*--- Variable export code ---*/ /*--- Function export code ---*/ /*--- Type init code ---*/ /*--- Type import code ---*/ /*--- Variable import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ /* "fib.pyx":1 * def fib(n): # <<<<<<<<<<<<<< * a ,b = 0,1 * while b<n: */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_3fib_fib, NULL, __pyx_n_s__fib); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyObject_SetAttr(__pyx_m, __pyx_n_s__fib, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(((PyObject *)__pyx_t_1)); if (PyObject_SetAttr(__pyx_m, __pyx_n_s____test__, ((PyObject *)__pyx_t_1)) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(((PyObject *)__pyx_t_1)); __pyx_t_1 = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); if (__pyx_m) { __Pyx_AddTraceback("init fib", __pyx_clineno, __pyx_lineno, __pyx_filename); Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init fib"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if PY_MAJOR_VERSION < 3 return; #else return __pyx_m; #endif }
PyObject * PyFile_GetLine(PyObject *f, int n) { PyObject *result; if (f == NULL) { PyErr_BadInternalCall(); return NULL; } { PyObject *reader; PyObject *args; _Py_IDENTIFIER(readline); reader = _PyObject_GetAttrId(f, &PyId_readline); if (reader == NULL) return NULL; if (n <= 0) args = PyTuple_New(0); else args = Py_BuildValue("(i)", n); if (args == NULL) { Py_DECREF(reader); return NULL; } result = PyEval_CallObject(reader, args); Py_DECREF(reader); Py_DECREF(args); if (result != NULL && !PyBytes_Check(result) && !PyUnicode_Check(result)) { Py_DECREF(result); result = NULL; PyErr_SetString(PyExc_TypeError, "object.readline() returned non-string"); } } if (n < 0 && result != NULL && PyBytes_Check(result)) { char *s = PyBytes_AS_STRING(result); Py_ssize_t len = PyBytes_GET_SIZE(result); if (len == 0) { Py_DECREF(result); result = NULL; PyErr_SetString(PyExc_EOFError, "EOF when reading a line"); } else if (s[len-1] == '\n') { if (result->ob_refcnt == 1) _PyBytes_Resize(&result, len-1); else { PyObject *v; v = PyBytes_FromStringAndSize(s, len-1); Py_DECREF(result); result = v; } } } if (n < 0 && result != NULL && PyUnicode_Check(result)) { Py_ssize_t len = PyUnicode_GET_LENGTH(result); if (len == 0) { Py_DECREF(result); result = NULL; PyErr_SetString(PyExc_EOFError, "EOF when reading a line"); } else if (PyUnicode_READ_CHAR(result, len-1) == '\n') { PyObject *v; v = PyUnicode_Substring(result, 0, len-1); Py_DECREF(result); result = v; } } return result; }
static PyObject * pylzma_decomp_decompress(CDecompressionObject *self, PyObject *args) { PyObject *result=NULL; unsigned char *data; Byte *next_in, *next_out; int length, res, bufsize=BLOCK_SIZE; SizeT avail_in; SizeT inProcessed, outProcessed; ELzmaStatus status; if (!PyArg_ParseTuple(args, "s#|i", &data, &length, &bufsize)){ return NULL; } if (bufsize <= 0) { PyErr_SetString(PyExc_ValueError, "bufsize must be greater than zero"); return NULL; } if (self->unconsumed_length > 0) { self->unconsumed_tail = (unsigned char *) realloc(self->unconsumed_tail, self->unconsumed_length + length); next_in = (unsigned char *) self->unconsumed_tail; memcpy(next_in + self->unconsumed_length, data, length); } else { next_in = data; } if (self->need_properties) { if ((self->unconsumed_length + length) < LZMA_PROPS_SIZE) { // we need enough bytes to read the properties self->unconsumed_tail = (unsigned char *) realloc(self->unconsumed_tail, self->unconsumed_length + length); if (self->unconsumed_tail == NULL) { PyErr_NoMemory(); return NULL; } memcpy(self->unconsumed_tail + self->unconsumed_length, data, length); self->unconsumed_length += length; return PyBytes_FromString(""); } self->unconsumed_length += length; res = LzmaDec_Allocate(&self->state, next_in, LZMA_PROPS_SIZE, &allocator); if (res != SZ_OK) { PyErr_SetString(PyExc_TypeError, "Incorrect stream properties"); return NULL; } next_in += LZMA_PROPS_SIZE; self->unconsumed_length -= LZMA_PROPS_SIZE; if (self->unconsumed_length > 0) { if (self->unconsumed_tail == NULL) { // No remaining data yet self->unconsumed_tail = (unsigned char *) malloc(self->unconsumed_length); if (self->unconsumed_tail == NULL) { PyErr_NoMemory(); return NULL; } memcpy(self->unconsumed_tail, next_in, self->unconsumed_length); next_in = self->unconsumed_tail; } else { // Skip properties in remaining data memmove(self->unconsumed_tail, self->unconsumed_tail+LZMA_PROPS_SIZE, self->unconsumed_length); self->unconsumed_tail = next_in = (unsigned char *) realloc(self->unconsumed_tail, self->unconsumed_length); if (self->unconsumed_tail == NULL) { PyErr_NoMemory(); return NULL; } } } else { FREE_AND_NULL(self->unconsumed_tail); } self->need_properties = 0; LzmaDec_Init(&self->state); } else { self->unconsumed_length += length; } avail_in = self->unconsumed_length; if (avail_in == 0) { // no more bytes to decompress return PyBytes_FromString(""); } result = PyBytes_FromStringAndSize(NULL, bufsize); if (result == NULL) { PyErr_NoMemory(); goto exit; } next_out = (unsigned char *) PyBytes_AS_STRING(result); Py_BEGIN_ALLOW_THREADS // Decompress until EOS marker is reached inProcessed = avail_in; outProcessed = bufsize; res = LzmaDec_DecodeToBuf(&self->state, next_out, &outProcessed, next_in, &inProcessed, LZMA_FINISH_ANY, &status); Py_END_ALLOW_THREADS self->total_out += outProcessed; next_in += inProcessed; avail_in -= inProcessed; if (res != SZ_OK) { DEC_AND_NULL(result); PyErr_SetString(PyExc_ValueError, "data error during decompression"); goto exit; } // Not all of the compressed data could be accomodated in the output buffer // of specified size. Return the unconsumed tail in an attribute. if (avail_in > 0) { if (self->unconsumed_tail == NULL) { // data are in "data" self->unconsumed_tail = (unsigned char *) malloc(avail_in); if (self->unconsumed_tail == NULL) { Py_DECREF(result); PyErr_NoMemory(); goto exit; } memcpy(self->unconsumed_tail, next_in, avail_in); } else { memmove(self->unconsumed_tail, next_in, avail_in); self->unconsumed_tail = (unsigned char *) realloc(self->unconsumed_tail, avail_in); } } else { FREE_AND_NULL(self->unconsumed_tail); } self->unconsumed_length = avail_in; _PyBytes_Resize(&result, outProcessed); exit: return result; }
PyObject* _anim_encoder_assemble(PyObject* self, PyObject* args) { uint8_t* icc_bytes; uint8_t* exif_bytes; uint8_t* xmp_bytes; Py_ssize_t icc_size; Py_ssize_t exif_size; Py_ssize_t xmp_size; WebPData webp_data; WebPAnimEncoderObject* encp = (WebPAnimEncoderObject*)self; WebPAnimEncoder* enc = encp->enc; WebPMux* mux = NULL; PyObject* ret = NULL; if (!PyArg_ParseTuple(args, "s#s#s#", &icc_bytes, &icc_size, &exif_bytes, &exif_size, &xmp_bytes, &xmp_size)) { return NULL; } // Init the output buffer WebPDataInit(&webp_data); // Assemble everything into the output buffer if (!WebPAnimEncoderAssemble(enc, &webp_data)) { PyErr_SetString(PyExc_RuntimeError, WebPAnimEncoderGetError(enc)); return NULL; } // Re-mux to add metadata as needed if (icc_size > 0 || exif_size > 0 || xmp_size > 0) { WebPMuxError err = WEBP_MUX_OK; int i_icc_size = (int)icc_size; int i_exif_size = (int)exif_size; int i_xmp_size = (int)xmp_size; WebPData icc_profile = { icc_bytes, i_icc_size }; WebPData exif = { exif_bytes, i_exif_size }; WebPData xmp = { xmp_bytes, i_xmp_size }; mux = WebPMuxCreate(&webp_data, 1); if (mux == NULL) { PyErr_SetString(PyExc_RuntimeError, "could not re-mux to add metadata"); return NULL; } WebPDataClear(&webp_data); // Add ICCP chunk if (i_icc_size > 0) { err = WebPMuxSetChunk(mux, "ICCP", &icc_profile, 1); if (err != WEBP_MUX_OK) { return HandleMuxError(err, "ICCP"); } } // Add EXIF chunk if (i_exif_size > 0) { err = WebPMuxSetChunk(mux, "EXIF", &exif, 1); if (err != WEBP_MUX_OK) { return HandleMuxError(err, "EXIF"); } } // Add XMP chunk if (i_xmp_size > 0) { err = WebPMuxSetChunk(mux, "XMP ", &xmp, 1); if (err != WEBP_MUX_OK) { return HandleMuxError(err, "XMP"); } } err = WebPMuxAssemble(mux, &webp_data); if (err != WEBP_MUX_OK) { return HandleMuxError(err, NULL); } } // Convert to Python bytes ret = PyBytes_FromStringAndSize((char*)webp_data.bytes, webp_data.size); WebPDataClear(&webp_data); // If we had to re-mux, we should free it now that we're done with it if (mux != NULL) { WebPMuxDelete(mux); } return ret; }