Modules/arraymodule.c

   1 /***********************************************************
   2 Copyright (c) 2000, BeOpen.com.
   3 Copyright (c) 1995-2000, Corporation for National Research Initiatives.
   4 Copyright (c) 1990-1995, Stichting Mathematisch Centrum.
   5 All rights reserved.
   6
   7 See the file "Misc/COPYRIGHT" for information on usage and
   8 redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
   9 ******************************************************************/
  10
  11 /* Array object implementation */
  12
  13 /* An array is a uniform list -- all items have the same type.
  14    The item type is restricted to simple C types like int or float */
  15
  16 #include "Python.h"
  17
  18 #ifdef STDC_HEADERS
  19 #include <stddef.h>
  20 #else /* !STDC_HEADERS */
  21 #ifndef DONT_HAVE_SYS_TYPES_H
  22 #include <sys/types.h>          /* For size_t */
  23 #endif /* DONT_HAVE_SYS_TYPES_H */
  24 #endif /* !STDC_HEADERS */
  25 #ifdef HAVE_LIMITS_H
  26 #include <limits.h>
  27 #endif /* HAVE_LIMITS_H */
  28
  29 struct arrayobject; /* Forward */
  30
  31 struct arraydescr {
  32         int typecode;
  33         int itemsize;
  34         PyObject * (*getitem)(struct arrayobject *, int);
  35         int (*setitem)(struct arrayobject *, int, PyObject *);
  36 };
  37
  38 typedef struct arrayobject {
  39         PyObject_VAR_HEAD
  40         char *ob_item;
  41         struct arraydescr *ob_descr;
  42 } arrayobject;
  43
  44 staticforward PyTypeObject Arraytype;
  45
  46 #define is_arrayobject(op) ((op)->ob_type == &Arraytype)
  47
  48 /* Forward */
  49 static PyObject *newarrayobject(int, struct arraydescr *);
  50 #if 0
  51 static int getarraysize(PyObject *);
  52 #endif
  53 static PyObject *getarrayitem(PyObject *, int);
  54 static int setarrayitem(PyObject *, int, PyObject *);
  55 #if 0
  56 static int insarrayitem(PyObject *, int, PyObject *);
  57 static int addarrayitem(PyObject *, PyObject *);
  58 #endif
  59
  60 static PyObject *
  61 c_getitem(arrayobject *ap, int i)
  62 {
  63         return PyString_FromStringAndSize(&((char *)ap->ob_item)[i], 1);
  64 }
  65
  66 static int
  67 c_setitem(arrayobject *ap, int i, PyObject *v)
  68 {
  69         char x;
  70         if (!PyArg_Parse(v, "c;array item must be char", &x))
  71                 return -1;
  72         if (i >= 0)
  73                      ((char *)ap->ob_item)[i] = x;
  74         return 0;
  75 }
  76
  77 static PyObject *
  78 b_getitem(arrayobject *ap, int i)
  79 {
  80         long x = ((char *)ap->ob_item)[i];
  81         if (x >= 128)
  82                 x -= 256;
  83         return PyInt_FromLong(x);
  84 }
  85
  86 static int
  87 b_setitem(arrayobject *ap, int i, PyObject *v)
  88 {
  89         short x;
  90         /* PyArg_Parse's 'b' formatter is for an unsigned char, therefore
  91            must use the next size up that is signed ('h') and manually do
  92            the overflow checking */
  93         if (!PyArg_Parse(v, "h;array item must be integer", &x))
  94                 return -1;
  95         else if (x < -128) {
  96                 PyErr_SetString(PyExc_OverflowError,
  97                         "signed char is less than minimum");
  98                 return -1;
  99         }
 100         else if (x > 127) {
 101                 PyErr_SetString(PyExc_OverflowError,
 102                         "signed char is greater than maximum");
 103                 return -1;
 104         }
 105         if (i >= 0)
 106                 ((char *)ap->ob_item)[i] = (char)x;
 107         return 0;
 108 }
 109
 110 static PyObject *
 111 BB_getitem(arrayobject *ap, int i)
 112 {
 113         long x = ((unsigned char *)ap->ob_item)[i];
 114         return PyInt_FromLong(x);
 115 }
 116
 117 static int
 118 BB_setitem(arrayobject *ap, int i, PyObject *v)
 119 {
 120         unsigned char x;
 121         /* 'B' == unsigned char, maps to PyArg_Parse's 'b' formatter */
 122         if (!PyArg_Parse(v, "b;array item must be integer", &x))
 123                 return -1;
 124         if (i >= 0)
 125                      ((char *)ap->ob_item)[i] = x;
 126         return 0;
 127 }
 128
 129 static PyObject *
 130 h_getitem(arrayobject *ap, int i)
 131 {
 132         return PyInt_FromLong((long) ((short *)ap->ob_item)[i]);
 133 }
 134
 135 static int
 136 h_setitem(arrayobject *ap, int i, PyObject *v)
 137 {
 138         short x;
 139         /* 'h' == signed short, maps to PyArg_Parse's 'h' formatter */
 140         if (!PyArg_Parse(v, "h;array item must be integer", &x))
 141                 return -1;
 142         if (i >= 0)
 143                      ((short *)ap->ob_item)[i] = x;
 144         return 0;
 145 }
 146
 147 static PyObject *
 148 HH_getitem(arrayobject *ap, int i)
 149 {
 150         return PyInt_FromLong((long) ((unsigned short *)ap->ob_item)[i]);
 151 }
 152
 153 static int
 154 HH_setitem(arrayobject *ap, int i, PyObject *v)
 155 {
 156         int x;
 157         /* PyArg_Parse's 'h' formatter is for a signed short, therefore
 158            must use the next size up and manually do the overflow checking */
 159         if (!PyArg_Parse(v, "i;array item must be integer", &x))
 160                 return -1;
 161         else if (x < 0) {
 162                 PyErr_SetString(PyExc_OverflowError,
 163                         "unsigned short is less than minimum");
 164                 return -1;
 165         }
 166         else if (x > USHRT_MAX) {
 167                 PyErr_SetString(PyExc_OverflowError,
 168                         "unsigned short is greater than maximum");
 169                 return -1;
 170         }
 171         if (i >= 0)
 172                 ((short *)ap->ob_item)[i] = (short)x;
 173         return 0;
 174 }
 175
 176 static PyObject *
 177 i_getitem(arrayobject *ap, int i)
 178 {
 179         return PyInt_FromLong((long) ((int *)ap->ob_item)[i]);
 180 }
 181
 182 static int
 183 i_setitem(arrayobject *ap, int i, PyObject *v)
 184 {
 185         int x;
 186         /* 'i' == signed int, maps to PyArg_Parse's 'i' formatter */
 187         if (!PyArg_Parse(v, "i;array item must be integer", &x))
 188                 return -1;
 189         if (i >= 0)
 190                      ((int *)ap->ob_item)[i] = x;
 191         return 0;
 192 }
 193
 194 static PyObject *
 195 II_getitem(arrayobject *ap, int i)
 196 {
 197         return PyLong_FromUnsignedLong(
 198                 (unsigned long) ((unsigned int *)ap->ob_item)[i]);
 199 }
 200
 201 static int
 202 II_setitem(arrayobject *ap, int i, PyObject *v)
 203 {
 204         unsigned long x;
 205         if (PyLong_Check(v)) {
 206                 x = PyLong_AsUnsignedLong(v);
 207                 if (x == (unsigned long) -1 && PyErr_Occurred())
 208                         return -1;
 209         }
 210         else {
 211                 long y;
 212                 if (!PyArg_Parse(v, "l;array item must be integer", &y))
 213                         return -1;
 214                 if (y < 0) {
 215                         PyErr_SetString(PyExc_OverflowError,
 216                                 "unsigned int is less than minimum");
 217                         return -1;
 218                 }
 219                 x = (unsigned long)y;
 220
 221         }
 222         if (x > UINT_MAX) {
 223                 PyErr_SetString(PyExc_OverflowError,
 224                         "unsigned int is greater than maximum");
 225                 return -1;
 226         }
 227
 228         if (i >= 0)
 229                 ((unsigned int *)ap->ob_item)[i] = (unsigned int)x;
 230         return 0;
 231 }
 232
 233 static PyObject *
 234 l_getitem(arrayobject *ap, int i)
 235 {
 236         return PyInt_FromLong(((long *)ap->ob_item)[i]);
 237 }
 238
 239 static int
 240 l_setitem(arrayobject *ap, int i, PyObject *v)
 241 {
 242         long x;
 243         if (!PyArg_Parse(v, "l;array item must be integer", &x))
 244                 return -1;
 245         if (i >= 0)
 246                      ((long *)ap->ob_item)[i] = x;
 247         return 0;
 248 }
 249
 250 static PyObject *
 251 LL_getitem(arrayobject *ap, int i)
 252 {
 253         return PyLong_FromUnsignedLong(((unsigned long *)ap->ob_item)[i]);
 254 }
 255
 256 static int
 257 LL_setitem(arrayobject *ap, int i, PyObject *v)
 258 {
 259         unsigned long x;
 260         if (PyLong_Check(v)) {
 261                 x = PyLong_AsUnsignedLong(v);
 262                 if (x == (unsigned long) -1 && PyErr_Occurred())
 263                         return -1;
 264         }
 265         else {
 266                 long y;
 267                 if (!PyArg_Parse(v, "l;array item must be integer", &y))
 268                         return -1;
 269                 if (y < 0) {
 270                         PyErr_SetString(PyExc_OverflowError,
 271                                 "unsigned long is less than minimum");
 272                         return -1;
 273                 }
 274                 x = (unsigned long)y;
 275
 276         }
 277         if (x > ULONG_MAX) {
 278                 PyErr_SetString(PyExc_OverflowError,
 279                         "unsigned long is greater than maximum");
 280                 return -1;
 281         }
 282
 283         if (i >= 0)
 284                 ((unsigned long *)ap->ob_item)[i] = x;
 285         return 0;
 286 }
 287
 288 static PyObject *
 289 f_getitem(arrayobject *ap, int i)
 290 {
 291         return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]);
 292 }
 293
 294 static int
 295 f_setitem(arrayobject *ap, int i, PyObject *v)
 296 {
 297         float x;
 298         if (!PyArg_Parse(v, "f;array item must be float", &x))
 299                 return -1;
 300         if (i >= 0)
 301                      ((float *)ap->ob_item)[i] = x;
 302         return 0;
 303 }
 304
 305 static PyObject *
 306 d_getitem(arrayobject *ap, int i)
 307 {
 308         return PyFloat_FromDouble(((double *)ap->ob_item)[i]);
 309 }
 310
 311 static int
 312 d_setitem(arrayobject *ap, int i, PyObject *v)
 313 {
 314         double x;
 315         if (!PyArg_Parse(v, "d;array item must be float", &x))
 316                 return -1;
 317         if (i >= 0)
 318                      ((double *)ap->ob_item)[i] = x;
 319         return 0;
 320 }
 321
 322 /* Description of types */
 323 static struct arraydescr descriptors[] = {
 324         {'c', sizeof(char), c_getitem, c_setitem},
 325         {'b', sizeof(char), b_getitem, b_setitem},
 326         {'B', sizeof(char), BB_getitem, BB_setitem},
 327         {'h', sizeof(short), h_getitem, h_setitem},
 328         {'H', sizeof(short), HH_getitem, HH_setitem},
 329         {'i', sizeof(int), i_getitem, i_setitem},
 330         {'I', sizeof(int), II_getitem, II_setitem},
 331         {'l', sizeof(long), l_getitem, l_setitem},
 332         {'L', sizeof(long), LL_getitem, LL_setitem},
 333         {'f', sizeof(float), f_getitem, f_setitem},
 334         {'d', sizeof(double), d_getitem, d_setitem},
 335         {'\0', 0, 0, 0} /* Sentinel */
 336 };
 337 /* If we ever allow items larger than double, we must change reverse()! */
 338
 339
 340 static PyObject *
 341 newarrayobject(int size, struct arraydescr *descr)
 342 {
 343         arrayobject *op;
 344         size_t nbytes;
 345         if (size < 0) {
 346                 PyErr_BadInternalCall();
 347                 return NULL;
 348         }
 349         nbytes = size * descr->itemsize;
 350         /* Check for overflow */
 351         if (nbytes / descr->itemsize != (size_t)size) {
 352                 return PyErr_NoMemory();
 353         }
 354         op = PyObject_NewVar(arrayobject, &Arraytype, size);
 355         if (op == NULL) {
 356                 return PyErr_NoMemory();
 357         }
 358         if (size <= 0) {
 359                 op->ob_item = NULL;
 360         }
 361         else {
 362                 op->ob_item = PyMem_NEW(char, nbytes);
 363                 if (op->ob_item == NULL) {
 364                         PyObject_Del(op);
 365                         return PyErr_NoMemory();
 366                 }
 367         }
 368         op->ob_descr = descr;
 369         return (PyObject *) op;
 370 }
 371
 372 #if 0
 373 static int
 374 getarraysize(PyObject *op)
 375 {
 376         if (!is_arrayobject(op)) {
 377                 PyErr_BadInternalCall();
 378                 return -1;
 379         }
 380         return ((arrayobject *)op) -> ob_size;
 381 }
 382 #endif
 383
 384 static PyObject *
 385 getarrayitem(PyObject *op, int i)
 386 {
 387         register arrayobject *ap;
 388         if (!is_arrayobject(op)) {
 389                 PyErr_BadInternalCall();
 390                 return NULL;
 391         }
 392         ap = (arrayobject *)op;
 393         if (i < 0 || i >= ap->ob_size) {
 394                 PyErr_SetString(PyExc_IndexError, "array index out of range");
 395                 return NULL;
 396         }
 397         return (*ap->ob_descr->getitem)(ap, i);
 398 }
 399
 400 static int
 401 ins1(arrayobject *self, int where, PyObject *v)
 402 {
 403         char *items;
 404         if (v == NULL) {
 405                 PyErr_BadInternalCall();
 406                 return -1;
 407         }
 408         if ((*self->ob_descr->setitem)(self, -1, v) < 0)
 409                 return -1;
 410         items = self->ob_item;
 411         PyMem_RESIZE(items, char,
 412                      (self->ob_size+1) * self->ob_descr->itemsize);
 413         if (items == NULL) {
 414                 PyErr_NoMemory();
 415                 return -1;
 416         }
 417         if (where < 0)
 418                 where = 0;
 419         if (where > self->ob_size)
 420                 where = self->ob_size;
 421         memmove(items + (where+1)*self->ob_descr->itemsize,
 422                 items + where*self->ob_descr->itemsize,
 423                 (self->ob_size-where)*self->ob_descr->itemsize);
 424         self->ob_item = items;
 425         self->ob_size++;
 426         return (*self->ob_descr->setitem)(self, where, v);
 427 }
 428
 429 #if 0
 430 static int
 431 insarrayitem(PyObject *op, int where, PyObject *newitem)
 432 {
 433         if (!is_arrayobject(op)) {
 434                 PyErr_BadInternalCall();
 435                 return -1;
 436         }
 437         return ins1((arrayobject *)op, where, newitem);
 438 }
 439
 440 static int
 441 addarrayitem(PyObject *op, PyObject *newitem)
 442 {
 443         if (!is_arrayobject(op)) {
 444                 PyErr_BadInternalCall();
 445                 return -1;
 446         }
 447         return ins1((arrayobject *)op,
 448                 (int) ((arrayobject *)op)->ob_size, newitem);
 449 }
 450 #endif
 451
 452 /* Methods */
 453
 454 static void
 455 array_dealloc(arrayobject *op)
 456 {
 457         if (op->ob_item != NULL)
 458                 PyMem_DEL(op->ob_item);
 459         PyObject_Del(op);
 460 }
 461
 462 static int
 463 array_compare(arrayobject *v, arrayobject *w)
 464 {
 465         int len = (v->ob_size < w->ob_size) ? v->ob_size : w->ob_size;
 466         int i;
 467         for (i = 0; i < len; i++) {
 468                 PyObject *ai, *bi;
 469                 int cmp;
 470                 ai = getarrayitem((PyObject *)v, i);
 471                 bi = getarrayitem((PyObject *)w, i);
 472                 if (ai && bi)
 473                         cmp = PyObject_Compare(ai, bi);
 474                 else
 475                         cmp = -1;
 476                 Py_XDECREF(ai);
 477                 Py_XDECREF(bi);
 478                 if (cmp != 0)
 479                         return cmp;
 480         }
 481         return v->ob_size - w->ob_size;
 482 }
 483
 484 static int
 485 array_length(arrayobject *a)
 486 {
 487         return a->ob_size;
 488 }
 489
 490 static PyObject *
 491 array_item(arrayobject *a, int i)
 492 {
 493         if (i < 0 || i >= a->ob_size) {
 494                 PyErr_SetString(PyExc_IndexError, "array index out of range");
 495                 return NULL;
 496         }
 497         return getarrayitem((PyObject *)a, i);
 498 }
 499
 500 static PyObject *
 501 array_slice(arrayobject *a, int ilow, int ihigh)
 502 {
 503         arrayobject *np;
 504         if (ilow < 0)
 505                 ilow = 0;
 506         else if (ilow > a->ob_size)
 507                 ilow = a->ob_size;
 508         if (ihigh < 0)
 509                 ihigh = 0;
 510         if (ihigh < ilow)
 511                 ihigh = ilow;
 512         else if (ihigh > a->ob_size)
 513                 ihigh = a->ob_size;
 514         np = (arrayobject *) newarrayobject(ihigh - ilow, a->ob_descr);
 515         if (np == NULL)
 516                 return NULL;
 517         memcpy(np->ob_item, a->ob_item + ilow * a->ob_descr->itemsize,
 518                (ihigh-ilow) * a->ob_descr->itemsize);
 519         return (PyObject *)np;
 520 }
 521
 522 static PyObject *
 523 array_concat(arrayobject *a, PyObject *bb)
 524 {
 525         int size;
 526         arrayobject *np;
 527         if (!is_arrayobject(bb)) {
 528                 PyErr_Format(PyExc_TypeError,
 529                      "can only append array (not \"%.200s\") to array",
 530                              bb->ob_type->tp_name);
 531                 return NULL;
 532         }
 533 #define b ((arrayobject *)bb)
 534         if (a->ob_descr != b->ob_descr) {
 535                 PyErr_BadArgument();
 536                 return NULL;
 537         }
 538         size = a->ob_size + b->ob_size;
 539         np = (arrayobject *) newarrayobject(size, a->ob_descr);
 540         if (np == NULL) {
 541                 return NULL;
 542         }
 543         memcpy(np->ob_item, a->ob_item, a->ob_size*a->ob_descr->itemsize);
 544         memcpy(np->ob_item + a->ob_size*a->ob_descr->itemsize,
 545                b->ob_item, b->ob_size*b->ob_descr->itemsize);
 546         return (PyObject *)np;
 547 #undef b
 548 }
 549
 550 static PyObject *
 551 array_repeat(arrayobject *a, int n)
 552 {
 553         int i;
 554         int size;
 555         arrayobject *np;
 556         char *p;
 557         int nbytes;
 558         if (n < 0)
 559                 n = 0;
 560         size = a->ob_size * n;
 561         np = (arrayobject *) newarrayobject(size, a->ob_descr);
 562         if (np == NULL)
 563                 return NULL;
 564         p = np->ob_item;
 565         nbytes = a->ob_size * a->ob_descr->itemsize;
 566         for (i = 0; i < n; i++) {
 567                 memcpy(p, a->ob_item, nbytes);
 568                 p += nbytes;
 569         }
 570         return (PyObject *) np;
 571 }
 572
 573 static int
 574 array_ass_slice(arrayobject *a, int ilow, int ihigh, PyObject *v)
 575 {
 576         char *item;
 577         int n; /* Size of replacement array */
 578         int d; /* Change in size */
 579 #define b ((arrayobject *)v)
 580         if (v == NULL)
 581                 n = 0;
 582         else if (is_arrayobject(v)) {
 583                 n = b->ob_size;
 584                 if (a == b) {
 585                         /* Special case "a[i:j] = a" -- copy b first */
 586                         int ret;
 587                         v = array_slice(b, 0, n);
 588                         ret = array_ass_slice(a, ilow, ihigh, v);
 589                         Py_DECREF(v);
 590                         return ret;
 591                 }
 592                 if (b->ob_descr != a->ob_descr) {
 593                         PyErr_BadArgument();
 594                         return -1;
 595                 }
 596         }
 597         else {
 598                 PyErr_Format(PyExc_TypeError,
 599              "can only assign array (not \"%.200s\") to array slice",
 600                              v->ob_type->tp_name);
 601                 return -1;
 602         }
 603         if (ilow < 0)
 604                 ilow = 0;
 605         else if (ilow > a->ob_size)
 606                 ilow = a->ob_size;
 607         if (ihigh < 0)
 608                 ihigh = 0;
 609         if (ihigh < ilow)
 610                 ihigh = ilow;
 611         else if (ihigh > a->ob_size)
 612                 ihigh = a->ob_size;
 613         item = a->ob_item;
 614         d = n - (ihigh-ilow);
 615         if (d < 0) { /* Delete -d items */
 616                 memmove(item + (ihigh+d)*a->ob_descr->itemsize,
 617                         item + ihigh*a->ob_descr->itemsize,
 618                         (a->ob_size-ihigh)*a->ob_descr->itemsize);
 619                 a->ob_size += d;
 620                 PyMem_RESIZE(item, char, a->ob_size*a->ob_descr->itemsize);
 621                                                 /* Can't fail */
 622                 a->ob_item = item;
 623         }
 624         else if (d > 0) { /* Insert d items */
 625                 PyMem_RESIZE(item, char,
 626                              (a->ob_size + d)*a->ob_descr->itemsize);
 627                 if (item == NULL) {
 628                         PyErr_NoMemory();
 629                         return -1;
 630                 }
 631                 memmove(item + (ihigh+d)*a->ob_descr->itemsize,
 632                         item + ihigh*a->ob_descr->itemsize,
 633                         (a->ob_size-ihigh)*a->ob_descr->itemsize);
 634                 a->ob_item = item;
 635                 a->ob_size += d;
 636         }
 637         if (n > 0)
 638                 memcpy(item + ilow*a->ob_descr->itemsize, b->ob_item,
 639                        n*b->ob_descr->itemsize);
 640         return 0;
 641 #undef b
 642 }
 643
 644 static int
 645 array_ass_item(arrayobject *a, int i, PyObject *v)
 646 {
 647         if (i < 0 || i >= a->ob_size) {
 648                 PyErr_SetString(PyExc_IndexError,
 649                                  "array assignment index out of range");
 650                 return -1;
 651         }
 652         if (v == NULL)
 653                 return array_ass_slice(a, i, i+1, v);
 654         return (*a->ob_descr->setitem)(a, i, v);
 655 }
 656
 657 static int
 658 setarrayitem(PyObject *a, int i, PyObject *v)
 659 {
 660         if (!is_arrayobject(a)) {
 661                 PyErr_BadInternalCall();
 662                 return -1;
 663         }
 664         return array_ass_item((arrayobject *)a, i, v);
 665 }
 666
 667 static PyObject *
 668 ins(arrayobject *self, int where, PyObject *v)
 669 {
 670         if (ins1(self, where, v) != 0)
 671                 return NULL;
 672         Py_INCREF(Py_None);
 673         return Py_None;
 674 }
 675
 676 static PyObject *
 677 array_count(arrayobject *self, PyObject *args)
 678 {
 679         int count = 0;
 680         int i;
 681         PyObject *v;
 682
 683         if (!PyArg_ParseTuple(args, "O:count", &v))
 684                 return NULL;
 685         for (i = 0; i < self->ob_size; i++) {
 686                 PyObject *selfi = getarrayitem((PyObject *)self, i);
 687                 if (PyObject_Compare(selfi, v) == 0)
 688                         count++;
 689                 Py_DECREF(selfi);
 690                 if (PyErr_Occurred())
 691                         return NULL;
 692         }
 693         return PyInt_FromLong((long)count);
 694 }
 695
 696 static char count_doc [] =
 697 "count (x)\n\
 698 \n\
 699 Return number of occurences of x in the array.";
 700
 701 static PyObject *
 702 array_index(arrayobject *self, PyObject *args)
 703 {
 704         int i;
 705         PyObject *v;
 706
 707         if (!PyArg_ParseTuple(args, "O:index", &v))
 708                 return NULL;
 709         for (i = 0; i < self->ob_size; i++) {
 710                 PyObject *selfi = getarrayitem((PyObject *)self, i);
 711                 if (PyObject_Compare(selfi, v) == 0) {
 712                         Py_DECREF(selfi);
 713                         return PyInt_FromLong((long)i);
 714                 }
 715                 Py_DECREF(selfi);
 716                 if (PyErr_Occurred())
 717                         return NULL;
 718         }
 719         PyErr_SetString(PyExc_ValueError, "array.index(x): x not in list");
 720         return NULL;
 721 }
 722
 723 static char index_doc [] =
 724 "index (x)\n\
 725 \n\
 726 Return index of first occurence of x in the array.";
 727
 728 static PyObject *
 729 array_remove(arrayobject *self, PyObject *args)
 730 {
 731         int i;
 732         PyObject *v;
 733
 734         if (!PyArg_ParseTuple(args, "O:remove", &v))
 735                 return NULL;
 736         for (i = 0; i < self->ob_size; i++) {
 737                 PyObject *selfi = getarrayitem((PyObject *)self,i);
 738                 if (PyObject_Compare(selfi, v) == 0) {
 739                         Py_DECREF(selfi);
 740                         if (array_ass_slice(self, i, i+1,
 741                                            (PyObject *)NULL) != 0)
 742                                 return NULL;
 743                         Py_INCREF(Py_None);
 744                         return Py_None;
 745                 }
 746                 Py_DECREF(selfi);
 747                 if (PyErr_Occurred())
 748                         return NULL;
 749         }
 750         PyErr_SetString(PyExc_ValueError, "array.remove(x): x not in list");
 751         return NULL;
 752 }
 753
 754 static char remove_doc [] =
 755 "remove (x)\n\
 756 \n\
 757 Remove the first occurence of x in the array.";
 758
 759 static PyObject *
 760 array_pop(arrayobject *self, PyObject *args)
 761 {
 762         int i = -1;
 763         PyObject *v;
 764         if (!PyArg_ParseTuple(args, "|i:pop", &i))
 765                 return NULL;
 766         if (self->ob_size == 0) {
 767                 /* Special-case most common failure cause */
 768                 PyErr_SetString(PyExc_IndexError, "pop from empty array");
 769                 return NULL;
 770         }
 771         if (i < 0)
 772                 i += self->ob_size;
 773         if (i < 0 || i >= self->ob_size) {
 774                 PyErr_SetString(PyExc_IndexError, "pop index out of range");
 775                 return NULL;
 776         }
 777         v = getarrayitem((PyObject *)self,i);
 778         if (array_ass_slice(self, i, i+1, (PyObject *)NULL) != 0) {
 779                 Py_DECREF(v);
 780                 return NULL;
 781         }
 782         return v;
 783 }
 784
 785 static char pop_doc [] =
 786 "pop ([i])\n\
 787 \n\
 788 Return the i-th element and delete it from the array. i defaults to -1.";
 789
 790 static PyObject *
 791 array_extend(self, args)
 792         arrayobject *self;
 793         PyObject *args;
 794 {
 795         int size;
 796         PyObject    *bb;
 797
 798         if (!PyArg_ParseTuple(args, "O:extend", &bb))
 799             return NULL;
 800
 801         if (!is_arrayobject(bb)) {
 802                 PyErr_Format(PyExc_TypeError,
 803                              "can only extend array with array (not \"%.200s\")",
 804                              bb->ob_type->tp_name);
 805                 return NULL;
 806         }
 807 #define b ((arrayobject *)bb)
 808         if (self->ob_descr != b->ob_descr) {
 809                 PyErr_SetString(PyExc_TypeError,
 810                              "can only extend with array of same kind");
 811                 return NULL;
 812         }
 813         size = self->ob_size + b->ob_size;
 814         PyMem_RESIZE(self->ob_item, char, size*self->ob_descr->itemsize);
 815         if (self->ob_item == NULL) {
 816                 PyObject_Del(self);
 817                 return PyErr_NoMemory();
 818         }
 819         memcpy(self->ob_item + self->ob_size*self->ob_descr->itemsize,
 820                b->ob_item, b->ob_size*b->ob_descr->itemsize);
 821         self->ob_size = size;
 822         Py_INCREF(Py_None);
 823         return Py_None;
 824 #undef b
 825 }
 826
 827 static char extend_doc [] =
 828 "extend(array)\n\
 829 \n\
 830  Append array items to the end of the array.";
 831
 832 static PyObject *
 833 array_insert(arrayobject *self, PyObject *args)
 834 {
 835         int i;
 836         PyObject *v;
 837         if (!PyArg_ParseTuple(args, "iO:insert", &i, &v))
 838                 return NULL;
 839         return ins(self, i, v);
 840 }
 841
 842 static char insert_doc [] =
 843 "insert (i,x)\n\
 844 \n\
 845 Insert a new item x into the array before position i.";
 846
 847
 848 static PyObject *
 849 array_buffer_info(arrayobject *self, PyObject *args)
 850 {
 851         PyObject* retval = PyTuple_New(2);
 852         if (!retval) return NULL;
 853
 854         PyTuple_SET_ITEM(retval, 0, PyLong_FromVoidPtr(self->ob_item));
 855         PyTuple_SET_ITEM(retval, 1, PyInt_FromLong((long)(self->ob_size)));
 856
 857         return retval;
 858 }
 859
 860 static char buffer_info_doc [] =
 861 "buffer_info -> (address, length)\n\
 862 \n\
 863 Return a tuple (address, length) giving the current memory address and\n\
 864 the length in bytes of the buffer used to hold array's contents.";
 865
 866
 867 static PyObject *
 868 array_append(arrayobject *self, PyObject *args)
 869 {
 870         PyObject *v;
 871         if (!PyArg_ParseTuple(args, "O:append", &v))
 872                 return NULL;
 873         return ins(self, (int) self->ob_size, v);
 874 }
 875
 876 static char append_doc [] =
 877 "append(x)\n\
 878 \n\
 879 Append new value x to the end of the array.";
 880
 881
 882 static PyObject *
 883 array_byteswap(arrayobject *self, PyObject *args)
 884 {
 885         char *p;
 886         int i;
 887
 888         if (!PyArg_ParseTuple(args, ":byteswap"))
 889                 return NULL;
 890
 891         switch (self->ob_descr->itemsize) {
 892         case 1:
 893                 break;
 894         case 2:
 895                 for (p = self->ob_item, i = self->ob_size; --i >= 0; p += 2) {
 896                         char p0 = p[0];
 897                         p[0] = p[1];
 898                         p[1] = p0;
 899                 }
 900                 break;
 901         case 4:
 902                 for (p = self->ob_item, i = self->ob_size; --i >= 0; p += 4) {
 903                         char p0 = p[0];
 904                         char p1 = p[1];
 905                         p[0] = p[3];
 906                         p[1] = p[2];
 907                         p[2] = p1;
 908                         p[3] = p0;
 909                 }
 910                 break;
 911         case 8:
 912                 for (p = self->ob_item, i = self->ob_size; --i >= 0; p += 8) {
 913                         char p0 = p[0];
 914                         char p1 = p[1];
 915                         char p2 = p[2];
 916                         char p3 = p[3];
 917                         p[0] = p[7];
 918                         p[1] = p[6];
 919                         p[2] = p[5];
 920                         p[3] = p[4];
 921                         p[4] = p3;
 922                         p[5] = p2;
 923                         p[6] = p1;
 924                         p[7] = p0;
 925                 }
 926                 break;
 927         default:
 928                 PyErr_SetString(PyExc_RuntimeError,
 929                            "don't know how to byteswap this array type");
 930                 return NULL;
 931         }
 932         Py_INCREF(Py_None);
 933         return Py_None;
 934 }
 935
 936 static char byteswap_doc [] =
 937 "byteswap()\n\
 938 \n\
 939 Byteswap all items of the array.  If the items in the array are not 1, 2,\n\
 940 4, or 8 bytes in size, RuntimeError is raised.";
 941
 942 static PyObject *
 943 array_reverse(arrayobject *self, PyObject *args)
 944 {
 945         register int itemsize = self->ob_descr->itemsize;
 946         register char *p, *q;
 947         char tmp[sizeof(double)]; /* Assume that's the max item size */
 948
 949         if (args != NULL) {
 950                 PyErr_SetString(PyExc_TypeError,
 951                      "<array>.reverse requires exactly 0 arguments");
 952                 return NULL;
 953         }
 954
 955         if (self->ob_size > 1) {
 956                 for (p = self->ob_item,
 957                      q = self->ob_item + (self->ob_size - 1)*itemsize;
 958                      p < q;
 959                      p += itemsize, q -= itemsize) {
 960                         memmove(tmp, p, itemsize);
 961                         memmove(p, q, itemsize);
 962                         memmove(q, tmp, itemsize);
 963                 }
 964         }
 965
 966         Py_INCREF(Py_None);
 967         return Py_None;
 968 }
 969
 970 static char reverse_doc [] =
 971 "reverse()\n\
 972 \n\
 973 Reverse the order of the items in the array.";
 974
 975 static PyObject *
 976 array_fromfile(arrayobject *self, PyObject *args)
 977 {
 978         PyObject *f;
 979         int n;
 980         FILE *fp;
 981         if (!PyArg_ParseTuple(args, "Oi:fromfile", &f, &n))
 982                 return NULL;
 983         fp = PyFile_AsFile(f);
 984         if (fp == NULL) {
 985                 PyErr_SetString(PyExc_TypeError, "arg1 must be open file");
 986                 return NULL;
 987         }
 988         if (n > 0) {
 989                 char *item = self->ob_item;
 990                 int itemsize = self->ob_descr->itemsize;
 991                 size_t nread;
 992                 int newlength;
 993                 size_t newbytes;
 994                 /* Be careful here about overflow */
 995                 if ((newlength = self->ob_size + n) <= 0 ||
 996                     (newbytes = newlength * itemsize) / itemsize !=
 997                     (size_t)newlength)
 998                         goto nomem;
 999                 PyMem_RESIZE(item, char, newbytes);
1000                 if (item == NULL) {
1001                   nomem:
1002                         PyErr_NoMemory();
1003                         return NULL;
1004                 }
1005                 self->ob_item = item;
1006                 self->ob_size += n;
1007                 nread = fread(item + (self->ob_size - n) * itemsize,
1008                               itemsize, n, fp);
1009                 if (nread < (size_t)n) {
1010                         self->ob_size -= (n - nread);
1011                         PyMem_RESIZE(item, char, self->ob_size*itemsize);
1012                         self->ob_item = item;
1013                         PyErr_SetString(PyExc_EOFError,
1014                                          "not enough items in file");
1015                         return NULL;
1016                 }
1017         }
1018         Py_INCREF(Py_None);
1019         return Py_None;
1020 }
1021
1022 static char fromfile_doc [] =
1023 "fromfile(f, n)\n\
1024 \n\
1025 Read n objects from the file object f and append them to the end of the\n\
1026 array.  Also called as read.";
1027
1028
1029 static PyObject *
1030 array_tofile(arrayobject *self, PyObject *args)
1031 {
1032         PyObject *f;
1033         FILE *fp;
1034         if (!PyArg_ParseTuple(args, "O:tofile", &f))
1035                 return NULL;
1036         fp = PyFile_AsFile(f);
1037         if (fp == NULL) {
1038                 PyErr_SetString(PyExc_TypeError, "arg must be open file");
1039                 return NULL;
1040         }
1041         if (self->ob_size > 0) {
1042                 if (fwrite(self->ob_item, self->ob_descr->itemsize,
1043                            self->ob_size, fp) != (size_t)self->ob_size) {
1044                         PyErr_SetFromErrno(PyExc_IOError);
1045                         clearerr(fp);
1046                         return NULL;
1047                 }
1048         }
1049         Py_INCREF(Py_None);
1050         return Py_None;
1051 }
1052
1053 static char tofile_doc [] =
1054 "tofile(f)\n\
1055 \n\
1056 Write all items (as machine values) to the file object f.  Also called as\n\
1057 write.";
1058
1059
1060 static PyObject *
1061 array_fromlist(arrayobject *self, PyObject *args)
1062 {
1063         int n;
1064         PyObject *list;
1065         int itemsize = self->ob_descr->itemsize;
1066         if (!PyArg_ParseTuple(args, "O:fromlist", &list))
1067                 return NULL;
1068         if (!PyList_Check(list)) {
1069                 PyErr_SetString(PyExc_TypeError, "arg must be list");
1070                 return NULL;
1071         }
1072         n = PyList_Size(list);
1073         if (n > 0) {
1074                 char *item = self->ob_item;
1075                 int i;
1076                 PyMem_RESIZE(item, char, (self->ob_size + n) * itemsize);
1077                 if (item == NULL) {
1078                         PyErr_NoMemory();
1079                         return NULL;
1080                 }
1081                 self->ob_item = item;
1082                 self->ob_size += n;
1083                 for (i = 0; i < n; i++) {
1084                         PyObject *v = PyList_GetItem(list, i);
1085                         if ((*self->ob_descr->setitem)(self,
1086                                         self->ob_size - n + i, v) != 0) {
1087                                 self->ob_size -= n;
1088                                 PyMem_RESIZE(item, char,
1089                                                   self->ob_size * itemsize);
1090                                 self->ob_item = item;
1091                                 return NULL;
1092                         }
1093                 }
1094         }
1095         Py_INCREF(Py_None);
1096         return Py_None;
1097 }
1098
1099 static char fromlist_doc [] =
1100 "fromlist(list)\n\
1101 \n\
1102 Append items to array from list.";
1103
1104
1105 static PyObject *
1106 array_tolist(arrayobject *self, PyObject *args)
1107 {
1108         PyObject *list = PyList_New(self->ob_size);
1109         int i;
1110         if (!PyArg_ParseTuple(args, ":tolist"))
1111                 return NULL;
1112         if (list == NULL)
1113                 return NULL;
1114         for (i = 0; i < self->ob_size; i++) {
1115                 PyObject *v = getarrayitem((PyObject *)self, i);
1116                 if (v == NULL) {
1117                         Py_DECREF(list);
1118                         return NULL;
1119                 }
1120                 PyList_SetItem(list, i, v);
1121         }
1122         return list;
1123 }
1124
1125 static char tolist_doc [] =
1126 "tolist() -> list\n\
1127 \n\
1128 Convert array to an ordinary list with the same items.";
1129
1130
1131 static PyObject *
1132 array_fromstring(arrayobject *self, PyObject *args)
1133 {
1134         char *str;
1135         int n;
1136         int itemsize = self->ob_descr->itemsize;
1137         if (!PyArg_ParseTuple(args, "s#:fromstring", &str, &n))
1138                 return NULL;
1139         if (n % itemsize != 0) {
1140                 PyErr_SetString(PyExc_ValueError,
1141                            "string length not a multiple of item size");
1142                 return NULL;
1143         }
1144         n = n / itemsize;
1145         if (n > 0) {
1146                 char *item = self->ob_item;
1147                 PyMem_RESIZE(item, char, (self->ob_size + n) * itemsize);
1148                 if (item == NULL) {
1149                         PyErr_NoMemory();
1150                         return NULL;
1151                 }
1152                 self->ob_item = item;
1153                 self->ob_size += n;
1154                 memcpy(item + (self->ob_size - n) * itemsize,
1155                        str, itemsize*n);
1156         }
1157         Py_INCREF(Py_None);
1158         return Py_None;
1159 }
1160
1161 static char fromstring_doc [] =
1162 "fromstring(string)\n\
1163 \n\
1164 Appends items from the string, interpreting it as an array of machine\n\
1165 values,as if it had been read from a file using the fromfile() method).";
1166
1167
1168 static PyObject *
1169 array_tostring(arrayobject *self, PyObject *args)
1170 {
1171         if (!PyArg_ParseTuple(args, ":tostring"))
1172                 return NULL;
1173         return PyString_FromStringAndSize(self->ob_item,
1174                                     self->ob_size * self->ob_descr->itemsize);
1175 }
1176
1177 static char tostring_doc [] =
1178 "tostring() -> string\n\
1179 \n\
1180 Convert the array to an array of machine values and return the string\n\
1181 representation.";
1182
1183 PyMethodDef array_methods[] = {
1184         {"append",      (PyCFunction)array_append, METH_VARARGS, append_doc},
1185         {"buffer_info", (PyCFunction)array_buffer_info, METH_VARARGS, buffer_info_doc},
1186         {"byteswap",    (PyCFunction)array_byteswap, METH_VARARGS, byteswap_doc},
1187         {"count",       (PyCFunction)array_count, METH_VARARGS, count_doc},
1188         {"extend",      (PyCFunction)array_extend, METH_VARARGS, extend_doc},
1189         {"fromfile",    (PyCFunction)array_fromfile, METH_VARARGS, fromfile_doc},
1190         {"fromlist",    (PyCFunction)array_fromlist, METH_VARARGS, fromlist_doc},
1191         {"fromstring",  (PyCFunction)array_fromstring, METH_VARARGS, fromstring_doc},
1192         {"index",       (PyCFunction)array_index, METH_VARARGS, index_doc},
1193         {"insert",      (PyCFunction)array_insert, METH_VARARGS, insert_doc},
1194         {"pop",         (PyCFunction)array_pop, METH_VARARGS, pop_doc},
1195         {"read",        (PyCFunction)array_fromfile, METH_VARARGS, fromfile_doc},
1196         {"remove",      (PyCFunction)array_remove, METH_VARARGS, remove_doc},
1197         {"reverse",     (PyCFunction)array_reverse, METH_VARARGS, reverse_doc},
1198 /*      {"sort",        (PyCFunction)array_sort, METH_VARARGS, sort_doc},*/
1199         {"tofile",      (PyCFunction)array_tofile, METH_VARARGS, tofile_doc},
1200         {"tolist",      (PyCFunction)array_tolist, METH_VARARGS, tolist_doc},
1201         {"tostring",    (PyCFunction)array_tostring, METH_VARARGS, tostring_doc},
1202         {"write",       (PyCFunction)array_tofile, METH_VARARGS, tofile_doc},
1203         {NULL,          NULL}           /* sentinel */
1204 };
1205
1206 static PyObject *
1207 array_getattr(arrayobject *a, char *name)
1208 {
1209         if (strcmp(name, "typecode") == 0) {
1210                 char tc = a->ob_descr->typecode;
1211                 return PyString_FromStringAndSize(&tc, 1);
1212         }
1213         if (strcmp(name, "itemsize") == 0) {
1214                 return PyInt_FromLong((long)a->ob_descr->itemsize);
1215         }
1216         if (strcmp(name, "__members__") == 0) {
1217                 PyObject *list = PyList_New(2);
1218                 if (list) {
1219                         PyList_SetItem(list, 0,
1220                                        PyString_FromString("typecode"));
1221                         PyList_SetItem(list, 1,
1222                                        PyString_FromString("itemsize"));
1223                         if (PyErr_Occurred()) {
1224                                 Py_DECREF(list);
1225                                 list = NULL;
1226                         }
1227                 }
1228                 return list;
1229         }
1230         return Py_FindMethod(array_methods, (PyObject *)a, name);
1231 }
1232
1233 static int
1234 array_print(arrayobject *a, FILE *fp, int flags)
1235 {
1236         int ok = 0;
1237         int i, len;
1238         PyObject *t_empty = PyTuple_New(0);
1239         PyObject *v;
1240         len = a->ob_size;
1241         if (len == 0) {
1242                 fprintf(fp, "array('%c')", a->ob_descr->typecode);
1243                 return ok;
1244         }
1245         if (a->ob_descr->typecode == 'c') {
1246                 fprintf(fp, "array('c', ");
1247                 v = array_tostring(a, t_empty);
1248                 Py_DECREF(t_empty);;
1249                 ok = PyObject_Print(v, fp, 0);
1250                 Py_XDECREF(v);
1251                 fprintf(fp, ")");
1252                 return ok;
1253         }
1254         fprintf(fp, "array('%c', [", a->ob_descr->typecode);
1255         for (i = 0; i < len && ok == 0; i++) {
1256                 if (i > 0)
1257                         fprintf(fp, ", ");
1258                 v = (a->ob_descr->getitem)(a, i);
1259                 ok = PyObject_Print(v, fp, 0);
1260                 Py_XDECREF(v);
1261         }
1262         fprintf(fp, "])");
1263         return ok;
1264 }
1265
1266 static PyObject *
1267 array_repr(arrayobject *a)
1268 {
1269         char buf[256];
1270         PyObject *s, *t, *comma, *v;
1271         int i, len;
1272         len = a->ob_size;
1273         if (len == 0) {
1274                 sprintf(buf, "array('%c')", a->ob_descr->typecode);
1275                 return PyString_FromString(buf);
1276         }
1277         if (a->ob_descr->typecode == 'c') {
1278                 sprintf(buf, "array('c', ");
1279                 s = PyString_FromString(buf);
1280                 v = array_tostring(a, (PyObject *)NULL);
1281                 t = PyObject_Repr(v);
1282                 Py_XDECREF(v);
1283                 PyString_ConcatAndDel(&s, t);
1284                 PyString_ConcatAndDel(&s, PyString_FromString(")"));
1285                 return s;
1286         }
1287         sprintf(buf, "array('%c', [", a->ob_descr->typecode);
1288         s = PyString_FromString(buf);
1289         comma = PyString_FromString(", ");
1290         for (i = 0; i < len && !PyErr_Occurred(); i++) {
1291                 if (i > 0)
1292                         PyString_Concat(&s, comma);
1293                 v = (a->ob_descr->getitem)(a, i);
1294                 t = PyObject_Repr(v);
1295                 Py_XDECREF(v);
1296                 PyString_ConcatAndDel(&s, t);
1297         }
1298         Py_XDECREF(comma);
1299         PyString_ConcatAndDel(&s, PyString_FromString("])"));
1300         return s;
1301 }
1302
1303 static int
1304 array_buffer_getreadbuf(arrayobject *self, int index, const void **ptr)
1305 {
1306         if ( index != 0 ) {
1307                 PyErr_SetString(PyExc_SystemError,
1308                                 "Accessing non-existent array segment");
1309                 return -1;
1310         }
1311         *ptr = (void *)self->ob_item;
1312         return self->ob_size*self->ob_descr->itemsize;
1313 }
1314
1315 static int
1316 array_buffer_getwritebuf(arrayobject *self, int index, const void **ptr)
1317 {
1318         if ( index != 0 ) {
1319                 PyErr_SetString(PyExc_SystemError,
1320                                 "Accessing non-existent array segment");
1321                 return -1;
1322         }
1323         *ptr = (void *)self->ob_item;
1324         return self->ob_size*self->ob_descr->itemsize;
1325 }
1326
1327 static int
1328 array_buffer_getsegcount(arrayobject *self, int *lenp)
1329 {
1330         if ( lenp )
1331                 *lenp = self->ob_size*self->ob_descr->itemsize;
1332         return 1;
1333 }
1334
1335 static PySequenceMethods array_as_sequence = {
1336         (inquiry)array_length,                  /*sq_length*/
1337         (binaryfunc)array_concat,               /*sq_concat*/
1338         (intargfunc)array_repeat,               /*sq_repeat*/
1339         (intargfunc)array_item,                 /*sq_item*/
1340         (intintargfunc)array_slice,             /*sq_slice*/
1341         (intobjargproc)array_ass_item,          /*sq_ass_item*/
1342         (intintobjargproc)array_ass_slice,      /*sq_ass_slice*/
1343 };
1344
1345 static PyBufferProcs array_as_buffer = {
1346         (getreadbufferproc)array_buffer_getreadbuf,
1347         (getwritebufferproc)array_buffer_getwritebuf,
1348         (getsegcountproc)array_buffer_getsegcount,
1349 };
1350
1351
1352
1353
1354 static PyObject *
1355 a_array(PyObject *self, PyObject *args)
1356 {
1357         char c;
1358         PyObject *initial = NULL;
1359         struct arraydescr *descr;
1360         if (!PyArg_ParseTuple(args, "c:array", &c)) {
1361                 PyErr_Clear();
1362                 if (!PyArg_ParseTuple(args, "cO:array", &c, &initial))
1363                         return NULL;
1364                 if (!PyList_Check(initial) && !PyString_Check(initial)) {
1365                         PyErr_SetString(PyExc_TypeError,
1366                                  "array initializer must be list or string");
1367                         return NULL;
1368                 }
1369         }
1370         for (descr = descriptors; descr->typecode != '\0'; descr++) {
1371                 if (descr->typecode == c) {
1372                         PyObject *a;
1373                         int len;
1374                         if (initial == NULL || !PyList_Check(initial))
1375                                 len = 0;
1376                         else
1377                                 len = PyList_Size(initial);
1378                         a = newarrayobject(len, descr);
1379                         if (a == NULL)
1380                                 return NULL;
1381                         if (len > 0) {
1382                                 int i;
1383                                 for (i = 0; i < len; i++) {
1384                                         PyObject *v =
1385                                                  PyList_GetItem(initial, i);
1386                                         if (setarrayitem(a, i, v) != 0) {
1387                                                 Py_DECREF(a);
1388                                                 return NULL;
1389                                         }
1390                                 }
1391                         }
1392                         if (initial != NULL && PyString_Check(initial)) {
1393                                 PyObject *t_initial = Py_BuildValue("(O)", initial);
1394                                 PyObject *v =
1395                                         array_fromstring((arrayobject *)a, t_initial);
1396                                 Py_DECREF(t_initial);
1397                                 if (v == NULL) {
1398                                         Py_DECREF(a);
1399                                         return NULL;
1400                                 }
1401                                 Py_DECREF(v);
1402                         }
1403                         return a;
1404                 }
1405         }
1406         PyErr_SetString(PyExc_ValueError,
1407                 "bad typecode (must be c, b, B, h, H, i, I, l, L, f or d)");
1408         return NULL;
1409 }
1410
1411 static char a_array_doc [] =
1412 "array(typecode [, initializer]) -> array\n\
1413 \n\
1414 Return a new array whose items are restricted by typecode, and\n\
1415 initialized from the optional initializer value, which must be a list\n\
1416 or a string.";
1417
1418 static PyMethodDef a_methods[] = {
1419         {"array",       a_array, METH_VARARGS, a_array_doc},
1420         {NULL,          NULL}           /* sentinel */
1421 };
1422
1423 static char module_doc [] =
1424 "This module defines a new object type which can efficiently represent\n\
1425 an array of basic values: characters, integers, floating point\n\
1426 numbers.  Arrays are sequence types and behave very much like lists,\n\
1427 except that the type of objects stored in them is constrained.  The\n\
1428 type is specified at object creation time by using a type code, which\n\
1429 is a single character.  The following type codes are defined:\n\
1430 \n\
1431     Type code   C Type             Minimum size in bytes \n\
1432     'c'         character          1 \n\
1433     'b'         signed integer     1 \n\
1434     'B'         unsigned integer   1 \n\
1435     'h'         signed integer     2 \n\
1436     'H'         unsigned integer   2 \n\
1437     'i'         signed integer     2 \n\
1438     'I'         unsigned integer   2 \n\
1439     'l'         signed integer     4 \n\
1440     'L'         unsigned integer   4 \n\
1441     'f'         floating point     4 \n\
1442     'd'         floating point     8 \n\
1443 \n\
1444 Functions:\n\
1445 \n\
1446 array(typecode [, initializer]) -- create a new array\n\
1447 \n\
1448 Special Objects:\n\
1449 \n\
1450 ArrayType -- type object for array objects\n\
1451 ";
1452
1453 static char arraytype_doc [] =
1454 "An array represents basic values and behave very much like lists, except\n\
1455 the type of objects stored in them is constrained.\n\
1456 \n\
1457 Methods:\n\
1458 \n\
1459 append() -- append a new item to the end of the array\n\
1460 buffer_info() -- return information giving the current memory info\n\
1461 byteswap() -- byteswap all the items of the array\n\
1462 count() -- return number of occurences of an object\n\
1463 extend() -- extend array by appending array elements\n\
1464 fromfile() -- read items from a file object\n\
1465 fromlist() -- append items from the list\n\
1466 fromstring() -- append items from the string\n\
1467 index() -- return index of first occurence of an object\n\
1468 insert() -- insert a new item into the array at a provided position\n\
1469 pop() -- remove and return item (default last)\n\
1470 read() -- DEPRECATED, use fromfile()\n\
1471 remove() -- remove first occurence of an object\n\
1472 reverse() -- reverse the order of the items in the array\n\
1473 tofile() -- write all items to a file object\n\
1474 tolist() -- return the array converted to an ordinary list\n\
1475 tostring() -- return the array converted to a string\n\
1476 write() -- DEPRECATED, use tofile()\n\
1477 \n\
1478 Variables:\n\
1479 \n\
1480 typecode -- the typecode character used to create the array\n\
1481 itemsize -- the length in bytes of one array item\n\
1482 ";
1483
1484 statichere PyTypeObject Arraytype = {
1485         PyObject_HEAD_INIT(NULL)
1486         0,
1487         "array",
1488         sizeof(arrayobject),
1489         0,
1490         (destructor)array_dealloc,      /*tp_dealloc*/
1491         (printfunc)array_print,         /*tp_print*/
1492         (getattrfunc)array_getattr,     /*tp_getattr*/
1493         0,                              /*tp_setattr*/
1494         (cmpfunc)array_compare,         /*tp_compare*/
1495         (reprfunc)array_repr,           /*tp_repr*/
1496         0,                              /*tp_as_number*/
1497         &array_as_sequence,             /*tp_as_sequence*/
1498         0,                              /*tp_as_mapping*/
1499         0,                              /*tp_hash*/
1500         0,                              /*tp_call*/
1501         0,                              /*tp_str*/
1502         0,                              /*tp_getattro*/
1503         0,                              /*tp_setattro*/
1504         &array_as_buffer,               /*tp_as_buffer*/
1505         0,                              /*tp_xxx4*/
1506         arraytype_doc,                  /*tp_doc*/
1507 };
1508
1509 DL_EXPORT(void)
1510 initarray(void)
1511 {
1512         PyObject *m, *d;
1513
1514         Arraytype.ob_type = &PyType_Type;
1515         m = Py_InitModule3("array", a_methods, module_doc);
1516         d = PyModule_GetDict(m);
1517         PyDict_SetItemString(d, "ArrayType", (PyObject *)&Arraytype);
1518         /* No need to check the error here, the caller will do that */
1519 }