← Back to branch summary

~pythonregexp2.7/python/issue2636-11

« back to all changes in this revision

Viewing changes to Modules/arraymodule.c

  • Committer: Jeffrey C. "The TimeHorse" Jacobs
  • Date: 2008-09-21 17:53:26 UTC
  • mfrom: (39025.1.14 Regexp-2.7)
  • Revision ID: darklord@timehorse.com-20080921175326-92vaej2hc3yuecxb
Merged in changes from the core Regexp branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Modules/arraymodule.c
432
432
        if (op == NULL) {
433
433
                return NULL;
434
434
        }
 
435
        op->ob_descr = descr;
 
436
        op->allocated = size;
 
437
        op->weakreflist = NULL;
435
438
        Py_SIZE(op) = size;
436
439
        if (size <= 0) {
437
440
                op->ob_item = NULL;
439
442
        else {
440
443
                op->ob_item = PyMem_NEW(char, nbytes);
441
444
                if (op->ob_item == NULL) {
442
 
                        PyObject_Del(op);
 
445
                        Py_DECREF(op);
443
446
                        return PyErr_NoMemory();
444
447
                }
445
448
        }
446
 
        op->ob_descr = descr;
447
 
        op->allocated = size;
448
 
        op->weakreflist = NULL;
449
449
        return (PyObject *) op;
450
450
}
451
451
 
652
652
                PyErr_BadArgument();
653
653
                return NULL;
654
654
        }
 
655
        if (Py_SIZE(a) > PY_SSIZE_T_MAX - Py_SIZE(b)) {
 
656
                return PyErr_NoMemory();
 
657
        }
655
658
        size = Py_SIZE(a) + Py_SIZE(b);
656
659
        np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
657
660
        if (np == NULL) {
674
677
        Py_ssize_t nbytes;
675
678
        if (n < 0)
676
679
                n = 0;
 
680
        if ((Py_SIZE(a) != 0) && (n > PY_SSIZE_T_MAX / Py_SIZE(a))) {
 
681
                return PyErr_NoMemory();
 
682
        }
677
683
        size = Py_SIZE(a) * n;
678
684
        np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
679
685
        if (np == NULL)
809
815
array_do_extend(arrayobject *self, PyObject *bb)
810
816
{
811
817
        Py_ssize_t size;
 
818
        char *old_item;
812
819
 
813
820
        if (!array_Check(bb))
814
821
                return array_iter_extend(self, bb);
818
825
                             "can only extend with array of same kind");
819
826
                return -1;
820
827
        }
 
828
        if ((Py_SIZE(self) > PY_SSIZE_T_MAX - Py_SIZE(b)) ||
 
829
                ((Py_SIZE(self) + Py_SIZE(b)) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
 
830
                PyErr_NoMemory();
 
831
                return -1;
 
832
        }
821
833
        size = Py_SIZE(self) + Py_SIZE(b);
 
834
        old_item = self->ob_item;
822
835
        PyMem_RESIZE(self->ob_item, char, size*self->ob_descr->itemsize);
823
836
        if (self->ob_item == NULL) {
824
 
                PyObject_Del(self);
825
 
                PyErr_NoMemory();
 
837
                self->ob_item = old_item;
 
838
                PyErr_NoMemory();
826
839
                return -1;
827
840
        }
828
841
        memcpy(self->ob_item + Py_SIZE(self)*self->ob_descr->itemsize,
859
872
                if (n < 0)
860
873
                        n = 0;
861
874
                items = self->ob_item;
 
875
                if ((self->ob_descr->itemsize != 0) && 
 
876
                        (Py_SIZE(self) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
 
877
                        return PyErr_NoMemory();
 
878
                }
862
879
                size = Py_SIZE(self) * self->ob_descr->itemsize;
863
880
                if (n == 0) {
864
881
                        PyMem_FREE(items);
867
884
                        self->allocated = 0;
868
885
                }
869
886
                else {
870
 
                        PyMem_Resize(items, char, n * size);
 
887
                        if (size > PY_SSIZE_T_MAX / n) {
 
888
                                return PyErr_NoMemory();
 
889
                        }
 
890
                        PyMem_RESIZE(items, char, n * size);
871
891
                        if (items == NULL)
872
892
                                return PyErr_NoMemory();
873
893
                        p = items;
1148
1168
                Py_INCREF(dict);
1149
1169
        }
1150
1170
        if (Py_SIZE(array) > 0) {
 
1171
                if (array->ob_descr->itemsize 
 
1172
                                > PY_SSIZE_T_MAX / array->ob_size) {
 
1173
                        return PyErr_NoMemory();
 
1174
                }
1151
1175
                result = Py_BuildValue("O(cs#)O", 
1152
1176
                        Py_TYPE(array), 
1153
1177
                        array->ob_descr->typecode,
1330
1354
                        if ((*self->ob_descr->setitem)(self,
1331
1355
                                        Py_SIZE(self) - n + i, v) != 0) {
1332
1356
                                Py_SIZE(self) -= n;
 
1357
                                if (itemsize && (self->ob_size > PY_SSIZE_T_MAX / itemsize)) {
 
1358
                                        return PyErr_NoMemory();
 
1359
                                }
1333
1360
                                PyMem_RESIZE(item, char,
1334
1361
                                                  Py_SIZE(self) * itemsize);
1335
1362
                                self->ob_item = item;
1389
1416
        n = n / itemsize;
1390
1417
        if (n > 0) {
1391
1418
                char *item = self->ob_item;
 
1419
                if ((n > PY_SSIZE_T_MAX - Py_SIZE(self)) ||
 
1420
                        ((Py_SIZE(self) + n) > PY_SSIZE_T_MAX / itemsize)) {
 
1421
                                return PyErr_NoMemory();
 
1422
                }
1392
1423
                PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
1393
1424
                if (item == NULL) {
1394
1425
                        PyErr_NoMemory();
1414
1445
static PyObject *
1415
1446
array_tostring(arrayobject *self, PyObject *unused)
1416
1447
{
1417
 
        return PyString_FromStringAndSize(self->ob_item,
 
1448
        if (self->ob_size <= PY_SSIZE_T_MAX / self->ob_descr->itemsize) {
 
1449
                return PyString_FromStringAndSize(self->ob_item,
1418
1450
                                    Py_SIZE(self) * self->ob_descr->itemsize);
 
1451
        } else {
 
1452
                return PyErr_NoMemory();
 
1453
        }
1419
1454
}
1420
1455
 
1421
1456
PyDoc_STRVAR(tostring_doc,
1443
1478
        }
1444
1479
        if (n > 0) {
1445
1480
                Py_UNICODE *item = (Py_UNICODE *) self->ob_item;
 
1481
                if (Py_SIZE(self) > PY_SSIZE_T_MAX - n) {
 
1482
                        return PyErr_NoMemory();
 
1483
                }
1446
1484
                PyMem_RESIZE(item, Py_UNICODE, Py_SIZE(self) + n);
1447
1485
                if (item == NULL) {
1448
1486
                        PyErr_NoMemory();
1511
1549
        {NULL}
1512
1550
};
1513
1551
 
1514
 
PyMethodDef array_methods[] = {
 
1552
static PyMethodDef array_methods[] = {
1515
1553
        {"append",      (PyCFunction)array_append,      METH_O,
1516
1554
         append_doc},
1517
1555
        {"buffer_info", (PyCFunction)array_buffer_info, METH_NOARGS,