Lines Matching refs:data
154 (_PyUnicodeObject_CAST(op)->data.any)
172 (not shared with other data) */
179 (not shared with other data) */
272 unicode_fill(enum PyUnicode_Kind kind, void *data, Py_UCS4 value,
281 Py_UCS1 *to = (Py_UCS1 *)data + start;
288 Py_UCS2 *to = (Py_UCS2 *)data + start;
296 Py_UCS4 * to = (Py_UCS4 *)data + start;
518 void *data;
521 data = compact + 1;
527 CHECK(compact->utf8 != data);
532 data = unicode->data.any;
541 CHECK(data == NULL);
550 CHECK(data != NULL);
552 CHECK(compact->utf8 == data);
556 CHECK(compact->utf8 != data);
568 CHECK(ascii->wstr == data);
571 CHECK(ascii->wstr != data);
584 const void *data;
587 data = PyUnicode_DATA(ascii);
590 ch = PyUnicode_READ(kind, data, i);
610 CHECK(PyUnicode_READ(kind, data, ascii->length) == 0);
670 const Py_UCS1 *data = PyUnicode_1BYTE_DATA(unicode);
671 Py_UCS1 ch = data[0];
718 const void *data;
722 data = PyUnicode_DATA(unicode);
729 ch = PyUnicode_READ(kind, data, i);
752 ch = PyUnicode_READ(kind, data, i);
785 const void *data;
789 data = PyUnicode_DATA(unicode);
796 ch = PyUnicode_READ(kind, data, i);
827 size = sprintf(str, "&#%d;", PyUnicode_READ(kind, data, i));
869 TYPE *data = (TYPE *)PTR; \
870 TYPE *end = data + LEN; \
872 for (; data != end; data++) { \
873 ch = *data; \
1001 /* Fill the data of a Unicode string with invalid characters to detect bugs
1011 Py_UCS1 *data = PyUnicode_1BYTE_DATA(unicode);
1015 memset(data + old_length * kind, 0xff, (length - old_length) * kind);
1101 void *data;
1106 data = _PyUnicode_DATA_ANY(unicode);
1124 data = (PyObject *)PyObject_Realloc(data, new_size);
1125 if (data == NULL) {
1129 _PyUnicode_DATA_ANY(unicode) = data;
1131 _PyUnicode_WSTR(unicode) = data;
1135 _PyUnicode_UTF8(unicode) = data;
1139 PyUnicode_WRITE(PyUnicode_KIND(unicode), data, length, 0);
1326 printf("compact data %p\n", _PyUnicode_COMPACT_DATA(unicode));
1336 const void *data;
1341 data = (ascii + 1);
1343 data = (compact + 1);
1346 data = unicode->data.any;
1349 if (ascii->wstr == data)
1355 if (!ascii->state.compact && compact->utf8 == unicode->data.any) {
1360 printf(", data=%p\n", data);
1375 void *data;
1423 * it's data buffer.
1433 data = ((PyASCIIObject*)obj) + 1;
1435 data = unicode + 1;
1444 ((char*)data)[size] = 0;
1448 ((char*)data)[size] = 0;
1458 ((Py_UCS2*)data)[size] = 0;
1460 ((Py_UCS4*)data)[size] = 0;
1463 _PyUnicode_WSTR(unicode) = (wchar_t *)data;
2068 const void *data = PyUnicode_DATA(unicode);
2082 memcpy((char *) data + index, str, len);
2086 Py_UCS2 *start = (Py_UCS2 *)data + index;
2096 Py_UCS4 *start = (Py_UCS4 *)data + index;
2180 /* If the Unicode data is known at construction time, we can apply
2206 /* If not empty and not single character, copy the Unicode data
2604 unicode_askind(unsigned int skind, void const *data, Py_ssize_t len, unsigned int kind)
2617 (const Py_UCS1 *)data,
2618 ((const Py_UCS1 *)data) + len,
2628 (const Py_UCS2 *)data,
2629 ((const Py_UCS2 *)data) + len,
2636 (const Py_UCS1 *)data,
2637 ((const Py_UCS1 *)data) + len,
2652 const void *data;
2657 data = PyUnicode_DATA(string);
2679 const Py_UCS1 *start = (const Py_UCS1 *) data;
2683 const Py_UCS2 *start = (const Py_UCS2 *) data;
2687 memcpy(target, data, len * sizeof(Py_UCS4));
3434 return a true Unicode object with the same data. */
4064 const char *data;
4087 data = PyBytes_AS_STRING(output);
4088 if ((size_t)size != strlen(data)) {
4292 const void *data;
4306 data = PyUnicode_DATA(unicode);
4308 return PyUnicode_READ(kind, data, index);
4871 writer.kind, writer.data, shiftOutStart);
4903 const void *data;
4916 data = PyUnicode_DATA(str);
4931 Py_UCS4 ch = PyUnicode_READ(kind, data, i);
5142 ch = asciilib_utf8_decode(&s, end, writer.data, &writer.pos);
5144 ch = ucs1lib_utf8_decode(&s, end, writer.data, &writer.pos);
5146 ch = ucs2lib_utf8_decode(&s, end, writer.data, &writer.pos);
5149 ch = ucs4lib_utf8_decode(&s, end, writer.data, &writer.pos);
5156 errmsg = "unexpected end of data";
5207 PyUnicode_WRITE(writer.kind, writer.data, writer.pos,
5299 /* Unpack UTF-8 encoded data */
5344 *reason = "unexpected end of data";
5551 const void *data = PyUnicode_DATA(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);
5587 const void *data = PyUnicode_DATA(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,
5722 void *data = writer.data;
5733 PyUnicode_WRITE(kind, data, pos++, ch);
5745 PyUnicode_WRITE(kind, data, pos++, ch);
5761 errmsg = "truncated data";
5807 const void *data;
5829 data = PyUnicode_DATA(str);
5855 ucs1lib_utf32_encode((const Py_UCS1 *)data, len, &out, native_ordering);
5864 pos += ucs2lib_utf32_encode((const Py_UCS2 *)data + pos, len - pos,
5869 pos += ucs4lib_utf32_encode((const Py_UCS4 *)data + pos, len - pos,
6039 (Py_UCS1*)writer.data, &writer.pos,
6043 (Py_UCS1*)writer.data, &writer.pos,
6047 (Py_UCS2*)writer.data, &writer.pos,
6052 (Py_UCS4*)writer.data, &writer.pos,
6063 errmsg = "truncated data";
6073 errmsg = "unexpected end of data";
6128 const void *data;
6151 data = PyUnicode_DATA(str);
6156 const Py_UCS4 *in = (const Py_UCS4 *)data;
6184 ucs1lib_utf16_encode((const Py_UCS1 *)data, len, &out, native_ordering);
6203 pos += ucs2lib_utf16_encode((const Py_UCS2 *)data + pos, len - pos,
6208 pos += ucs4lib_utf16_encode((const Py_UCS4 *)data + pos, len - pos,
6344 PyUnicode_WRITE(writer.kind, writer.data, writer.pos++, ch); \
6351 PyUnicode_WRITE(writer.kind, writer.data, writer.pos++, ch); \
6460 /* load the unicode data module */
6597 const void *data;
6622 data = PyUnicode_DATA(unicode);
6636 Py_UCS4 ch = PyUnicode_READ(kind, data, i);
6750 PyUnicode_WRITE(writer.kind, writer.data, writer.pos++, ch); \
6784 PyUnicode_WRITE(writer.kind, writer.data, writer.pos++, '\\');
6862 const void *data;
6873 data = PyUnicode_DATA(unicode);
6876 return PyBytes_FromStringAndSize(data, len);
6896 Py_UCS4 ch = PyUnicode_READ(kind, data, pos);
7055 const void *data;
7071 data = PyUnicode_DATA(unicode);
7083 Py_UCS4 ch = PyUnicode_READ(kind, data, pos);
7098 while ((collend < size) && (PyUnicode_READ(kind, data, collend) >= limit))
7143 ch = PyUnicode_READ(kind, data, i);
7291 void *data = writer.data;
7297 PyUnicode_WRITE(kind, data, writer.pos, c);
7317 data = writer.data;
7320 PyUnicode_WRITE(kind, data, writer.pos, 0xfffd);
7322 PyUnicode_WRITE(kind, data, writer.pos, c + 0xdc00);
7341 data = writer.data;
7972 const void *data;
7991 data = PyUnicode_DATA(rep);
7993 Py_UCS4 ch = PyUnicode_READ(kind, data, i);
8136 Py_UCS1 *outdata = (Py_UCS1 *)writer->data;
8147 outdata = (Py_UCS1 *)writer->data;
8161 Py_UCS1 *outdata = (Py_UCS1 *)writer->data;
8175 Py_UCS2 *outdata = (Py_UCS2 *)writer->data;
8414 const void *data;
8423 data = PyUnicode_DATA(string);
8432 if (PyUnicode_READ(kind, data, 0) != 0)
8436 ch = PyUnicode_READ(kind, data, i);
8461 key = PyLong_FromLong(PyUnicode_READ(kind, data, i));
8498 Py_UCS4 ch = PyUnicode_READ(kind, data, i);
8680 const void *data;
8794 data = PyUnicode_DATA(repunicode);
8797 Py_UCS4 repch = PyUnicode_READ(kind, data, index);
8830 const void *data;
8836 data = PyUnicode_DATA(unicode);
8852 Py_UCS4 ch = PyUnicode_READ(kind, data, inpos);
9196 const void *data;
9215 data = PyUnicode_DATA(input);
9255 ch = PyUnicode_READ(kind, data, i);
9273 ch = PyUnicode_READ(kind, data, collend);
9343 const void *data = PyUnicode_DATA(unicode);
9346 Py_UCS4 ch = PyUnicode_READ(kind, data, i);
9808 const char *data = PyUnicode_DATA(self);
9817 _Py_bytes_lower(resdata, data, len);
9819 _Py_bytes_upper(resdata, data, len);
9824 handle_capital_sigma(int kind, const void *data, Py_ssize_t length, Py_ssize_t i)
9836 c = PyUnicode_READ(kind, data, j);
9843 c = PyUnicode_READ(kind, data, j);
9853 lower_ucs4(int kind, const void *data, Py_ssize_t length, Py_ssize_t i,
9858 mapped[0] = handle_capital_sigma(kind, data, length, i);
9865 do_capitalize(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9871 c = PyUnicode_READ(kind, data, 0);
9878 c = PyUnicode_READ(kind, data, i);
9879 n_res = lower_ucs4(kind, data, length, i, c, mapped);
9889 do_swapcase(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar) {
9893 Py_UCS4 c = PyUnicode_READ(kind, data, i), mapped[3];
9896 n_res = lower_ucs4(kind, data, length, i, c, mapped);
9914 do_upper_or_lower(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res,
9920 Py_UCS4 c = PyUnicode_READ(kind, data, i), mapped[3];
9923 n_res = lower_ucs4(kind, data, length, i, c, mapped);
9935 do_upper(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9937 return do_upper_or_lower(kind, data, length, res, maxchar, 0);
9941 do_lower(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9943 return do_upper_or_lower(kind, data, length, res, maxchar, 1);
9947 do_casefold(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9952 Py_UCS4 c = PyUnicode_READ(kind, data, i);
9964 do_title(int kind, const void *data, Py_ssize_t length, Py_UCS4 *res, Py_UCS4 *maxchar)
9971 const Py_UCS4 c = PyUnicode_READ(kind, data, i);
9976 n_res = lower_ucs4(kind, data, length, i, c, mapped);
9997 const void *data;
10004 data = PyUnicode_DATA(self);
10013 newlength = perform(kind, data, length, tmp, &maxchar);
10239 void *data = PyUnicode_DATA(unicode);
10245 unicode_fill(kind, data, fill_char, start, length);
10292 void *data;
10314 data = PyUnicode_DATA(u);
10316 unicode_fill(kind, data, fill, 0, left);
10318 unicode_fill(kind, data, fill, left + _PyUnicode_LENGTH(self), right);
10584 void *data = PyUnicode_DATA(u);
10587 ucs1lib_replace_1char_inplace((Py_UCS1 *)data + pos,
10588 (Py_UCS1 *)data + len,
10592 ucs2lib_replace_1char_inplace((Py_UCS2 *)data + pos,
10593 (Py_UCS2 *)data + len,
10598 ucs4lib_replace_1char_inplace((Py_UCS4 *)data + pos,
10599 (Py_UCS4 *)data + len,
11196 const void *data = PyUnicode_1BYTE_DATA(uni);
11202 cmp = memcmp(data, str, len);
11216 const void *data = PyUnicode_DATA(uni);
11218 for (i = 0; (chr = PyUnicode_READ(kind, data, i)) && str[i]; i++)
11261 /* Memory error or bad data */
11286 /* memory error or bad data */
11296 /* memory error or bad data */
11801 const void *data;
11817 data = PyUnicode_DATA(self);
11818 ch = PyUnicode_READ(kind, data, index);
11914 const void *data;
11921 data = PyUnicode_DATA(self);
11926 Py_UNICODE_ISLOWER(PyUnicode_READ(kind, data, 0)));
11934 const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
11959 const void *data;
11966 data = PyUnicode_DATA(self);
11971 Py_UNICODE_ISUPPER(PyUnicode_READ(kind, data, 0)) != 0);
11979 const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
12004 const void *data;
12011 data = PyUnicode_DATA(self);
12015 Py_UCS4 ch = PyUnicode_READ(kind, data, 0);
12027 const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
12062 const void *data;
12068 data = PyUnicode_DATA(self);
12073 Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, 0)));
12080 const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
12102 const void *data;
12108 data = PyUnicode_DATA(self);
12113 Py_UNICODE_ISALPHA(PyUnicode_READ(kind, data, 0)));
12120 if (!Py_UNICODE_ISALPHA(PyUnicode_READ(kind, data, i)))
12140 const void *data;
12147 data = PyUnicode_DATA(self);
12152 const Py_UCS4 ch = PyUnicode_READ(kind, data, 0);
12161 const Py_UCS4 ch = PyUnicode_READ(kind, data, i);
12183 const void *data;
12189 data = PyUnicode_DATA(self);
12194 Py_UNICODE_ISDECIMAL(PyUnicode_READ(kind, data, 0)));
12201 if (!Py_UNICODE_ISDECIMAL(PyUnicode_READ(kind, data, i)))
12222 const void *data;
12228 data = PyUnicode_DATA(self);
12232 const Py_UCS4 ch = PyUnicode_READ(kind, data, 0);
12241 if (!Py_UNICODE_ISDIGIT(PyUnicode_READ(kind, data, i)))
12262 const void *data;
12268 data = PyUnicode_DATA(self);
12273 Py_UNICODE_ISNUMERIC(PyUnicode_READ(kind, data, 0)));
12280 if (!Py_UNICODE_ISNUMERIC(PyUnicode_READ(kind, data, i)))
12300 const void *data = PyUnicode_DATA(self);
12301 Py_UCS4 ch = PyUnicode_READ(kind, data, 0);
12315 ch = PyUnicode_READ(kind, data, i);
12407 const void *data;
12413 data = PyUnicode_DATA(self);
12418 Py_UNICODE_ISPRINTABLE(PyUnicode_READ(kind, data, 0)));
12421 if (!Py_UNICODE_ISPRINTABLE(PyUnicode_READ(kind, data, i))) {
12512 const void *data;
12522 data = PyUnicode_DATA(self);
12532 Py_UCS4 ch = PyUnicode_READ(kind, data, i);
12545 Py_UCS4 ch = PyUnicode_READ(kind, data, j);
12562 const unsigned char *data;
12584 data = PyUnicode_1BYTE_DATA(self);
12585 return _PyUnicode_FromASCII((const char*)(data + start), length);
12589 data = PyUnicode_1BYTE_DATA(self);
12591 data + kind * start,
12607 const Py_UCS1 *data = PyUnicode_1BYTE_DATA(self);
12612 Py_UCS1 ch = data[i];
12623 Py_UCS1 ch = data[j];
12633 const void *data = PyUnicode_DATA(self);
12638 Py_UCS4 ch = PyUnicode_READ(kind, data, i);
12649 Py_UCS4 ch = PyUnicode_READ(kind, data, j);
13170 Note, str.split() is mainly useful for data that has been intentionally
13494 const void *data;
13513 data = PyUnicode_DATA(key);
13514 newkey = PyLong_FromLong(PyUnicode_READ(kind, data, 0));
13595 const void *data;
13612 data = PyUnicode_DATA(u);
13613 chr = PyUnicode_READ(kind, data, fill);
13617 PyUnicode_WRITE(kind, data, 0, chr);
13618 PyUnicode_WRITE(kind, data, fill, '0');
13735 writer->data = PyUnicode_DATA(writer->buffer);
13882 PyUnicode_WRITE(writer->kind, writer->data, writer->pos, ch);
13990 Py_UCS1 *data = writer->data;
13992 memcpy(data + writer->pos, str, len);
14000 (Py_UCS2 *)writer->data + writer->pos);
14008 (Py_UCS4 *)writer->data + writer->pos);
14127 character data. */
14142 with the data pointer. Check if the data is not shared. */
15072 PyUnicode_WRITE(writer->kind, writer->data, writer->pos, signchar);
15086 PyUnicode_WRITE(writer->kind, writer->data, writer->pos, '0');
15087 PyUnicode_WRITE(writer->kind, writer->data, writer->pos+1, arg->ch);
15100 unicode_fill(writer->kind, writer->data, fill, writer->pos, sublen);
15109 PyUnicode_WRITE(writer->kind, writer->data, writer->pos, signchar);
15115 PyUnicode_WRITE(writer->kind, writer->data, writer->pos, '0');
15116 PyUnicode_WRITE(writer->kind, writer->data, writer->pos+1, arg->ch);
15132 unicode_fill(writer->kind, writer->data, ' ', writer->pos, sublen);
15309 void *data;
15365 data = PyObject_Malloc((length + 1) * char_size);
15366 if (data == NULL) {
15371 _PyUnicode_DATA_ANY(self) = data;
15374 _PyUnicode_UTF8(self) = data;
15378 _PyUnicode_WSTR(self) = (wchar_t *)data;
15381 memcpy(data, PyUnicode_DATA(unicode),
15406 errors is specified, then the object must expose a data buffer\n\
15710 const void *data = PyUnicode_DATA(seq);
15711 Py_UCS4 chr = PyUnicode_READ(kind, data, it->it_index);
15732 const void *data = ((void*)(_PyASCIIObject_CAST(seq) + 1));
15734 data, it->it_index);
16118 void* data = (void*)(compact + 1);
16119 if (ascii->wstr && ascii->wstr != data) {