Mercurial > cpython-lru_cache-weakref

comparison Objects/unicodeobject.c @ 45852:30c4e1ca8421

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merged revisions 61431,61433-61436,61439,61444,61449-61450,61453,61458,61465,61468,61471-61474,61480,61483-61484,61488,61495-61496,61498,61503-61504,61507,61509-61510,61515-61518 via svnmerge from svn+ssh://pythondev@svn.python.org/python/trunk ........ r61431 | vinay.sajip | 2008-03-16 22:35:58 +0100 (So, 16 Mär 2008) | 1 line Clarified documentation on use of shutdown(). ........ r61433 | mark.summerfield | 2008-03-17 09:28:15 +0100 (Mo, 17 Mär 2008) | 5 lines Added a footnote to each pointing out that for XML output if an encoding string is given it should conform to the appropriate XML standards---for example, "UTF-8" is okay, but "UTF8" is not. ........ r61434 | eric.smith | 2008-03-17 12:01:01 +0100 (Mo, 17 Mär 2008) | 7 lines Issue 2264: empty float presentation type needs to have at least one digit past the decimal point. Added "Z" format_char to PyOS_ascii_formatd to support empty float presentation type. Renamed buf_size in PyOS_ascii_formatd to more accurately reflect it's meaning. Modified format.__float__ to use the new "Z" format as the default. Added test cases. ........ r61435 | eric.smith | 2008-03-17 13:14:29 +0100 (Mo, 17 Mär 2008) | 2 lines Reformated lines > 79 chars. Deleted unused macro ISXDIGIT. ........ r61436 | jeffrey.yasskin | 2008-03-17 15:40:53 +0100 (Mo, 17 Mär 2008) | 13 lines Allow Gnu gcc's to build python on OSX by removing -Wno-long-double, -no-cpp-precomp, and -mno-fused-madd from configure. * r22183 added -no-cpp-precomp, which http://gcc.gnu.org/ml/gcc/2005-12/msg00368.html claims hasn't been needed since gcc-3.1. * r25607 added -Wno-long-double to avoid a warning in Include/objimpl.h (issue 525481). The long double is still there, but OSX 10.4's gcc no longer warns about it. * r33666 fixed issue 775892 on OSX 10.3 by adding -mno-fused-madd, which changed the sign of some float 0s. Tim Peters said it wasn't a real issue anyway, and it no longer causes test failures. Fixes issue #1779871. ........ r61439 | martin.v.loewis | 2008-03-17 17:31:57 +0100 (Mo, 17 Mär 2008) | 2 lines Add Trent Nelson. ........ r61444 | travis.oliphant | 2008-03-17 18:36:12 +0100 (Mo, 17 Mär 2008) | 1 line Add necessary headers to back-port new buffer protocol to Python 2.6 ........ r61449 | gregory.p.smith | 2008-03-17 19:48:05 +0100 (Mo, 17 Mär 2008) | 8 lines Force zlib.crc32 and zlib.adler32 to return a signed integer on all platforms regardless of the native sizeof(long) used in the integer object. This somewhat odd behavior of returning a signed is maintained in 2.x for compatibility reasons of always returning an integer rather than a long object. Fixes Issue1202 for Python 2.6 ........ r61450 | neal.norwitz | 2008-03-17 20:02:45 +0100 (Mo, 17 Mär 2008) | 3 lines Use a buffer large enough to ensure we don't overrun, even if the value is outside the range we expect. ........ r61453 | steven.bethard | 2008-03-17 20:33:11 +0100 (Mo, 17 Mär 2008) | 1 line Document unicode.isnumeric() and unicode.isdecimal() (issue2326) ........ r61458 | neal.norwitz | 2008-03-17 21:22:43 +0100 (Mo, 17 Mär 2008) | 5 lines Issue 2321: reduce memory usage (increase the memory that is returned to the system) by using pymalloc for the data of unicode objects. Will backport. ........ r61465 | martin.v.loewis | 2008-03-17 22:55:30 +0100 (Mo, 17 Mär 2008) | 2 lines Add David Wolever. ........ r61468 | gregory.p.smith | 2008-03-18 01:20:01 +0100 (Di, 18 Mär 2008) | 3 lines Fix the IOError message text when opening a file with an invalid filename. Error reported by Ilan Schnell. ........ r61471 | brett.cannon | 2008-03-18 02:00:07 +0100 (Di, 18 Mär 2008) | 2 lines Convert test_strftime, test_getargs, and test_pep247 to use unittest. ........ r61472 | jeffrey.yasskin | 2008-03-18 02:09:59 +0100 (Di, 18 Mär 2008) | 2 lines Fix build on platforms that don't have intptr_t. Patch by Joseph Armbruster. ........ r61473 | brett.cannon | 2008-03-18 02:50:25 +0100 (Di, 18 Mär 2008) | 2 lines Convert test_dummy_threading and test_dbm to unittest. ........ r61474 | brett.cannon | 2008-03-18 02:58:56 +0100 (Di, 18 Mär 2008) | 2 lines Move test_extcall to doctest. ........ r61480 | brett.cannon | 2008-03-18 04:46:22 +0100 (Di, 18 Mär 2008) | 2 lines test_errno was a no-op test; now it actually tests things and uses unittest. ........ r61483 | brett.cannon | 2008-03-18 05:09:00 +0100 (Di, 18 Mär 2008) | 3 lines Remove our implementation of memmove() and strerror(); both are in the C89 standard library. ........ r61484 | brett.cannon | 2008-03-18 05:16:06 +0100 (Di, 18 Mär 2008) | 2 lines The output directory for tests that compare against stdout is now gone! ........ r61488 | jeffrey.yasskin | 2008-03-18 05:29:35 +0100 (Di, 18 Mär 2008) | 2 lines Block the "socket.ssl() is deprecated" warning from test_socket_ssl. ........ r61495 | jeffrey.yasskin | 2008-03-18 05:56:06 +0100 (Di, 18 Mär 2008) | 4 lines Speed test_thread up from 51.328s to 0.081s by reducing its sleep times. We still sleep at all to make it likely that all threads are active at the same time. ........ r61496 | jeffrey.yasskin | 2008-03-18 06:12:41 +0100 (Di, 18 Mär 2008) | 4 lines Speed up test_dict by about 10x by only checking selected dict literal sizes, instead of every integer from 0 to 400. Exhaustive testing wastes time without providing enough more assurance that the code is correct. ........ r61498 | neal.norwitz | 2008-03-18 06:20:29 +0100 (Di, 18 Mär 2008) | 1 line Try increasing the timeout to reduce the flakiness of this test. ........ r61503 | brett.cannon | 2008-03-18 06:43:04 +0100 (Di, 18 Mär 2008) | 2 lines Improve the error message for a test that failed on the S-390 Debian buildbot. ........ r61504 | jeffrey.yasskin | 2008-03-18 06:45:40 +0100 (Di, 18 Mär 2008) | 3 lines Add a -S/--slow flag to regrtest to have it print the 10 slowest tests with their times. ........ r61507 | neal.norwitz | 2008-03-18 07:03:46 +0100 (Di, 18 Mär 2008) | 1 line Add some info to the failure messages ........ r61509 | trent.nelson | 2008-03-18 08:02:12 +0100 (Di, 18 Mär 2008) | 1 line Issue 2286: bump up the stack size of the 64-bit debug python_d.exe to 2100000. The default value of 200000 causes a stack overflow at 1965 iterations of r_object() in marshal.c, 35 iterations before the 2000 limit enforced by MAX_MARSHAL_STACK_DEPTH. ........ r61510 | trent.nelson | 2008-03-18 08:32:47 +0100 (Di, 18 Mär 2008) | 5 lines The behaviour of winsound.Beep() seems to differ between different versions of Windows when there's either: a) no sound card entirely b) legacy beep driver has been disabled c) the legacy beep driver has been uninstalled Sometimes RuntimeErrors are raised, sometimes they're not. If _have_soundcard() returns False, don't expect winsound.Beep() to raise a RuntimeError, as this clearly isn't the case, as demonstrated by the various Win32 XP buildbots. ........ r61515 | martin.v.loewis | 2008-03-18 13:20:15 +0100 (Di, 18 Mär 2008) | 2 lines norwitz-amd64 (gentoo) has EREMOTEIO. ........ r61516 | martin.v.loewis | 2008-03-18 13:45:37 +0100 (Di, 18 Mär 2008) | 2 lines Add more Linux error codes. ........ r61517 | martin.v.loewis | 2008-03-18 14:05:03 +0100 (Di, 18 Mär 2008) | 2 lines Add WSA errors. ........ r61518 | martin.v.loewis | 2008-03-18 14:16:05 +0100 (Di, 18 Mär 2008) | 2 lines Note that the stderr output of the test is intentional. ........
author Christian Heimes <christian@cheimes.de>
date Tue, 18 Mar 2008 15:15:01 +0000
parents 832c820e9d14
children f3d838dab40e
comparison
equal deleted inserted replaced
45850:e148285bd511 45852:30c4e1ca8421
270 The overallocation is also used by fastsearch, which assumes that it's 270 The overallocation is also used by fastsearch, which assumes that it's
271 safe to look at str[length] (without making any assumptions about what 271 safe to look at str[length] (without making any assumptions about what
272 it contains). */ 272 it contains). */
273 273
274 oldstr = unicode->str; 274 oldstr = unicode->str;
275 PyMem_RESIZE(unicode->str, Py_UNICODE, length + 1); 275 unicode->str = PyObject_REALLOC(unicode->str,
276 sizeof(Py_UNICODE) * (length + 1));
276 if (!unicode->str) { 277 if (!unicode->str) {
277 unicode->str = (Py_UNICODE *)oldstr; 278 unicode->str = (Py_UNICODE *)oldstr;
278 PyErr_NoMemory(); 279 PyErr_NoMemory();
279 return -1; 280 return -1;
280 } 281 }
320 if (unicode->str) { 321 if (unicode->str) {
321 /* Keep-Alive optimization: we only upsize the buffer, 322 /* Keep-Alive optimization: we only upsize the buffer,
322 never downsize it. */ 323 never downsize it. */
323 if ((unicode->length < length) && 324 if ((unicode->length < length) &&
324 unicode_resize(unicode, length) < 0) { 325 unicode_resize(unicode, length) < 0) {
325 PyMem_DEL(unicode->str); 326 PyObject_DEL(unicode->str);
326 goto onError; 327 goto onError;
327 } 328 }
328 } 329 }
329 else { 330 else {
330 unicode->str = PyMem_NEW(Py_UNICODE, length + 1); 331 size_t new_size = sizeof(Py_UNICODE) * ((size_t)length + 1);
332 unicode->str = (Py_UNICODE*) PyObject_MALLOC(new_size);
331 } 333 }
332 PyObject_INIT(unicode, &PyUnicode_Type); 334 PyObject_INIT(unicode, &PyUnicode_Type);
333 } 335 }
334 else { 336 else {
337 size_t new_size;
335 unicode = PyObject_New(PyUnicodeObject, &PyUnicode_Type); 338 unicode = PyObject_New(PyUnicodeObject, &PyUnicode_Type);
336 if (unicode == NULL) 339 if (unicode == NULL)
337 return NULL; 340 return NULL;
338 unicode->str = PyMem_NEW(Py_UNICODE, length + 1); 341 new_size = sizeof(Py_UNICODE) * ((size_t)length + 1);
342 unicode->str = (Py_UNICODE*) PyObject_MALLOC(new_size);
339 } 343 }
340 344
341 if (!unicode->str) { 345 if (!unicode->str) {
342 PyErr_NoMemory(); 346 PyErr_NoMemory();
343 goto onError; 347 goto onError;
387 391
388 if (PyUnicode_CheckExact(unicode) && 392 if (PyUnicode_CheckExact(unicode) &&
389 numfree < PyUnicode_MAXFREELIST) { 393 numfree < PyUnicode_MAXFREELIST) {
390 /* Keep-Alive optimization */ 394 /* Keep-Alive optimization */
391 if (unicode->length >= KEEPALIVE_SIZE_LIMIT) { 395 if (unicode->length >= KEEPALIVE_SIZE_LIMIT) {
392 PyMem_DEL(unicode->str); 396 PyObject_DEL(unicode->str);
393 unicode->str = NULL; 397 unicode->str = NULL;
394 unicode->length = 0; 398 unicode->length = 0;
395 } 399 }
396 if (unicode->defenc) { 400 if (unicode->defenc) {
397 Py_DECREF(unicode->defenc); 401 Py_DECREF(unicode->defenc);
401 *(PyUnicodeObject **)unicode = free_list; 405 *(PyUnicodeObject **)unicode = free_list;
402 free_list = unicode; 406 free_list = unicode;
403 numfree++; 407 numfree++;
404 } 408 }
405 else { 409 else {
406 PyMem_DEL(unicode->str); 410 PyObject_DEL(unicode->str);
407 Py_XDECREF(unicode->defenc); 411 Py_XDECREF(unicode->defenc);
408 Py_TYPE(unicode)->tp_free((PyObject *)unicode); 412 Py_TYPE(unicode)->tp_free((PyObject *)unicode);
409 } 413 }
410 } 414 }
411 415
638 ++callcount; 642 ++callcount;
639 } 643 }
640 /* step 2: allocate memory for the results of 644 /* step 2: allocate memory for the results of
641 * PyObject_Str()/PyObject_Repr() calls */ 645 * PyObject_Str()/PyObject_Repr() calls */
642 if (callcount) { 646 if (callcount) {
643 callresults = PyMem_Malloc(sizeof(PyObject *)*callcount); 647 callresults = PyObject_Malloc(sizeof(PyObject *)*callcount);
644 if (!callresults) { 648 if (!callresults) {
645 PyErr_NoMemory(); 649 PyErr_NoMemory();
646 return NULL; 650 return NULL;
647 } 651 }
648 callresult = callresults; 652 callresult = callresults;
785 } else 789 } else
786 n++; 790 n++;
787 } 791 }
788 expand: 792 expand:
789 if (abuffersize > 20) { 793 if (abuffersize > 20) {
790 abuffer = PyMem_Malloc(abuffersize); 794 abuffer = PyObject_Malloc(abuffersize);
791 if (!abuffer) { 795 if (!abuffer) {
792 PyErr_NoMemory(); 796 PyErr_NoMemory();
793 goto fail; 797 goto fail;
794 } 798 }
795 realbuffer = abuffer; 799 realbuffer = abuffer;
948 *s++ = *f; 952 *s++ = *f;
949 } 953 }
950 954
951 end: 955 end:
952 if (callresults) 956 if (callresults)
953 PyMem_Free(callresults); 957 PyObject_Free(callresults);
954 if (abuffer) 958 if (abuffer)
955 PyMem_Free(abuffer); 959 PyObject_Free(abuffer);
956 _PyUnicode_Resize(&string, s - PyUnicode_AS_UNICODE(string)); 960 _PyUnicode_Resize(&string, s - PyUnicode_AS_UNICODE(string));
957 return string; 961 return string;
958 fail: 962 fail:
959 if (callresults) { 963 if (callresults) {
960 PyObject **callresult2 = callresults; 964 PyObject **callresult2 = callresults;
961 while (callresult2 < callresult) { 965 while (callresult2 < callresult) {
962 Py_DECREF(*callresult2); 966 Py_DECREF(*callresult2);
963 ++callresult2; 967 ++callresult2;
964 } 968 }
965 PyMem_Free(callresults); 969 PyObject_Free(callresults);
966 } 970 }
967 if (abuffer) 971 if (abuffer)
968 PyMem_Free(abuffer); 972 PyObject_Free(abuffer);
969 return NULL; 973 return NULL;
970 } 974 }
971 975
972 #undef appendstring 976 #undef appendstring
973 977
8275 return (PyObject *)self; 8279 return (PyObject *)self;
8276 } else if (step == 1) { 8280 } else if (step == 1) {
8277 return PyUnicode_FromUnicode(self->str + start, slicelength); 8281 return PyUnicode_FromUnicode(self->str + start, slicelength);
8278 } else { 8282 } else {
8279 source_buf = PyUnicode_AS_UNICODE((PyObject*)self); 8283 source_buf = PyUnicode_AS_UNICODE((PyObject*)self);
8280 result_buf = (Py_UNICODE *)PyMem_MALLOC(slicelength* 8284 result_buf = (Py_UNICODE *)PyObject_MALLOC(slicelength*
8281 sizeof(Py_UNICODE)); 8285 sizeof(Py_UNICODE));
8282 8286
8283 if (result_buf == NULL) 8287 if (result_buf == NULL)
8284 return PyErr_NoMemory(); 8288 return PyErr_NoMemory();
8285 8289
8286 for (cur = start, i = 0; i < slicelength; cur += step, i++) { 8290 for (cur = start, i = 0; i < slicelength; cur += step, i++) {
8287 result_buf[i] = source_buf[cur]; 8291 result_buf[i] = source_buf[cur];
8288 } 8292 }
8289 8293
8290 result = PyUnicode_FromUnicode(result_buf, slicelength); 8294 result = PyUnicode_FromUnicode(result_buf, slicelength);
8291 PyMem_FREE(result_buf); 8295 PyObject_FREE(result_buf);
8292 return result; 8296 return result;
8293 } 8297 }
8294 } else { 8298 } else {
8295 PyErr_SetString(PyExc_TypeError, "string indices must be integers"); 8299 PyErr_SetString(PyExc_TypeError, "string indices must be integers");
8296 return NULL; 8300 return NULL;
9028 pnew = (PyUnicodeObject *) type->tp_alloc(type, n = tmp->length); 9032 pnew = (PyUnicodeObject *) type->tp_alloc(type, n = tmp->length);
9029 if (pnew == NULL) { 9033 if (pnew == NULL) {
9030 Py_DECREF(tmp); 9034 Py_DECREF(tmp);
9031 return NULL; 9035 return NULL;
9032 } 9036 }
9033 pnew->str = PyMem_NEW(Py_UNICODE, n+1); 9037 pnew->str = (Py_UNICODE*) PyObject_MALLOC(sizeof(Py_UNICODE) * (n+1));
9034 if (pnew->str == NULL) { 9038 if (pnew->str == NULL) {
9035 _Py_ForgetReference((PyObject *)pnew); 9039 _Py_ForgetReference((PyObject *)pnew);
9036 PyObject_Del(pnew); 9040 PyObject_Del(pnew);
9037 Py_DECREF(tmp); 9041 Py_DECREF(tmp);
9038 return PyErr_NoMemory(); 9042 return PyErr_NoMemory();
9145 9149
9146 for (u = free_list; u != NULL;) { 9150 for (u = free_list; u != NULL;) {
9147 PyUnicodeObject *v = u; 9151 PyUnicodeObject *v = u;
9148 u = *(PyUnicodeObject **)u; 9152 u = *(PyUnicodeObject **)u;
9149 if (v->str) 9153 if (v->str)
9150 PyMem_DEL(v->str); 9154 PyObject_DEL(v->str);
9151 Py_XDECREF(v->defenc); 9155 Py_XDECREF(v->defenc);
9152 PyObject_Del(v); 9156 PyObject_Del(v);
9153 numfree--; 9157 numfree--;
9154 } 9158 }
9155 free_list = NULL; 9159 free_list = NULL;