Mercurial > cpython-lru_cache-weakref

comparison Modules/arraymodule.c @ 1393:7d6a2d950f13 legacy-trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
* nismodule.c: database keys and values can contain null bytes. be more careful about these. * arraymodule.c: added 8 byte swap; added 'i' format character; added reverse() method; rename read/write to fromfile/tofile. * config.c: Set version to 0.9.9++. * rotormodule.c (r_rand): declare k1..k5 as unsigned longs so the shifts will have a well-defined effect independent of word size. * bltinmodule.c: renamed bagof() to filter().
author Guido van Rossum <guido@python.org>
date Wed, 03 Nov 1993 15:01:26 +0000
parents 7c3245c18677
children 1ce2c0f565ef
comparison
equal deleted inserted replaced
1392:0ffff40d13ff 1393:7d6a2d950f13
142 ((short *)ap->ob_item)[i] = x; 142 ((short *)ap->ob_item)[i] = x;
143 return 0; 143 return 0;
144 } 144 }
145 145
146 static object * 146 static object *
147 i_getitem(ap, i)
148 arrayobject *ap;
149 int i;
150 {
151 return newintobject((long) ((int *)ap->ob_item)[i]);
152 }
153
154 static int
155 i_setitem(ap, i, v)
156 arrayobject *ap;
157 int i;
158 object *v;
159 {
160 int x;
161 if (!getargs(v, "i;array item must be integer", &x))
162 return -1;
163 if (i >= 0)
164 ((int *)ap->ob_item)[i] = x;
165 return 0;
166 }
167
168 static object *
147 l_getitem(ap, i) 169 l_getitem(ap, i)
148 arrayobject *ap; 170 arrayobject *ap;
149 int i; 171 int i;
150 { 172 {
151 return newintobject(((long *)ap->ob_item)[i]); 173 return newintobject(((long *)ap->ob_item)[i]);
212 /* Description of types */ 234 /* Description of types */
213 static struct arraydescr descriptors[] = { 235 static struct arraydescr descriptors[] = {
214 {'c', sizeof(char), c_getitem, c_setitem}, 236 {'c', sizeof(char), c_getitem, c_setitem},
215 {'b', sizeof(char), b_getitem, b_setitem}, 237 {'b', sizeof(char), b_getitem, b_setitem},
216 {'h', sizeof(short), h_getitem, h_setitem}, 238 {'h', sizeof(short), h_getitem, h_setitem},
239 {'i', sizeof(int), i_getitem, i_setitem},
217 {'l', sizeof(long), l_getitem, l_setitem}, 240 {'l', sizeof(long), l_getitem, l_setitem},
218 {'f', sizeof(float), f_getitem, f_setitem}, 241 {'f', sizeof(float), f_getitem, f_setitem},
219 {'d', sizeof(double), d_getitem, d_setitem}, 242 {'d', sizeof(double), d_getitem, d_setitem},
220 {'\0', 0, 0, 0} /* Sentinel */ 243 {'\0', 0, 0, 0} /* Sentinel */
221 }; 244 };
245 /* If we ever allow items larger than double, we must change reverse()! */
222 246
223 247
224 object * 248 object *
225 newarrayobject(size, descr) 249 newarrayobject(size, descr)
226 int size; 250 int size;
237 nbytes = size * descr->itemsize; 261 nbytes = size * descr->itemsize;
238 /* Check for overflow */ 262 /* Check for overflow */
239 if (nbytes / descr->itemsize != size) { 263 if (nbytes / descr->itemsize != size) {
240 return err_nomem(); 264 return err_nomem();
241 } 265 }
242 op = (arrayobject *) malloc(sizeof(arrayobject)); 266 op = NEW(arrayobject, 1);
243 if (op == NULL) { 267 if (op == NULL) {
244 return err_nomem(); 268 return err_nomem();
245 } 269 }
246 if (size <= 0) { 270 if (size <= 0) {
247 op->ob_item = NULL; 271 op->ob_item = NULL;
248 } 272 }
249 else { 273 else {
250 op->ob_item = malloc(nbytes); 274 op->ob_item = NEW(char, nbytes);
251 if (op->ob_item == NULL) { 275 if (op->ob_item == NULL) {
252 free((ANY *)op); 276 DEL(op);
253 return err_nomem(); 277 return err_nomem();
254 } 278 }
255 } 279 }
256 op->ob_type = &Arraytype; 280 op->ob_type = &Arraytype;
257 op->ob_size = size; 281 op->ob_size = size;
353 array_dealloc(op) 377 array_dealloc(op)
354 arrayobject *op; 378 arrayobject *op;
355 { 379 {
356 int i; 380 int i;
357 if (op->ob_item != NULL) 381 if (op->ob_item != NULL)
358 free((ANY *)op->ob_item); 382 DEL(op->ob_item);
359 free((ANY *)op); 383 DEL(op);
360 } 384 }
361 385
362 static int 386 static int
363 array_compare(v, w) 387 array_compare(v, w)
364 arrayobject *v, *w; 388 arrayobject *v, *w;
642 p[1] = p[2]; 666 p[1] = p[2];
643 p[2] = p1; 667 p[2] = p1;
644 p[3] = p0; 668 p[3] = p0;
645 } 669 }
646 break; 670 break;
671 case 8:
672 for (p = self->ob_item, i = self->ob_size; --i >= 0; p += 8) {
673 char p0 = p[0];
674 char p1 = p[1];
675 char p2 = p[2];
676 char p3 = p[3];
677 p[0] = p[7];
678 p[1] = p[6];
679 p[2] = p[5];
680 p[3] = p[4];
681 p[4] = p3;
682 p[5] = p2;
683 p[6] = p1;
684 p[7] = p0;
685 }
686 break;
647 default: 687 default:
648 err_setstr(RuntimeError, 688 err_setstr(RuntimeError,
649 "don't know how to byteswap this array type"); 689 "don't know how to byteswap this array type");
650 return NULL; 690 return NULL;
651 } 691 }
652 INCREF(None); 692 INCREF(None);
653 return None; 693 return None;
654 } 694 }
655 695
656 #if 0
657 static object * 696 static object *
658 array_reverse(self, args) 697 array_reverse(self, args)
659 arrayobject *self; 698 arrayobject *self;
660 object *args; 699 object *args;
661 { 700 {
662 register object **p, **q; 701 register int itemsize = self->ob_descr->itemsize;
663 register object *tmp; 702 register char *p, *q;
664 703 char tmp[sizeof(double)]; /* Assume that's the max item size */
704
665 if (args != NULL) { 705 if (args != NULL) {
666 err_badarg(); 706 err_badarg();
667 return NULL; 707 return NULL;
668 } 708 }
669 709
670 if (self->ob_size > 1) { 710 if (self->ob_size > 1) {
671 for (p = self->ob_item, q = self->ob_item + self->ob_size - 1; 711 for (p = self->ob_item,
672 p < q; p++, q--) { 712 q = self->ob_item + (self->ob_size - 1)*itemsize;
673 tmp = *p; 713 p < q;
674 *p = *q; 714 p += itemsize, q -= itemsize) {
675 *q = tmp; 715 memmove(tmp, p, itemsize);
716 memmove(p, q, itemsize);
717 memmove(q, tmp, itemsize);
676 } 718 }
677 } 719 }
678 720
679 INCREF(None); 721 INCREF(None);
680 return None; 722 return None;
681 } 723 }
682 #endif 724
725 /* The following routines were adapted from listobject.c but not converted.
726 To make them work you will have to work! */
683 727
684 #if 0 728 #if 0
685 static object * 729 static object *
686 array_index(self, args) 730 array_index(self, args)
687 arrayobject *self; 731 arrayobject *self;
748 return NULL; 792 return NULL;
749 } 793 }
750 #endif 794 #endif
751 795
752 static object * 796 static object *
753 array_read(self, args) 797 array_fromfile(self, args)
754 arrayobject *self; 798 arrayobject *self;
755 object *args; 799 object *args;
756 { 800 {
757 object *f; 801 object *f;
758 int n; 802 int n;
788 INCREF(None); 832 INCREF(None);
789 return None; 833 return None;
790 } 834 }
791 835
792 static object * 836 static object *
793 array_write(self, args) 837 array_tofile(self, args)
794 arrayobject *self; 838 arrayobject *self;
795 object *args; 839 object *args;
796 { 840 {
797 object *f; 841 object *f;
798 FILE *fp; 842 FILE *fp;
919 963
920 static struct methodlist array_methods[] = { 964 static struct methodlist array_methods[] = {
921 {"append", array_append}, 965 {"append", array_append},
922 {"byteswap", array_byteswap}, 966 {"byteswap", array_byteswap},
923 /* {"count", array_count},*/ 967 /* {"count", array_count},*/
968 {"fromfile", array_fromfile},
969 {"fromlist", array_fromlist},
970 {"fromstring", array_fromstring},
924 /* {"index", array_index},*/ 971 /* {"index", array_index},*/
925 {"insert", array_insert}, 972 {"insert", array_insert},
973 {"read", array_fromfile},
974 /* {"remove", array_remove},*/
975 {"reverse", array_reverse},
926 /* {"sort", array_sort},*/ 976 /* {"sort", array_sort},*/
927 /* {"remove", array_remove},*/ 977 {"tofile", array_tofile},
928 /* {"reverse", array_reverse},*/
929 {"read", array_read},
930 {"write", array_write},
931 {"fromlist", array_fromlist},
932 {"tolist", array_tolist}, 978 {"tolist", array_tolist},
933 {"fromstring", array_fromstring},
934 {"tostring", array_tostring}, 979 {"tostring", array_tostring},
980 {"write", array_tofile},
935 {NULL, NULL} /* sentinel */ 981 {NULL, NULL} /* sentinel */
936 }; 982 };
937 983
938 static object * 984 static object *
939 array_getattr(a, name) 985 array_getattr(a, name)