Lines Matching defs:size
241 unicode_decode_utf8(const char *s, Py_ssize_t size,
344 _PyUnicode_FromUCS1(const Py_UCS1 *s, Py_ssize_t size);
346 _PyUnicode_FromUCS2(const Py_UCS2 *s, Py_ssize_t size);
348 _PyUnicode_FromUCS4(const Py_UCS4 *s, Py_ssize_t size);
715 Py_ssize_t size, i;
724 size = 0;
725 /* determine replacement size */
738 if (size > PY_SSIZE_T_MAX - incr) {
743 size += incr;
746 str = _PyBytesWriter_Prepare(writer, str, size);
782 Py_ssize_t size, i;
791 size = 0;
792 /* determine replacement size */
813 if (size > PY_SSIZE_T_MAX - incr) {
818 size += incr;
821 str = _PyBytesWriter_Prepare(writer, str, size);
827 size = sprintf(str, "&#%d;", PyUnicode_READ(kind, data, i));
828 if (size < 0) {
831 str += size;
972 Py_ssize_t size, Py_UCS4 ch,
980 return ucs1lib_find_char((const Py_UCS1 *) s, size, (Py_UCS1) ch);
982 return ucs1lib_rfind_char((const Py_UCS1 *) s, size, (Py_UCS1) ch);
987 return ucs2lib_find_char((const Py_UCS2 *) s, size, (Py_UCS2) ch);
989 return ucs2lib_rfind_char((const Py_UCS2 *) s, size, (Py_UCS2) ch);
992 return ucs4lib_find_char((const Py_UCS4 *) s, size, ch);
994 return ucs4lib_rfind_char((const Py_UCS4 *) s, size, ch);
1205 free list never reduces its size below 1.
1220 /* Ensure we won't overflow the size. */
1226 "Negative size passed to _PyUnicode_New");
1366 PyUnicode_New(Py_ssize_t size, Py_UCS4 maxchar)
1369 if (size == 0) {
1412 /* Ensure we won't overflow the size. */
1413 if (size < 0) {
1415 "Negative size passed to PyUnicode_New");
1418 if (size > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1))
1425 obj = (PyObject *) PyObject_Malloc(struct_size + (size + 1) * char_size);
1436 _PyUnicode_LENGTH(unicode) = size;
1444 ((char*)data)[size] = 0;
1448 ((char*)data)[size] = 0;
1458 ((Py_UCS2*)data)[size] = 0;
1460 ((Py_UCS4*)data)[size] = 0;
1462 _PyUnicode_WSTR_LENGTH(unicode) = size;
2143 PyUnicode_FromUnicode(const Py_UNICODE *u, Py_ssize_t size)
2146 if (size > 0) {
2148 "PyUnicode_FromUnicode(NULL, size) is deprecated; "
2153 return (PyObject*)_PyUnicode_New(size);
2156 if (size < 0) {
2161 return PyUnicode_FromWideChar(u, size);
2165 PyUnicode_FromWideChar(const wchar_t *u, Py_ssize_t size)
2171 if (u == NULL && size != 0) {
2176 if (size == -1) {
2177 size = wcslen(u);
2184 if (size == 0)
2191 wchar_t* converted = _Py_DecodeNonUnicodeWchar(u, size);
2195 PyObject *unicode = _PyUnicode_FromUCS4(converted, size);
2203 if (size == 1 && (Py_UCS4)*u < 256)
2208 if (find_maxchar_surrogates(u, u + size,
2212 unicode = PyUnicode_New(size - num_surrogates, maxchar);
2219 u, u + size, PyUnicode_1BYTE_DATA(unicode));
2223 memcpy(PyUnicode_2BYTE_DATA(unicode), u, size * 2);
2226 u, u + size, PyUnicode_2BYTE_DATA(unicode));
2233 unicode_convert_wchar_to_ucs4(u, u + size, unicode);
2236 memcpy(PyUnicode_4BYTE_DATA(unicode), u, size * 4);
2247 PyUnicode_FromStringAndSize(const char *u, Py_ssize_t size)
2249 if (size < 0) {
2251 "Negative size passed to PyUnicode_FromStringAndSize");
2255 return PyUnicode_DecodeUTF8Stateful(u, size, NULL, NULL);
2258 if (size > 0) {
2260 "PyUnicode_FromStringAndSize(NULL, size) is deprecated; "
2265 return (PyObject *)_PyUnicode_New(size);
2272 size_t size = strlen(u);
2273 if (size > PY_SSIZE_T_MAX) {
2277 return PyUnicode_DecodeUTF8Stateful(u, (Py_ssize_t)size, NULL, NULL);
2306 if (index < ids->size) {
2321 if (index >= ids->size) {
2330 memset(&new_array[ids->size], 0, (new_size - ids->size) * item_size);
2332 ids->size = new_size;
2347 for (Py_ssize_t i=0; i < ids->size; i++) {
2350 ids->size = 0;
2361 _PyUnicode_FromASCII(const char *buffer, Py_ssize_t size)
2365 if (size == 1) {
2371 unicode = PyUnicode_New(size, 127);
2374 memcpy(PyUnicode_1BYTE_DATA(unicode), s, size);
2395 _PyUnicode_FromUCS1(const Py_UCS1* u, Py_ssize_t size)
2400 if (size == 0) {
2403 assert(size > 0);
2404 if (size == 1) {
2408 max_char = ucs1lib_find_max_char(u, u + size);
2409 res = PyUnicode_New(size, max_char);
2412 memcpy(PyUnicode_1BYTE_DATA(res), u, size);
2418 _PyUnicode_FromUCS2(const Py_UCS2 *u, Py_ssize_t size)
2423 if (size == 0)
2425 assert(size > 0);
2426 if (size == 1)
2429 max_char = ucs2lib_find_max_char(u, u + size);
2430 res = PyUnicode_New(size, max_char);
2434 memcpy(PyUnicode_2BYTE_DATA(res), u, sizeof(Py_UCS2)*size);
2437 Py_UCS2, Py_UCS1, u, u + size, PyUnicode_1BYTE_DATA(res));
2444 _PyUnicode_FromUCS4(const Py_UCS4 *u, Py_ssize_t size)
2449 if (size == 0)
2451 assert(size > 0);
2452 if (size == 1)
2455 max_char = ucs4lib_find_max_char(u, u + size);
2456 res = PyUnicode_New(size, max_char);
2460 _PyUnicode_CONVERT_BYTES(Py_UCS4, Py_UCS1, u, u + size,
2463 _PyUnicode_CONVERT_BYTES(Py_UCS4, Py_UCS2, u, u + size,
2466 memcpy(PyUnicode_4BYTE_DATA(res), u, sizeof(Py_UCS4)*size);
2472 PyUnicode_FromKindAndData(int kind, const void *buffer, Py_ssize_t size)
2474 if (size < 0) {
2475 PyErr_SetString(PyExc_ValueError, "size must be positive");
2480 return _PyUnicode_FromUCS1(buffer, size);
2482 return _PyUnicode_FromUCS2(buffer, size);
2484 return _PyUnicode_FromUCS4(buffer, size);
3188 unicode_copy_as_widechar(PyObject *unicode, wchar_t *w, Py_ssize_t size)
3196 memcpy(w, wstr, size * sizeof(wchar_t));
3201 memcpy(w, PyUnicode_DATA(unicode), size * sizeof(wchar_t));
3209 for (; size--; ++s, ++w) {
3217 for (; size--; ++s, ++w) {
3223 for (; size--; ++s, ++w) {
3229 if (!size--)
3246 character) required to convert the unicode object. Ignore size argument.
3249 character) written into w. Write at most size wide characters (including
3254 Py_ssize_t size)
3272 if (size > res) {
3273 size = res + 1;
3276 res = size;
3278 unicode_copy_as_widechar(unicode, w, size);
3284 if (_Py_EncodeNonUnicodeWchar_InPlace(w, size) < 0) {
3295 Py_ssize_t *size)
3327 if (size != NULL) {
3328 *size = buflen;
3547 Py_ssize_t size,
3559 if (size == 0) {
3564 return PyUnicode_DecodeUTF8Stateful(s, size, errors, NULL);
3580 return PyUnicode_DecodeUTF8Stateful(s, size, errors, NULL);
3583 return PyUnicode_DecodeUTF16(s, size, errors, 0);
3586 return PyUnicode_DecodeUTF32(s, size, errors, 0);
3592 return PyUnicode_DecodeASCII(s, size, errors);
3596 return PyUnicode_DecodeMBCS(s, size, errors);
3603 return PyUnicode_DecodeLatin1(s, size, errors);
3610 if (PyBuffer_FillInfo(&info, NULL, (void *)s, size, 1, PyBUF_FULL_RO) < 0)
4010 Py_ssize_t size = (Py_ssize_t)strlen(str);
4012 return unicode_decode_locale(str, size, error_handler, 1);
4018 Py_ssize_t size = (Py_ssize_t)strlen(s);
4019 return PyUnicode_DecodeFSDefaultAndSize(s, size);
4023 PyUnicode_DecodeFSDefaultAndSize(const char *s, Py_ssize_t size)
4028 return unicode_decode_utf8(s, size,
4035 return PyUnicode_Decode(s, size,
4050 return unicode_decode_utf8(s, size, errors, NULL, NULL);
4052 return unicode_decode_locale(s, size, errors, 0);
4063 Py_ssize_t size;
4086 size = PyBytes_GET_SIZE(output);
4088 if ((size_t)size != strlen(data)) {
4199 PyUnicode_AsUnicodeAndSize(PyObject *unicode, Py_ssize_t *size)
4227 if (size != NULL)
4228 *size = PyUnicode_WSTR_LENGTH(unicode);
4246 Py_ssize_t size;
4249 wstr = PyUnicode_AsUnicodeAndSize(unicode, &size);
4250 if (wstr && wcslen(wstr) != (size_t)size) {
4368 widechar_resize(wchar_t **buf, Py_ssize_t *size, Py_ssize_t newsize)
4370 if (newsize > *size) {
4378 *size = newsize;
4685 Py_ssize_t size,
4688 return PyUnicode_DecodeUTF7Stateful(s, size, errors, NULL);
4700 Py_ssize_t size,
4718 if (size == 0) {
4726 writer.min_length = size;
4729 e = s + size;
4853 endinpos = size;
5008 Py_ssize_t size,
5011 return PyUnicode_DecodeUTF8Stateful(s, size, errors, NULL);
5037 # error C 'size_t' size should be either 4 or 8!
5095 unicode_decode_utf8(const char *s, Py_ssize_t size,
5099 if (size == 0) {
5106 if (size == 1 && (unsigned char)s[0] < 128) {
5114 const char *end = s + size;
5117 PyObject *u = PyUnicode_New(size, 127);
5243 Py_ssize_t size,
5247 return unicode_decode_utf8(s, size, _Py_ERROR_UNKNOWN, errors, consumed);
5264 _Py_DecodeUTF8Ex(const char *s, Py_ssize_t size, wchar_t **wstr, size_t *wlen,
5288 /* Note: size will always be longer than the resulting Unicode
5290 if (PY_SSIZE_T_MAX / (Py_ssize_t)sizeof(wchar_t) - 1 < size) {
5294 unicode = PyMem_RawMalloc((size + 1) * sizeof(wchar_t));
5300 e = s + size;
5552 Py_ssize_t size = PyUnicode_GET_LENGTH(unicode);
5563 end = ucs1lib_utf8_encoder(&writer, unicode, data, size, error_handler, errors);
5566 end = ucs2lib_utf8_encoder(&writer, unicode, data, size, error_handler, errors);
5569 end = ucs4lib_utf8_encoder(&writer, unicode, data, size, error_handler, errors);
5588 Py_ssize_t size = PyUnicode_GET_LENGTH(unicode);
5597 end = ucs1lib_utf8_encoder(&writer, unicode, data, size,
5601 end = ucs2lib_utf8_encoder(&writer, unicode, data, size,
5605 end = ucs4lib_utf8_encoder(&writer, unicode, data, size,
5649 Py_ssize_t size,
5653 return PyUnicode_DecodeUTF32Stateful(s, size, errors, byteorder, NULL);
5658 Py_ssize_t size,
5675 e = q + size;
5684 if (bo == 0 && size >= 4) {
5700 *consumed = size;
5760 /* remaining bytes at the end? (size should be divisible by 4) */
5932 /* Cut back to size actually needed. This is necessary for, for example,
5960 Py_ssize_t size,
5964 return PyUnicode_DecodeUTF16Stateful(s, size, errors, byteorder, NULL);
5969 Py_ssize_t size,
5987 e = q + size;
5996 if (bo == 0 && size >= 2) {
6012 *consumed = size;
6024 /* Note: size will always be longer than the resulting Unicode
6060 /* remaining byte at the end? (size should be even) */
6271 /* Cut back to size actually needed. This is necessary for, for example,
6302 Py_ssize_t size,
6316 if (size == 0) {
6323 Unicode string, so we start with size here and then reduce the
6328 writer.min_length = size;
6329 if (_PyUnicodeWriter_Prepare(&writer, size, 127) < 0) {
6333 end = s + size;
6343 assert(writer.pos < writer.size); \
6350 assert(writer.pos < writer.size); \
6372 assert(writer.pos < writer.size);
6527 assert(end - s <= writer.size - writer.pos);
6546 Py_ssize_t size,
6551 PyObject *result = _PyUnicode_DecodeUnicodeEscapeInternal(s, size, errors,
6582 Py_ssize_t size,
6585 return _PyUnicode_DecodeUnicodeEscapeStateful(s, size, errors, NULL);
6712 Py_ssize_t size,
6722 if (size == 0) {
6730 Unicode string, so we start with size here and then reduce the
6734 writer.min_length = size;
6735 if (_PyUnicodeWriter_Prepare(&writer, size, 127) < 0) {
6739 end = s + size;
6749 assert(writer.pos < writer.size); \
6783 assert(writer.pos < writer.size);
6831 assert(end - s <= writer.size - writer.pos);
6848 Py_ssize_t size,
6851 return _PyUnicode_DecodeRawUnicodeEscapeStateful(s, size, errors, NULL);
6938 Py_ssize_t size,
6942 return _PyUnicode_FromUCS1((const unsigned char*)s, size);
7053 Py_ssize_t pos=0, size;
7069 size = PyUnicode_GET_LENGTH(unicode);
7074 if (size == 0)
7078 str = _PyBytesWriter_Alloc(&writer, size);
7082 while (pos < size) {
7098 while ((collend < size) && (PyUnicode_READ(kind, data, collend) >= limit))
7102 writer.overallocate = (collend < size);
7175 writer.overallocate = (newpos < size);
7213 assert(writer.overallocate || pos == size);
7258 Py_ssize_t size,
7262 const char *e = s + size;
7267 if (size == 0)
7271 if (size == 1 && (unsigned char)s[0] < 128) {
7276 PyObject *u = PyUnicode_New(size, 127);
7281 if (outpos == size) {
7428 * Returns consumed size if succeed, returns -2 on decode error, or raise an
7442 /* First get the size of the result */
7478 * Returns consumed size if succeed, or raise an OSError or
7485 const char *in, const int size,
7489 const char *endin = in + size;
7507 assert(size > 0);
7516 make_decode_exception(&exc, encoding, in, size, 0, 0, reason);
7526 if (size > (PY_SSIZE_T_MAX - n) / (Py_ssize_t)Py_ARRAY_LENGTH(buffer)) {
7530 if (widechar_resize(buf, bufsize, n + size * Py_ARRAY_LENGTH(buffer)) < 0) {
7594 /* (in - startin) <= size and size is an int */
7606 const char *s, Py_ssize_t size,
7617 if (size < 0) {
7628 if (size > DECODING_CHUNK_SIZE) {
7636 chunk_size = (int)size;
7664 size -= converted;
7675 Py_ssize_t size,
7679 return decode_code_page_stateful(code_page, s, size, errors, consumed);
7684 Py_ssize_t size,
7688 return decode_code_page_stateful(CP_ACP, s, size, errors, consumed);
7693 Py_ssize_t size,
7696 return PyUnicode_DecodeMBCSStateful(s, size, errors, NULL);
7733 Py_ssize_t size;
7754 p = PyUnicode_AsUnicodeAndSize(substring, &size);
7761 p = PyUnicode_AsWideCharString(substring, &size);
7767 assert(size <= INT_MAX);
7769 /* First get the size of the result */
7771 p, (int)size,
7805 p, (int)size,
8107 Py_ssize_t size,
8129 e = s + size;
8226 Py_ssize_t size,
8238 e = s + size;
8328 Py_ssize_t size,
8336 return PyUnicode_DecodeLatin1(s, size, errors);
8338 if (size == 0)
8341 writer.min_length = size;
8346 if (charmap_decode_string(s, size, mapping, errors, &writer) < 0)
8350 if (charmap_decode_mapping(s, size, mapping, errors, &writer) < 0)
8375 EncodingMap.size
8377 Return the size (in bytes) of this object.
8677 Py_ssize_t size, repsize;
8694 size = PyUnicode_GET_LENGTH(unicode);
8696 while (collendpos < size) {
8824 Py_ssize_t size;
8835 size = PyUnicode_GET_LENGTH(unicode);
8845 res = PyBytes_FromStringAndSize(NULL, size);
8848 if (size == 0)
8851 while (inpos<size) {
9197 Py_ssize_t size, i;
9217 size = PyUnicode_GET_LENGTH(input);
9219 if (size == 0)
9225 if (_PyUnicodeWriter_Prepare(&writer, size, 127) == -1)
9245 while (i<size) {
9271 while (collend < size) {
9487 * If counting, the required buffer size is returned.
9489 * need to pass in the buffer size.
11525 to change the structure size, but characters are stored just after
11684 If tabsize is not given, a tab size of 8 characters is assumed.
11702 /* First pass: determine size of output string */
13739 writer->size = PyUnicode_GET_LENGTH(writer->buffer);
13747 /* Copy-on-write mode: set buffer size to 0 so
13750 writer->size = 0;
13775 writer->min_length = writer->size;
13813 else if (newlen > writer->size) {
13842 newbuffer = PyUnicode_New(writer->size, maxchar);
13905 if (maxchar > writer->maxchar || len > writer->size - writer->pos) {
14117 Return the size of the string in memory, in bytes.
14124 Py_ssize_t size;
14129 size = sizeof(PyASCIIObject) + PyUnicode_GET_LENGTH(self) + 1;
14131 size = sizeof(PyCompactUnicodeObject) +
14136 size = sizeof(PyUnicodeObject);
14138 size += (PyUnicode_GET_LENGTH(self) + 1) *
14144 size += (PyUnicode_WSTR_LENGTH(self) + 1) * sizeof(wchar_t);
14146 size += PyUnicode_UTF8_LENGTH(self) + 1;
14148 return PyLong_FromSsize_t(size);
15665 "total size of all interned strings: %zd/%zd mortal/immortal\n",