Lines Matching defs:len
85 if len(self.c_default) > 4 or self.c_default[0] != "'":
622 Py_ssize_t len;
624 len = _PyUnicode_WSTR_LENGTH(unicode);
625 if (len == 0) {
630 if (len == 1) {
865 make_bloom_mask(int kind, const void* ptr, Py_ssize_t len)
886 BLOOM_UPDATE(Py_UCS1, mask, ptr, len);
889 BLOOM_UPDATE(Py_UCS2, mask, ptr, len);
892 BLOOM_UPDATE(Py_UCS4, mask, ptr, len);
1347 printf("%s: len=%zu, ", unicode_kind_name(op), ascii->length);
2065 const char *str, Py_ssize_t len)
2069 const char *end = str + len;
2071 assert(index + len <= PyUnicode_GET_LENGTH(unicode));
2078 (const Py_UCS1*)str + len);
2082 memcpy((char *) data + index, str, len);
2535 Py_ssize_t len;
2544 len = PyUnicode_GET_LENGTH(unicode);
2548 max_char = ucs1lib_find_max_char(u, u + len);
2554 max_char = ucs2lib_find_max_char(u, u + len);
2560 max_char = ucs4lib_find_max_char(u, u + len);
2567 copy = PyUnicode_New(len, max_char);
2569 _PyUnicode_FastCopyCharacters(copy, 0, unicode, 0, len);
2604 unicode_askind(unsigned int skind, void const *data, Py_ssize_t len, unsigned int kind)
2611 result = PyMem_New(Py_UCS2, len);
2618 ((const Py_UCS1 *)data) + len,
2622 result = PyMem_New(Py_UCS4, len);
2629 ((const Py_UCS2 *)data) + len,
2637 ((const Py_UCS1 *)data) + len,
2653 Py_ssize_t len, targetlen;
2658 len = PyUnicode_GET_LENGTH(string);
2659 targetlen = len;
2680 _PyUnicode_CONVERT_BYTES(Py_UCS1, Py_UCS4, start, start + len, target);
2684 _PyUnicode_CONVERT_BYTES(Py_UCS2, Py_UCS4, start, start + len, target);
2687 memcpy(target, data, len * sizeof(Py_UCS4));
2693 target[len] = 0;
2791 Py_ssize_t len;
2898 len = sprintf(buffer, "%lu", va_arg(*vargs, unsigned long));
2901 len = sprintf(buffer, "%llu", va_arg(*vargs, unsigned long long));
2904 len = sprintf(buffer, "%zu", va_arg(*vargs, size_t));
2907 len = sprintf(buffer, "%u", va_arg(*vargs, unsigned int));
2911 len = sprintf(buffer, "%x", va_arg(*vargs, int));
2915 len = sprintf(buffer, "%li", va_arg(*vargs, long));
2918 len = sprintf(buffer, "%lli", va_arg(*vargs, long long));
2921 len = sprintf(buffer, "%zi", va_arg(*vargs, Py_ssize_t));
2924 len = sprintf(buffer, "%i", va_arg(*vargs, int));
2927 assert(len >= 0);
2929 if (precision < len)
2930 precision = len;
2944 if (precision > len) {
2945 fill = precision - len;
2951 if (_PyUnicodeWriter_WriteASCIIString(writer, buffer, len) < 0)
2960 len = sprintf(number, "%p", va_arg(*vargs, void*));
2961 assert(len >= 0);
2971 len += 2;
2974 if (_PyUnicodeWriter_WriteASCIIString(writer, number, len) < 0)
3073 len = strlen(p);
3074 if (_PyUnicodeWriter_WriteLatin1String(writer, p, len) == -1)
3076 f = p+len;
3106 Py_ssize_t len;
3121 len = p - f;
3126 if (_PyUnicodeWriter_WriteASCIIString(&writer, f, len) < 0)
3483 if (buffer.len == 0) {
3491 v = PyUnicode_Decode((char*) buffer.buf, buffer.len, encoding, errors);
3959 unicode_decode_locale(const char *str, Py_ssize_t len,
3962 if (str[len] != '\0' || (size_t)len != strlen(str)) {
3976 "locale", str, len,
4000 PyUnicode_DecodeLocaleAndSize(const char *str, Py_ssize_t len,
4004 return unicode_decode_locale(str, len, error_handler, 1);
4904 Py_ssize_t len;
4917 len = PyUnicode_GET_LENGTH(str);
4919 if (len == 0)
4923 if (len > PY_SSIZE_T_MAX / 8)
4925 v = PyBytes_FromStringAndSize(NULL, len * 8);
4930 for (i = 0; i < len; ++i) {
5407 Py_ssize_t len = wcslen(text);
5409 assert(len >= 0);
5427 if (len > PY_SSIZE_T_MAX / max_char_size - 1) {
5432 bytes = PyMem_RawMalloc((len + 1) * max_char_size);
5435 bytes = PyMem_Malloc((len + 1) * max_char_size);
5443 for (i = 0; i < len; ) {
5449 && i < len
5616 Py_ssize_t len = end - start;
5618 char *cache = PyObject_Malloc(len + 1);
5625 _PyUnicode_UTF8_LENGTH(unicode) = len;
5626 memcpy(cache, start, len);
5627 cache[len] = '\0';
5808 Py_ssize_t len;
5830 len = PyUnicode_GET_LENGTH(str);
5832 if (len > PY_SSIZE_T_MAX / 4 - (byteorder == 0))
5834 nsize = len + (byteorder == 0);
5844 if (len == 0)
5855 ucs1lib_utf32_encode((const Py_UCS1 *)data, len, &out, native_ordering);
5860 while (pos < len) {
5864 pos += ucs2lib_utf32_encode((const Py_UCS2 *)data + pos, len - pos,
5869 pos += ucs4lib_utf32_encode((const Py_UCS4 *)data + pos, len - pos,
5872 if (pos == len)
6129 Py_ssize_t len;
6152 len = PyUnicode_GET_LENGTH(str);
6157 const Py_UCS4 *end = in + len;
6164 if (len > PY_SSIZE_T_MAX / 2 - pairs - (byteorder == 0)) {
6167 nsize = len + pairs + (byteorder == 0);
6179 if (len == 0) {
6184 ucs1lib_utf16_encode((const Py_UCS1 *)data, len, &out, native_ordering);
6199 while (pos < len) {
6203 pos += ucs2lib_utf16_encode((const Py_UCS2 *)data + pos, len - pos,
6208 pos += ucs4lib_utf16_encode((const Py_UCS4 *)data + pos, len - pos,
6211 if (pos == len)
6593 Py_ssize_t i, len;
6616 len = PyUnicode_GET_LENGTH(unicode);
6617 if (len == 0) {
6626 if (len > PY_SSIZE_T_MAX / expandsize) {
6629 repr = PyBytes_FromStringAndSize(NULL, expandsize * len);
6635 for (i = 0; i < len; i++) {
6863 Py_ssize_t len;
6874 len = PyUnicode_GET_LENGTH(unicode);
6876 return PyBytes_FromStringAndSize(data, len);
6883 if (len > PY_SSIZE_T_MAX / expandsize) {
6886 repr = PyBytes_FromStringAndSize(NULL, expandsize * len);
6890 if (len == 0) {
6895 for (pos = 0; pos < len; pos++) {
6998 Py_ssize_t len;
7010 len = PyUnicode_GET_LENGTH(unicode);
7036 *newpos = len + *newpos;
7037 if (*newpos<0 || *newpos>len) {
7726 PyObject *unicode, Py_ssize_t offset, int len,
7741 assert(len > 0);
7748 substring = PyUnicode_Substring(unicode, offset, offset+len);
8029 Py_ssize_t len;
8041 len = PyUnicode_GET_LENGTH(unicode);
8048 if (len == 0)
8055 if (len > DECODING_CHUNK_SIZE) {
8062 chunk_len = (int)len;
8079 len -= chunk_len;
9145 Py_ssize_t len;
9150 len = PyUnicode_GET_LENGTH(input);
9155 end = in + len;
9158 assert(PyUnicode_GET_LENGTH(writer->buffer) == len);
9335 Py_ssize_t len = PyUnicode_GET_LENGTH(unicode);
9336 PyObject *result = PyUnicode_New(len, 127);
9345 for (i = 0; i < len; ++i) {
9372 #define ADJUST_INDICES(start, end, len) \
9373 if (end > len) \
9374 end = len; \
9376 end += len; \
9381 start += len; \
9537 Py_ssize_t len;
9565 while ((len = GroupGenerator_next(&groupgen)) > 0) {
9566 len = Py_MIN(len, Py_MAX(Py_MAX(remaining, min_width), 1));
9567 n_zeros = Py_MAX(0, len - remaining);
9568 n_chars = Py_MAX(0, Py_MIN(remaining, len));
9586 min_width -= len;
9597 len = Py_MAX(Py_MAX(remaining, min_width), 1);
9598 n_zeros = Py_MAX(0, len - remaining);
9599 n_chars = Py_MAX(0, Py_MIN(remaining, len));
9708 Py_ssize_t len, result;
9711 len = PyUnicode_GET_LENGTH(str);
9712 ADJUST_INDICES(start, end, len);
9776 /* We do not need to compare 0 and len(substring)-1 because
9807 Py_ssize_t len = PyUnicode_GET_LENGTH(self);
9812 res = PyUnicode_New(len, 127);
9817 _Py_bytes_lower(resdata, data, len);
9819 _Py_bytes_upper(resdata, data, len);
10585 Py_ssize_t len = PyUnicode_GET_LENGTH(u);
10588 (Py_UCS1 *)data + len,
10593 (Py_UCS2 *)data + len,
10599 (Py_UCS4 *)data + len,
11004 TYPE1* end = p1 + len; \
11017 Py_ssize_t len1, len2, len;
11025 len = Py_MIN(len1, len2);
11033 int cmp = memcmp(data1, data2, len);
11083 int cmp = wmemcmp((wchar_t *)data1, (wchar_t *)data2, len);
11118 Py_ssize_t len;
11121 len = PyUnicode_GET_LENGTH(str1);
11122 if (PyUnicode_GET_LENGTH(str2) != len)
11130 cmp = memcmp(data1, data2, len * kind);
11198 size_t len, len2 = strlen(str);
11201 len = Py_MIN(len1, len2);
11202 cmp = memcmp(data, str, len);
11234 size_t i, len;
11236 len = (size_t)_PyUnicode_WSTR_LENGTH(unicode);
11237 if (strlen(str) != len)
11241 for (i = 0; i < len; i++) {
11252 size_t len;
11267 len = (size_t)PyUnicode_GET_LENGTH(unicode);
11268 return strlen(str) == len &&
11269 memcmp(PyUnicode_1BYTE_DATA(unicode), str, len) == 0;
12141 Py_ssize_t len, i;
12148 len = PyUnicode_GET_LENGTH(self);
12151 if (len == 1) {
12157 if (len == 0)
12160 for (i = 0; i < len; i++) {
12293 Py_ssize_t len = PyUnicode_GET_LENGTH(self);
12294 if (len == 0) {
12314 for (i = 1; i < len; i++) {
12328 Py_ssize_t len = PyUnicode_GET_LENGTH(self);
12330 return len && i == len;
12335 Py_ssize_t i = 0, len = PyUnicode_GET_SIZE(self);
12336 if (len == 0) {
12345 && i < len
12356 while (i < len) {
12360 && i < len
12514 Py_ssize_t i, j, len;
12523 len = PyUnicode_GET_LENGTH(self);
12531 while (i < len) {
12541 j = len;
12599 Py_ssize_t len, i, j;
12604 len = PyUnicode_GET_LENGTH(self);
12611 while (i < len) {
12619 j = len;
12637 while (i < len) {
12645 j = len;
12738 unicode_repeat(PyObject *str, Py_ssize_t len)
12743 if (len < 1)
12747 if (len == 1)
12753 if (PyUnicode_GET_LENGTH(str) > PY_SSIZE_T_MAX / len) {
12758 nchars = len * PyUnicode_GET_LENGTH(str);
12770 memset(to, (unsigned char)fill_char, len);
12774 for (n = 0; n < len; ++n)
12779 for (n = 0; n < len; ++n)
12840 If the string starts with the prefix string, return string[len(prefix):].
12868 return string[:-len(suffix)]. Otherwise, return a copy of the original
13897 Py_ssize_t len;
13901 len = PyUnicode_GET_LENGTH(str);
13902 if (len == 0)
13905 if (maxchar > writer->maxchar || len > writer->size - writer->pos) {
13912 writer->pos += len;
13915 if (_PyUnicodeWriter_PrepareInternal(writer, len, maxchar) == -1)
13919 str, 0, len);
13920 writer->pos += len;
13929 Py_ssize_t len;
13948 len = end - start;
13950 if (_PyUnicodeWriter_Prepare(writer, len, maxchar) < 0)
13954 str, start, len);
13955 writer->pos += len;
13961 const char *ascii, Py_ssize_t len)
13963 if (len == -1)
13964 len = strlen(ascii);
13966 assert(ucs1lib_find_max_char((const Py_UCS1*)ascii, (const Py_UCS1*)ascii + len) < 128);
13971 str = _PyUnicode_FromASCII(ascii, len);
13978 writer->pos += len;
13982 if (_PyUnicodeWriter_Prepare(writer, len, 127) == -1)
13992 memcpy(data + writer->pos, str, len);
13999 ascii, ascii + len,
14007 ascii, ascii + len,
14015 writer->pos += len;
14021 const char *str, Py_ssize_t len)
14025 maxchar = ucs1lib_find_max_char((const Py_UCS1*)str, (const Py_UCS1*)str + len);
14026 if (_PyUnicodeWriter_Prepare(writer, len, maxchar) == -1)
14028 unicode_write_cstr(writer->buffer, writer->pos, str, len);
14029 writer->pos += len;
14374 Py_ssize_t len;
14391 len = strlen(p);
14393 if (_PyUnicodeWriter_WriteASCIIString(writer, p, len) < 0) {
14399 *p_output = _PyUnicode_FromASCII(p, len);
14429 int len; /* number of characters */
14431 int numdigits; /* len == numnondigits + numdigits */
14484 len = (int)llen;
14487 numdigits = len - numnondigits;
14498 len -= 2;
14501 assert(len == numnondigits + numdigits);
14525 len = numnondigits + prec;
14532 for (i = 0; i < len; i++)
14539 unicode = _PyUnicode_FromASCII(buf, len);
14543 else if (len != PyUnicode_GET_LENGTH(result)) {
14544 if (PyUnicode_Resize(&result, len) < 0)
14988 Py_ssize_t len;
15006 len = PyUnicode_GET_LENGTH(str);
15007 if ((arg->width == -1 || arg->width <= len)
15008 && (arg->prec == -1 || arg->prec >= len)
15020 if (arg->prec >= 0 && len > arg->prec)
15021 len = arg->prec;
15033 len--;
15043 if (arg->width < len)
15044 arg->width = len;
15050 if ((arg->width-1) > len)
15054 if (arg->width > len)
15059 Py_UCS4 strmaxchar = _PyUnicode_FindMaxChar(str, 0, pindex+len);
15064 if (arg->sign && len == arg->width)
15075 if (arg->width > len)
15094 len -= 2;
15098 if (arg->width > len && !(arg->flags & F_LJUST)) {
15099 sublen = arg->width - len;
15102 arg->width = len;
15123 if (len) {
15125 str, pindex, len);
15126 writer->pos += len;
15130 if (arg->width > len) {
15131 sublen = arg->width - len;
15747 Py_ssize_t len = 0;
15749 len = PyUnicode_GET_LENGTH(it->it_seq) - it->it_index;
15750 return PyLong_FromSsize_t(len);
15753 PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");