blob: b51e3d83dfa00178807d298caae9d8c2c6071c62 [file] [log] [blame]
Guido van Rossumf70e43a1991-02-19 12:39:46 +00001/***********************************************************
Guido van Rossum34679b71993-01-26 13:33:44 +00002Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
3Amsterdam, The Netherlands.
Guido van Rossumf70e43a1991-02-19 12:39:46 +00004
5 All Rights Reserved
6
7Permission to use, copy, modify, and distribute this software and its
8documentation for any purpose and without fee is hereby granted,
9provided that the above copyright notice appear in all copies and that
10both that copyright notice and this permission notice appear in
11supporting documentation, and that the names of Stichting Mathematisch
12Centrum or CWI not be used in advertising or publicity pertaining to
13distribution of the software without specific, written prior permission.
14
15STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
16THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
17FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
18FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
19WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
20ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
21OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22
23******************************************************************/
24
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000025/* List object implementation */
26
Guido van Rossum3f5da241990-12-20 15:06:42 +000027#include "allobjects.h"
Guido van Rossumfa3da8a1992-01-27 16:53:23 +000028#include "modsupport.h"
Guido van Rossumff4949e1992-08-05 19:58:53 +000029#include "ceval.h"
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000030
31object *
32newlistobject(size)
33 int size;
34{
35 int i;
36 listobject *op;
Guido van Rossum1e28e5e1992-08-19 16:46:30 +000037 MALLARG nbytes;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000038 if (size < 0) {
Guido van Rossum2a9096b1990-10-21 22:15:08 +000039 err_badcall();
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000040 return NULL;
41 }
Guido van Rossum1e28e5e1992-08-19 16:46:30 +000042 nbytes = size * sizeof(object *);
43 /* Check for overflow */
44 if (nbytes / sizeof(object *) != size) {
45 return err_nomem();
46 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000047 op = (listobject *) malloc(sizeof(listobject));
48 if (op == NULL) {
Guido van Rossum2a9096b1990-10-21 22:15:08 +000049 return err_nomem();
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000050 }
51 if (size <= 0) {
52 op->ob_item = NULL;
53 }
54 else {
Guido van Rossum1e28e5e1992-08-19 16:46:30 +000055 op->ob_item = (object **) malloc(nbytes);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000056 if (op->ob_item == NULL) {
57 free((ANY *)op);
Guido van Rossum2a9096b1990-10-21 22:15:08 +000058 return err_nomem();
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000059 }
60 }
61 NEWREF(op);
62 op->ob_type = &Listtype;
63 op->ob_size = size;
64 for (i = 0; i < size; i++)
65 op->ob_item[i] = NULL;
66 return (object *) op;
67}
68
69int
70getlistsize(op)
71 object *op;
72{
73 if (!is_listobject(op)) {
Guido van Rossum2a9096b1990-10-21 22:15:08 +000074 err_badcall();
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000075 return -1;
76 }
77 else
78 return ((listobject *)op) -> ob_size;
79}
80
81object *
82getlistitem(op, i)
83 object *op;
84 int i;
85{
86 if (!is_listobject(op)) {
Guido van Rossum2a9096b1990-10-21 22:15:08 +000087 err_badcall();
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000088 return NULL;
89 }
90 if (i < 0 || i >= ((listobject *)op) -> ob_size) {
Guido van Rossum2a9096b1990-10-21 22:15:08 +000091 err_setstr(IndexError, "list index out of range");
Guido van Rossum85a5fbb1990-10-14 12:07:46 +000092 return NULL;
93 }
94 return ((listobject *)op) -> ob_item[i];
95}
96
97int
98setlistitem(op, i, newitem)
99 register object *op;
100 register int i;
101 register object *newitem;
102{
103 register object *olditem;
104 if (!is_listobject(op)) {
Guido van Rossume6f7d181991-10-20 20:20:40 +0000105 XDECREF(newitem);
Guido van Rossum2a9096b1990-10-21 22:15:08 +0000106 err_badcall();
107 return -1;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000108 }
109 if (i < 0 || i >= ((listobject *)op) -> ob_size) {
Guido van Rossume6f7d181991-10-20 20:20:40 +0000110 XDECREF(newitem);
Guido van Rossum2a9096b1990-10-21 22:15:08 +0000111 err_setstr(IndexError, "list assignment index out of range");
112 return -1;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000113 }
114 olditem = ((listobject *)op) -> ob_item[i];
115 ((listobject *)op) -> ob_item[i] = newitem;
Guido van Rossume6f7d181991-10-20 20:20:40 +0000116 XDECREF(olditem);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000117 return 0;
118}
119
120static int
121ins1(self, where, v)
122 listobject *self;
123 int where;
124 object *v;
125{
126 int i;
127 object **items;
Guido van Rossum2a9096b1990-10-21 22:15:08 +0000128 if (v == NULL) {
129 err_badcall();
130 return -1;
131 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000132 items = self->ob_item;
133 RESIZE(items, object *, self->ob_size+1);
Guido van Rossum2a9096b1990-10-21 22:15:08 +0000134 if (items == NULL) {
135 err_nomem();
136 return -1;
137 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000138 if (where < 0)
139 where = 0;
140 if (where > self->ob_size)
141 where = self->ob_size;
142 for (i = self->ob_size; --i >= where; )
143 items[i+1] = items[i];
144 INCREF(v);
145 items[where] = v;
146 self->ob_item = items;
147 self->ob_size++;
148 return 0;
149}
150
151int
152inslistitem(op, where, newitem)
153 object *op;
154 int where;
155 object *newitem;
156{
Guido van Rossum2a9096b1990-10-21 22:15:08 +0000157 if (!is_listobject(op)) {
158 err_badcall();
159 return -1;
160 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000161 return ins1((listobject *)op, where, newitem);
162}
163
164int
165addlistitem(op, newitem)
166 object *op;
167 object *newitem;
168{
Guido van Rossum2a9096b1990-10-21 22:15:08 +0000169 if (!is_listobject(op)) {
170 err_badcall();
171 return -1;
172 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000173 return ins1((listobject *)op,
174 (int) ((listobject *)op)->ob_size, newitem);
175}
176
177/* Methods */
178
179static void
180list_dealloc(op)
181 listobject *op;
182{
183 int i;
184 for (i = 0; i < op->ob_size; i++) {
Guido van Rossume6f7d181991-10-20 20:20:40 +0000185 XDECREF(op->ob_item[i]);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000186 }
187 if (op->ob_item != NULL)
188 free((ANY *)op->ob_item);
189 free((ANY *)op);
190}
191
Guido van Rossum90933611991-06-07 16:10:43 +0000192static int
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000193list_print(op, fp, flags)
194 listobject *op;
195 FILE *fp;
196 int flags;
197{
198 int i;
199 fprintf(fp, "[");
Guido van Rossum90933611991-06-07 16:10:43 +0000200 for (i = 0; i < op->ob_size; i++) {
201 if (i > 0)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000202 fprintf(fp, ", ");
Guido van Rossum90933611991-06-07 16:10:43 +0000203 if (printobject(op->ob_item[i], fp, flags) != 0)
204 return -1;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000205 }
206 fprintf(fp, "]");
Guido van Rossum90933611991-06-07 16:10:43 +0000207 return 0;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000208}
209
Guido van Rossum234f9421993-06-17 12:35:49 +0000210static object *
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000211list_repr(v)
212 listobject *v;
213{
214 object *s, *t, *comma;
215 int i;
216 s = newstringobject("[");
217 comma = newstringobject(", ");
218 for (i = 0; i < v->ob_size && s != NULL; i++) {
219 if (i > 0)
220 joinstring(&s, comma);
221 t = reprobject(v->ob_item[i]);
222 joinstring(&s, t);
223 DECREF(t);
224 }
225 DECREF(comma);
226 t = newstringobject("]");
227 joinstring(&s, t);
228 DECREF(t);
229 return s;
230}
231
232static int
233list_compare(v, w)
234 listobject *v, *w;
235{
236 int len = (v->ob_size < w->ob_size) ? v->ob_size : w->ob_size;
237 int i;
238 for (i = 0; i < len; i++) {
239 int cmp = cmpobject(v->ob_item[i], w->ob_item[i]);
240 if (cmp != 0)
241 return cmp;
242 }
243 return v->ob_size - w->ob_size;
244}
245
246static int
247list_length(a)
248 listobject *a;
249{
250 return a->ob_size;
251}
252
253static object *
254list_item(a, i)
255 listobject *a;
256 int i;
257{
258 if (i < 0 || i >= a->ob_size) {
Guido van Rossum2a9096b1990-10-21 22:15:08 +0000259 err_setstr(IndexError, "list index out of range");
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000260 return NULL;
261 }
262 INCREF(a->ob_item[i]);
263 return a->ob_item[i];
264}
265
266static object *
267list_slice(a, ilow, ihigh)
268 listobject *a;
269 int ilow, ihigh;
270{
271 listobject *np;
272 int i;
273 if (ilow < 0)
274 ilow = 0;
275 else if (ilow > a->ob_size)
276 ilow = a->ob_size;
277 if (ihigh < 0)
278 ihigh = 0;
279 if (ihigh < ilow)
280 ihigh = ilow;
281 else if (ihigh > a->ob_size)
282 ihigh = a->ob_size;
283 np = (listobject *) newlistobject(ihigh - ilow);
284 if (np == NULL)
285 return NULL;
286 for (i = ilow; i < ihigh; i++) {
287 object *v = a->ob_item[i];
288 INCREF(v);
289 np->ob_item[i - ilow] = v;
290 }
291 return (object *)np;
292}
293
Guido van Rossum234f9421993-06-17 12:35:49 +0000294object *
295getlistslice(a, ilow, ihigh)
296 object *a;
297 int ilow, ihigh;
298{
299 if (!is_listobject(a)) {
300 err_badcall();
301 return NULL;
302 }
303 return list_slice((listobject *)a, ilow, ihigh);
304}
305
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000306static object *
307list_concat(a, bb)
308 listobject *a;
309 object *bb;
310{
311 int size;
312 int i;
313 listobject *np;
314 if (!is_listobject(bb)) {
Guido van Rossum2a9096b1990-10-21 22:15:08 +0000315 err_badarg();
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000316 return NULL;
317 }
318#define b ((listobject *)bb)
319 size = a->ob_size + b->ob_size;
320 np = (listobject *) newlistobject(size);
321 if (np == NULL) {
Guido van Rossum90933611991-06-07 16:10:43 +0000322 return NULL;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000323 }
324 for (i = 0; i < a->ob_size; i++) {
325 object *v = a->ob_item[i];
326 INCREF(v);
327 np->ob_item[i] = v;
328 }
329 for (i = 0; i < b->ob_size; i++) {
330 object *v = b->ob_item[i];
331 INCREF(v);
332 np->ob_item[i + a->ob_size] = v;
333 }
334 return (object *)np;
335#undef b
336}
337
Guido van Rossumed98d481991-03-06 13:07:53 +0000338static object *
339list_repeat(a, n)
340 listobject *a;
341 int n;
342{
343 int i, j;
344 int size;
345 listobject *np;
346 object **p;
347 if (n < 0)
348 n = 0;
349 size = a->ob_size * n;
350 np = (listobject *) newlistobject(size);
351 if (np == NULL)
352 return NULL;
353 p = np->ob_item;
354 for (i = 0; i < n; i++) {
355 for (j = 0; j < a->ob_size; j++) {
356 *p = a->ob_item[j];
357 INCREF(*p);
358 p++;
359 }
360 }
361 return (object *) np;
362}
363
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000364static int
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000365list_ass_slice(a, ilow, ihigh, v)
366 listobject *a;
367 int ilow, ihigh;
368 object *v;
369{
370 object **item;
371 int n; /* Size of replacement list */
372 int d; /* Change in size */
373 int k; /* Loop index */
374#define b ((listobject *)v)
375 if (v == NULL)
376 n = 0;
Guido van Rossum32dffaa1991-12-24 13:27:34 +0000377 else if (is_listobject(v)) {
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000378 n = b->ob_size;
Guido van Rossum32dffaa1991-12-24 13:27:34 +0000379 if (a == b) {
380 /* Special case "a[i:j] = a" -- copy b first */
381 int ret;
382 v = list_slice(b, 0, n);
383 ret = list_ass_slice(a, ilow, ihigh, v);
384 DECREF(v);
385 return ret;
386 }
387 }
Guido van Rossum2a9096b1990-10-21 22:15:08 +0000388 else {
389 err_badarg();
390 return -1;
391 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000392 if (ilow < 0)
393 ilow = 0;
394 else if (ilow > a->ob_size)
395 ilow = a->ob_size;
396 if (ihigh < 0)
397 ihigh = 0;
398 if (ihigh < ilow)
399 ihigh = ilow;
400 else if (ihigh > a->ob_size)
401 ihigh = a->ob_size;
402 item = a->ob_item;
403 d = n - (ihigh-ilow);
404 if (d <= 0) { /* Delete -d items; DECREF ihigh-ilow items */
405 for (k = ilow; k < ihigh; k++)
406 DECREF(item[k]);
407 if (d < 0) {
408 for (/*k = ihigh*/; k < a->ob_size; k++)
409 item[k+d] = item[k];
410 a->ob_size += d;
411 RESIZE(item, object *, a->ob_size); /* Can't fail */
412 a->ob_item = item;
413 }
414 }
415 else { /* Insert d items; DECREF ihigh-ilow items */
416 RESIZE(item, object *, a->ob_size + d);
Guido van Rossum2a9096b1990-10-21 22:15:08 +0000417 if (item == NULL) {
418 err_nomem();
419 return -1;
420 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000421 for (k = a->ob_size; --k >= ihigh; )
422 item[k+d] = item[k];
423 for (/*k = ihigh-1*/; k >= ilow; --k)
424 DECREF(item[k]);
425 a->ob_item = item;
426 a->ob_size += d;
427 }
428 for (k = 0; k < n; k++, ilow++) {
429 object *w = b->ob_item[k];
430 INCREF(w);
431 item[ilow] = w;
432 }
433 return 0;
434#undef b
435}
436
Guido van Rossum234f9421993-06-17 12:35:49 +0000437int
438setlistslice(a, ilow, ihigh, v)
439 object *a;
440 int ilow, ihigh;
441 object *v;
442{
443 if (!is_listobject(a)) {
444 err_badcall();
445 return NULL;
446 }
447 return list_ass_slice((listobject *)a, ilow, ihigh, v);
448}
449
Guido van Rossum4a450d01991-04-03 19:05:18 +0000450static int
451list_ass_item(a, i, v)
452 listobject *a;
453 int i;
454 object *v;
455{
456 if (i < 0 || i >= a->ob_size) {
457 err_setstr(IndexError, "list assignment index out of range");
458 return -1;
459 }
460 if (v == NULL)
461 return list_ass_slice(a, i, i+1, v);
462 INCREF(v);
463 DECREF(a->ob_item[i]);
464 a->ob_item[i] = v;
465 return 0;
466}
467
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000468static object *
469ins(self, where, v)
470 listobject *self;
471 int where;
472 object *v;
473{
474 if (ins1(self, where, v) != 0)
475 return NULL;
476 INCREF(None);
477 return None;
478}
479
480static object *
481listinsert(self, args)
482 listobject *self;
483 object *args;
484{
485 int i;
Guido van Rossumbf80e541993-02-08 15:49:17 +0000486 object *v;
487 if (!getargs(args, "(iO)", &i, &v))
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000488 return NULL;
Guido van Rossumbf80e541993-02-08 15:49:17 +0000489 return ins(self, i, v);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000490}
491
492static object *
493listappend(self, args)
494 listobject *self;
495 object *args;
496{
Guido van Rossumbf80e541993-02-08 15:49:17 +0000497 object *v;
498 if (!getargs(args, "O", &v))
499 return NULL;
500 return ins(self, (int) self->ob_size, v);
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000501}
502
Guido van Rossume10a19e1992-08-03 19:05:37 +0000503static object *cmpfunc;
504
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000505static int
506cmp(v, w)
Guido van Rossuma2b7f401993-01-04 09:09:59 +0000507#ifdef __STDC__
508 void *v, *w;
509#else
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000510 char *v, *w;
Guido van Rossuma2b7f401993-01-04 09:09:59 +0000511#endif
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000512{
Guido van Rossume10a19e1992-08-03 19:05:37 +0000513 object *t, *res;
514 long i;
515
516 if (err_occurred())
517 return 0;
518
519 if (cmpfunc == NULL)
520 return cmpobject(* (object **) v, * (object **) w);
521
522 /* Call the user-supplied comparison function */
Guido van Rossumbf80e541993-02-08 15:49:17 +0000523 t = mkvalue("OO", v, w);
Guido van Rossume10a19e1992-08-03 19:05:37 +0000524 if (t == NULL)
525 return 0;
Guido van Rossume10a19e1992-08-03 19:05:37 +0000526 res = call_object(cmpfunc, t);
527 DECREF(t);
528 if (res == NULL)
529 return 0;
530 if (!is_intobject(res)) {
531 err_setstr(TypeError, "comparison function should return int");
532 i = 0;
533 }
534 else {
535 i = getintvalue(res);
536 if (i < 0)
537 i = -1;
538 else if (i > 0)
539 i = 1;
540 }
541 DECREF(res);
542 return (int) i;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000543}
544
545static object *
546listsort(self, args)
547 listobject *self;
548 object *args;
549{
Guido van Rossume10a19e1992-08-03 19:05:37 +0000550 object *save_cmpfunc;
551 if (self->ob_size <= 1) {
552 INCREF(None);
553 return None;
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000554 }
Guido van Rossume10a19e1992-08-03 19:05:37 +0000555 save_cmpfunc = cmpfunc;
556 cmpfunc = args;
557 if (cmpfunc != NULL) {
558 /* Test the comparison function for obvious errors */
559 (void) cmp(&self->ob_item[0], &self->ob_item[1]);
560 if (err_occurred()) {
561 cmpfunc = save_cmpfunc;
562 return NULL;
563 }
564 }
565 qsort((char *)self->ob_item,
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000566 (int) self->ob_size, sizeof(object *), cmp);
Guido van Rossume10a19e1992-08-03 19:05:37 +0000567 cmpfunc = save_cmpfunc;
Guido van Rossum2a9096b1990-10-21 22:15:08 +0000568 if (err_occurred())
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000569 return NULL;
570 INCREF(None);
571 return None;
572}
573
Guido van Rossumed98d481991-03-06 13:07:53 +0000574static object *
575listreverse(self, args)
576 listobject *self;
577 object *args;
578{
579 register object **p, **q;
580 register object *tmp;
581
582 if (args != NULL) {
583 err_badarg();
584 return NULL;
585 }
586
587 if (self->ob_size > 1) {
588 for (p = self->ob_item, q = self->ob_item + self->ob_size - 1;
589 p < q; p++, q--) {
590 tmp = *p;
591 *p = *q;
592 *q = tmp;
593 }
594 }
595
596 INCREF(None);
597 return None;
598}
599
Guido van Rossum84c76f51990-10-30 13:32:20 +0000600int
601sortlist(v)
602 object *v;
603{
604 if (v == NULL || !is_listobject(v)) {
605 err_badcall();
606 return -1;
607 }
608 v = listsort((listobject *)v, (object *)NULL);
609 if (v == NULL)
610 return -1;
611 DECREF(v);
612 return 0;
613}
614
Guido van Rossumed98d481991-03-06 13:07:53 +0000615static object *
616listindex(self, args)
617 listobject *self;
618 object *args;
619{
620 int i;
621
622 if (args == NULL) {
623 err_badarg();
624 return NULL;
625 }
626 for (i = 0; i < self->ob_size; i++) {
627 if (cmpobject(self->ob_item[i], args) == 0)
Guido van Rossum7066dd71992-09-17 17:54:56 +0000628 return newintobject((long)i);
Guido van Rossumed98d481991-03-06 13:07:53 +0000629 }
Guido van Rossum87e7ea71991-12-10 14:00:03 +0000630 err_setstr(ValueError, "list.index(x): x not in list");
Guido van Rossumed98d481991-03-06 13:07:53 +0000631 return NULL;
632}
633
634static object *
Guido van Rossume6f7d181991-10-20 20:20:40 +0000635listcount(self, args)
636 listobject *self;
637 object *args;
638{
639 int count = 0;
640 int i;
641
642 if (args == NULL) {
643 err_badarg();
644 return NULL;
645 }
646 for (i = 0; i < self->ob_size; i++) {
647 if (cmpobject(self->ob_item[i], args) == 0)
648 count++;
649 }
650 return newintobject((long)count);
651}
652
653static object *
Guido van Rossumed98d481991-03-06 13:07:53 +0000654listremove(self, args)
655 listobject *self;
656 object *args;
657{
658 int i;
659
660 if (args == NULL) {
661 err_badarg();
662 return NULL;
663 }
664 for (i = 0; i < self->ob_size; i++) {
665 if (cmpobject(self->ob_item[i], args) == 0) {
666 if (list_ass_slice(self, i, i+1, (object *)NULL) != 0)
667 return NULL;
668 INCREF(None);
669 return None;
670 }
671
672 }
Guido van Rossum87e7ea71991-12-10 14:00:03 +0000673 err_setstr(ValueError, "list.remove(x): x not in list");
Guido van Rossumed98d481991-03-06 13:07:53 +0000674 return NULL;
675}
676
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000677static struct methodlist list_methods[] = {
678 {"append", listappend},
Guido van Rossume6f7d181991-10-20 20:20:40 +0000679 {"count", listcount},
Guido van Rossumed98d481991-03-06 13:07:53 +0000680 {"index", listindex},
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000681 {"insert", listinsert},
682 {"sort", listsort},
Guido van Rossumed98d481991-03-06 13:07:53 +0000683 {"remove", listremove},
684 {"reverse", listreverse},
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000685 {NULL, NULL} /* sentinel */
686};
687
688static object *
689list_getattr(f, name)
690 listobject *f;
691 char *name;
692{
693 return findmethod(list_methods, (object *)f, name);
694}
695
696static sequence_methods list_as_sequence = {
697 list_length, /*sq_length*/
698 list_concat, /*sq_concat*/
Guido van Rossumed98d481991-03-06 13:07:53 +0000699 list_repeat, /*sq_repeat*/
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000700 list_item, /*sq_item*/
701 list_slice, /*sq_slice*/
702 list_ass_item, /*sq_ass_item*/
703 list_ass_slice, /*sq_ass_slice*/
704};
705
706typeobject Listtype = {
707 OB_HEAD_INIT(&Typetype)
708 0,
709 "list",
710 sizeof(listobject),
711 0,
712 list_dealloc, /*tp_dealloc*/
713 list_print, /*tp_print*/
714 list_getattr, /*tp_getattr*/
715 0, /*tp_setattr*/
716 list_compare, /*tp_compare*/
717 list_repr, /*tp_repr*/
718 0, /*tp_as_number*/
719 &list_as_sequence, /*tp_as_sequence*/
720 0, /*tp_as_mapping*/
721};