Mercurial > lcfOS

comparison cos/python/Objects/object.c @ 27:7f74363f4c82

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added some files for the python port
author windel
date Tue, 27 Dec 2011 18:59:02 +0100
parents
children
comparison
equal deleted inserted replaced
26:dcce92b1efbc 27:7f74363f4c82
1
2 /* Generic object operations; and implementation of None */
3
4 #include "Python.h"
5 #include "frameobject.h"
6
7 /* Object allocation routines used by NEWOBJ and NEWVAROBJ macros.
8 These are used by the individual routines for object creation.
9 Do not call them otherwise, they do not initialize the object! */
10
11 void
12 Py_IncRef(PyObject *o)
13 {
14 Py_XINCREF(o);
15 }
16
17 void
18 Py_DecRef(PyObject *o)
19 {
20 Py_XDECREF(o);
21 }
22
23 PyObject *
24 PyObject_Init(PyObject *op, PyTypeObject *tp)
25 {
26 if (op == NULL)
27 return PyErr_NoMemory();
28 /* Any changes should be reflected in PyObject_INIT (objimpl.h) */
29 Py_TYPE(op) = tp;
30 _Py_NewReference(op);
31 return op;
32 }
33
34 PyVarObject *
35 PyObject_InitVar(PyVarObject *op, PyTypeObject *tp, Py_ssize_t size)
36 {
37 if (op == NULL)
38 return (PyVarObject *) PyErr_NoMemory();
39 /* Any changes should be reflected in PyObject_INIT_VAR */
40 op->ob_size = size;
41 Py_TYPE(op) = tp;
42 _Py_NewReference((PyObject *)op);
43 return op;
44 }
45
46 PyObject *
47 _PyObject_New(PyTypeObject *tp)
48 {
49 PyObject *op;
50 op = (PyObject *) PyObject_MALLOC(_PyObject_SIZE(tp));
51 if (op == NULL)
52 return PyErr_NoMemory();
53 return PyObject_INIT(op, tp);
54 }
55
56 PyVarObject *
57 _PyObject_NewVar(PyTypeObject *tp, Py_ssize_t nitems)
58 {
59 PyVarObject *op;
60 const size_t size = _PyObject_VAR_SIZE(tp, nitems);
61 op = (PyVarObject *) PyObject_MALLOC(size);
62 if (op == NULL)
63 return (PyVarObject *)PyErr_NoMemory();
64 return PyObject_INIT_VAR(op, tp, nitems);
65 }
66
67 int
68 PyObject_Print(PyObject *op, FILE *fp, int flags)
69 {
70 int ret = 0;
71 if (PyErr_CheckSignals())
72 return -1;
73 #ifdef USE_STACKCHECK
74 if (PyOS_CheckStack()) {
75 PyErr_SetString(PyExc_MemoryError, "stack overflow");
76 return -1;
77 }
78 #endif
79 clearerr(fp); /* Clear any previous error condition */
80 if (op == NULL) {
81 Py_BEGIN_ALLOW_THREADS
82 fprintf(fp, "<nil>");
83 Py_END_ALLOW_THREADS
84 }
85 else {
86 if (op->ob_refcnt <= 0)
87 /* XXX(twouters) cast refcount to long until %zd is
88 universally available */
89 Py_BEGIN_ALLOW_THREADS
90 fprintf(fp, "<refcnt %ld at %p>",
91 (long)op->ob_refcnt, op);
92 Py_END_ALLOW_THREADS
93 else {
94 PyObject *s;
95 if (flags & Py_PRINT_RAW)
96 s = PyObject_Str(op);
97 else
98 s = PyObject_Repr(op);
99 if (s == NULL)
100 ret = -1;
101 else if (PyBytes_Check(s)) {
102 fwrite(PyBytes_AS_STRING(s), 1,
103 PyBytes_GET_SIZE(s), fp);
104 }
105 else if (PyUnicode_Check(s)) {
106 PyObject *t;
107 t = PyUnicode_AsEncodedString(s, "utf-8", "backslashreplace");
108 if (t == NULL)
109 ret = 0;
110 else {
111 fwrite(PyBytes_AS_STRING(t), 1,
112 PyBytes_GET_SIZE(t), fp);
113 Py_DECREF(t);
114 }
115 }
116 else {
117 PyErr_Format(PyExc_TypeError,
118 "str() or repr() returned '%.100s'",
119 s->ob_type->tp_name);
120 ret = -1;
121 }
122 Py_XDECREF(s);
123 }
124 }
125 if (ret == 0) {
126 if (ferror(fp)) {
127 PyErr_SetFromErrno(PyExc_IOError);
128 clearerr(fp);
129 ret = -1;
130 }
131 }
132 return ret;
133 }
134
135 /* For debugging convenience. Set a breakpoint here and call it from your DLL */
136 void
137 _Py_BreakPoint(void)
138 {
139 }
140
141
142 /* For debugging convenience. See Misc/gdbinit for some useful gdb hooks */
143 void
144 _PyObject_Dump(PyObject* op)
145 {
146 if (op == NULL)
147 fprintf(stderr, "NULL\n");
148 else {
149 #ifdef WITH_THREAD
150 PyGILState_STATE gil;
151 #endif
152 fprintf(stderr, "object : ");
153 #ifdef WITH_THREAD
154 gil = PyGILState_Ensure();
155 #endif
156 (void)PyObject_Print(op, stderr, 0);
157 #ifdef WITH_THREAD
158 PyGILState_Release(gil);
159 #endif
160 /* XXX(twouters) cast refcount to long until %zd is
161 universally available */
162 fprintf(stderr, "\n"
163 "type : %s\n"
164 "refcount: %ld\n"
165 "address : %p\n",
166 Py_TYPE(op)==NULL ? "NULL" : Py_TYPE(op)->tp_name,
167 (long)op->ob_refcnt,
168 op);
169 }
170 }
171
172 PyObject *
173 PyObject_Repr(PyObject *v)
174 {
175 PyObject *res;
176 if (PyErr_CheckSignals())
177 return NULL;
178 #ifdef USE_STACKCHECK
179 if (PyOS_CheckStack()) {
180 PyErr_SetString(PyExc_MemoryError, "stack overflow");
181 return NULL;
182 }
183 #endif
184 if (v == NULL)
185 return PyUnicode_FromString("<NULL>");
186 if (Py_TYPE(v)->tp_repr == NULL)
187 return PyUnicode_FromFormat("<%s object at %p>",
188 v->ob_type->tp_name, v);
189 res = (*v->ob_type->tp_repr)(v);
190 if (res == NULL)
191 return NULL;
192 if (!PyUnicode_Check(res)) {
193 PyErr_Format(PyExc_TypeError,
194 "__repr__ returned non-string (type %.200s)",
195 res->ob_type->tp_name);
196 Py_DECREF(res);
197 return NULL;
198 }
199 #ifndef Py_DEBUG
200 if (PyUnicode_READY(res) < 0)
201 return NULL;
202 #endif
203 return res;
204 }
205
206 PyObject *
207 PyObject_Str(PyObject *v)
208 {
209 PyObject *res;
210 if (PyErr_CheckSignals())
211 return NULL;
212 #ifdef USE_STACKCHECK
213 if (PyOS_CheckStack()) {
214 PyErr_SetString(PyExc_MemoryError, "stack overflow");
215 return NULL;
216 }
217 #endif
218 if (v == NULL)
219 return PyUnicode_FromString("<NULL>");
220 if (PyUnicode_CheckExact(v)) {
221 #ifndef Py_DEBUG
222 if (PyUnicode_READY(v) < 0)
223 return NULL;
224 #endif
225 Py_INCREF(v);
226 return v;
227 }
228 if (Py_TYPE(v)->tp_str == NULL)
229 return PyObject_Repr(v);
230
231 /* It is possible for a type to have a tp_str representation that loops
232 infinitely. */
233 if (Py_EnterRecursiveCall(" while getting the str of an object"))
234 return NULL;
235 res = (*Py_TYPE(v)->tp_str)(v);
236 Py_LeaveRecursiveCall();
237 if (res == NULL)
238 return NULL;
239 if (!PyUnicode_Check(res)) {
240 PyErr_Format(PyExc_TypeError,
241 "__str__ returned non-string (type %.200s)",
242 Py_TYPE(res)->tp_name);
243 Py_DECREF(res);
244 return NULL;
245 }
246 #ifndef Py_DEBUG
247 if (PyUnicode_READY(res) < 0)
248 return NULL;
249 #endif
250 assert(_PyUnicode_CheckConsistency(res, 1));
251 return res;
252 }
253
254 PyObject *
255 PyObject_ASCII(PyObject *v)
256 {
257 PyObject *repr, *ascii, *res;
258
259 repr = PyObject_Repr(v);
260 if (repr == NULL)
261 return NULL;
262
263 /* repr is guaranteed to be a PyUnicode object by PyObject_Repr */
264 ascii = _PyUnicode_AsASCIIString(repr, "backslashreplace");
265 Py_DECREF(repr);
266 if (ascii == NULL)
267 return NULL;
268
269 res = PyUnicode_DecodeASCII(
270 PyBytes_AS_STRING(ascii),
271 PyBytes_GET_SIZE(ascii),
272 NULL);
273
274 Py_DECREF(ascii);
275 return res;
276 }
277
278 PyObject *
279 PyObject_Bytes(PyObject *v)
280 {
281 PyObject *result, *func;
282 static PyObject *bytesstring = NULL;
283
284 if (v == NULL)
285 return PyBytes_FromString("<NULL>");
286
287 if (PyBytes_CheckExact(v)) {
288 Py_INCREF(v);
289 return v;
290 }
291
292 func = _PyObject_LookupSpecial(v, "__bytes__", &bytesstring);
293 if (func != NULL) {
294 result = PyObject_CallFunctionObjArgs(func, NULL);
295 Py_DECREF(func);
296 if (result == NULL)
297 return NULL;
298 if (!PyBytes_Check(result)) {
299 PyErr_Format(PyExc_TypeError,
300 "__bytes__ returned non-bytes (type %.200s)",
301 Py_TYPE(result)->tp_name);
302 Py_DECREF(result);
303 return NULL;
304 }
305 return result;
306 }
307 else if (PyErr_Occurred())
308 return NULL;
309 return PyBytes_FromObject(v);
310 }
311
312 /* For Python 3.0.1 and later, the old three-way comparison has been
313 completely removed in favour of rich comparisons. PyObject_Compare() and
314 PyObject_Cmp() are gone, and the builtin cmp function no longer exists.
315 The old tp_compare slot has been renamed to tp_reserved, and should no
316 longer be used. Use tp_richcompare instead.
317
318 See (*) below for practical amendments.
319
320 tp_richcompare gets called with a first argument of the appropriate type
321 and a second object of an arbitrary type. We never do any kind of
322 coercion.
323
324 The tp_richcompare slot should return an object, as follows:
325
326 NULL if an exception occurred
327 NotImplemented if the requested comparison is not implemented
328 any other false value if the requested comparison is false
329 any other true value if the requested comparison is true
330
331 The PyObject_RichCompare[Bool]() wrappers raise TypeError when they get
332 NotImplemented.
333
334 (*) Practical amendments:
335
336 - If rich comparison returns NotImplemented, == and != are decided by
337 comparing the object pointer (i.e. falling back to the base object
338 implementation).
339
340 */
341
342 /* Map rich comparison operators to their swapped version, e.g. LT <--> GT */
343 int _Py_SwappedOp[] = {Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE};
344
345 static char *opstrings[] = {"<", "<=", "==", "!=", ">", ">="};
346
347 /* Perform a rich comparison, raising TypeError when the requested comparison
348 operator is not supported. */
349 static PyObject *
350 do_richcompare(PyObject *v, PyObject *w, int op)
351 {
352 richcmpfunc f;
353 PyObject *res;
354 int checked_reverse_op = 0;
355
356 if (v->ob_type != w->ob_type &&
357 PyType_IsSubtype(w->ob_type, v->ob_type) &&
358 (f = w->ob_type->tp_richcompare) != NULL) {
359 checked_reverse_op = 1;
360 res = (*f)(w, v, _Py_SwappedOp[op]);
361 if (res != Py_NotImplemented)
362 return res;
363 Py_DECREF(res);
364 }
365 if ((f = v->ob_type->tp_richcompare) != NULL) {
366 res = (*f)(v, w, op);
367 if (res != Py_NotImplemented)
368 return res;
369 Py_DECREF(res);
370 }
371 if (!checked_reverse_op && (f = w->ob_type->tp_richcompare) != NULL) {
372 res = (*f)(w, v, _Py_SwappedOp[op]);
373 if (res != Py_NotImplemented)
374 return res;
375 Py_DECREF(res);
376 }
377 /* If neither object implements it, provide a sensible default
378 for == and !=, but raise an exception for ordering. */
379 switch (op) {
380 case Py_EQ:
381 res = (v == w) ? Py_True : Py_False;
382 break;
383 case Py_NE:
384 res = (v != w) ? Py_True : Py_False;
385 break;
386 default:
387 /* XXX Special-case None so it doesn't show as NoneType() */
388 PyErr_Format(PyExc_TypeError,
389 "unorderable types: %.100s() %s %.100s()",
390 v->ob_type->tp_name,
391 opstrings[op],
392 w->ob_type->tp_name);
393 return NULL;
394 }
395 Py_INCREF(res);
396 return res;
397 }
398
399 /* Perform a rich comparison with object result. This wraps do_richcompare()
400 with a check for NULL arguments and a recursion check. */
401
402 PyObject *
403 PyObject_RichCompare(PyObject *v, PyObject *w, int op)
404 {
405 PyObject *res;
406
407 assert(Py_LT <= op && op <= Py_GE);
408 if (v == NULL || w == NULL) {
409 if (!PyErr_Occurred())
410 PyErr_BadInternalCall();
411 return NULL;
412 }
413 if (Py_EnterRecursiveCall(" in comparison"))
414 return NULL;
415 res = do_richcompare(v, w, op);
416 Py_LeaveRecursiveCall();
417 return res;
418 }
419
420 /* Perform a rich comparison with integer result. This wraps
421 PyObject_RichCompare(), returning -1 for error, 0 for false, 1 for true. */
422 int
423 PyObject_RichCompareBool(PyObject *v, PyObject *w, int op)
424 {
425 PyObject *res;
426 int ok;
427
428 /* Quick result when objects are the same.
429 Guarantees that identity implies equality. */
430 if (v == w) {
431 if (op == Py_EQ)
432 return 1;
433 else if (op == Py_NE)
434 return 0;
435 }
436
437 res = PyObject_RichCompare(v, w, op);
438 if (res == NULL)
439 return -1;
440 if (PyBool_Check(res))
441 ok = (res == Py_True);
442 else
443 ok = PyObject_IsTrue(res);
444 Py_DECREF(res);
445 return ok;
446 }
447
448 /* Set of hash utility functions to help maintaining the invariant that
449 if a==b then hash(a)==hash(b)
450
451 All the utility functions (_Py_Hash*()) return "-1" to signify an error.
452 */
453
454 /* For numeric types, the hash of a number x is based on the reduction
455 of x modulo the prime P = 2**_PyHASH_BITS - 1. It's designed so that
456 hash(x) == hash(y) whenever x and y are numerically equal, even if
457 x and y have different types.
458
459 A quick summary of the hashing strategy:
460
461 (1) First define the 'reduction of x modulo P' for any rational
462 number x; this is a standard extension of the usual notion of
463 reduction modulo P for integers. If x == p/q (written in lowest
464 terms), the reduction is interpreted as the reduction of p times
465 the inverse of the reduction of q, all modulo P; if q is exactly
466 divisible by P then define the reduction to be infinity. So we've
467 got a well-defined map
468
469 reduce : { rational numbers } -> { 0, 1, 2, ..., P-1, infinity }.
470
471 (2) Now for a rational number x, define hash(x) by:
472
473 reduce(x) if x >= 0
474 -reduce(-x) if x < 0
475
476 If the result of the reduction is infinity (this is impossible for
477 integers, floats and Decimals) then use the predefined hash value
478 _PyHASH_INF for x >= 0, or -_PyHASH_INF for x < 0, instead.
479 _PyHASH_INF, -_PyHASH_INF and _PyHASH_NAN are also used for the
480 hashes of float and Decimal infinities and nans.
481
482 A selling point for the above strategy is that it makes it possible
483 to compute hashes of decimal and binary floating-point numbers
484 efficiently, even if the exponent of the binary or decimal number
485 is large. The key point is that
486
487 reduce(x * y) == reduce(x) * reduce(y) (modulo _PyHASH_MODULUS)
488
489 provided that {reduce(x), reduce(y)} != {0, infinity}. The reduction of a
490 binary or decimal float is never infinity, since the denominator is a power
491 of 2 (for binary) or a divisor of a power of 10 (for decimal). So we have,
492 for nonnegative x,
493
494 reduce(x * 2**e) == reduce(x) * reduce(2**e) % _PyHASH_MODULUS
495
496 reduce(x * 10**e) == reduce(x) * reduce(10**e) % _PyHASH_MODULUS
497
498 and reduce(10**e) can be computed efficiently by the usual modular
499 exponentiation algorithm. For reduce(2**e) it's even better: since
500 P is of the form 2**n-1, reduce(2**e) is 2**(e mod n), and multiplication
501 by 2**(e mod n) modulo 2**n-1 just amounts to a rotation of bits.
502
503 */
504
505 Py_hash_t
506 _Py_HashDouble(double v)
507 {
508 int e, sign;
509 double m;
510 Py_uhash_t x, y;
511
512 if (!Py_IS_FINITE(v)) {
513 if (Py_IS_INFINITY(v))
514 return v > 0 ? _PyHASH_INF : -_PyHASH_INF;
515 else
516 return _PyHASH_NAN;
517 }
518
519 m = frexp(v, &e);
520
521 sign = 1;
522 if (m < 0) {
523 sign = -1;
524 m = -m;
525 }
526
527 /* process 28 bits at a time; this should work well both for binary
528 and hexadecimal floating point. */
529 x = 0;
530 while (m) {
531 x = ((x << 28) & _PyHASH_MODULUS) | x >> (_PyHASH_BITS - 28);
532 m *= 268435456.0; /* 2**28 */
533 e -= 28;
534 y = (Py_uhash_t)m; /* pull out integer part */
535 m -= y;
536 x += y;
537 if (x >= _PyHASH_MODULUS)
538 x -= _PyHASH_MODULUS;
539 }
540
541 /* adjust for the exponent; first reduce it modulo _PyHASH_BITS */
542 e = e >= 0 ? e % _PyHASH_BITS : _PyHASH_BITS-1-((-1-e) % _PyHASH_BITS);
543 x = ((x << e) & _PyHASH_MODULUS) | x >> (_PyHASH_BITS - e);
544
545 x = x * sign;
546 if (x == (Py_uhash_t)-1)
547 x = (Py_uhash_t)-2;
548 return (Py_hash_t)x;
549 }
550
551 Py_hash_t
552 _Py_HashPointer(void *p)
553 {
554 Py_hash_t x;
555 size_t y = (size_t)p;
556 /* bottom 3 or 4 bits are likely to be 0; rotate y by 4 to avoid
557 excessive hash collisions for dicts and sets */
558 y = (y >> 4) | (y << (8 * SIZEOF_VOID_P - 4));
559 x = (Py_hash_t)y;
560 if (x == -1)
561 x = -2;
562 return x;
563 }
564
565 Py_hash_t
566 _Py_HashBytes(unsigned char *p, Py_ssize_t len)
567 {
568 Py_uhash_t x;
569 Py_ssize_t i;
570
571 x = (Py_uhash_t) *p << 7;
572 for (i = 0; i < len; i++)
573 x = (1000003U * x) ^ (Py_uhash_t) *p++;
574 x ^= (Py_uhash_t) len;
575 if (x == -1)
576 x = -2;
577 return x;
578 }
579
580 Py_hash_t
581 PyObject_HashNotImplemented(PyObject *v)
582 {
583 PyErr_Format(PyExc_TypeError, "unhashable type: '%.200s'",
584 Py_TYPE(v)->tp_name);
585 return -1;
586 }
587
588 Py_hash_t
589 PyObject_Hash(PyObject *v)
590 {
591 PyTypeObject *tp = Py_TYPE(v);
592 if (tp->tp_hash != NULL)
593 return (*tp->tp_hash)(v);
594 /* To keep to the general practice that inheriting
595 * solely from object in C code should work without
596 * an explicit call to PyType_Ready, we implicitly call
597 * PyType_Ready here and then check the tp_hash slot again
598 */
599 if (tp->tp_dict == NULL) {
600 if (PyType_Ready(tp) < 0)
601 return -1;
602 if (tp->tp_hash != NULL)
603 return (*tp->tp_hash)(v);
604 }
605 /* Otherwise, the object can't be hashed */
606 return PyObject_HashNotImplemented(v);
607 }
608
609 PyObject *
610 PyObject_GetAttrString(PyObject *v, const char *name)
611 {
612 PyObject *w, *res;
613
614 if (Py_TYPE(v)->tp_getattr != NULL)
615 return (*Py_TYPE(v)->tp_getattr)(v, (char*)name);
616 w = PyUnicode_InternFromString(name);
617 if (w == NULL)
618 return NULL;
619 res = PyObject_GetAttr(v, w);
620 Py_XDECREF(w);
621 return res;
622 }
623
624 int
625 PyObject_HasAttrString(PyObject *v, const char *name)
626 {
627 PyObject *res = PyObject_GetAttrString(v, name);
628 if (res != NULL) {
629 Py_DECREF(res);
630 return 1;
631 }
632 PyErr_Clear();
633 return 0;
634 }
635
636 int
637 PyObject_SetAttrString(PyObject *v, const char *name, PyObject *w)
638 {
639 PyObject *s;
640 int res;
641
642 if (Py_TYPE(v)->tp_setattr != NULL)
643 return (*Py_TYPE(v)->tp_setattr)(v, (char*)name, w);
644 s = PyUnicode_InternFromString(name);
645 if (s == NULL)
646 return -1;
647 res = PyObject_SetAttr(v, s, w);
648 Py_XDECREF(s);
649 return res;
650 }
651
652 int
653 _PyObject_IsAbstract(PyObject *obj)
654 {
655 int res;
656 PyObject* isabstract;
657 _Py_IDENTIFIER(__isabstractmethod__);
658
659 if (obj == NULL)
660 return 0;
661
662 isabstract = _PyObject_GetAttrId(obj, &PyId___isabstractmethod__);
663 if (isabstract == NULL) {
664 if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
665 PyErr_Clear();
666 return 0;
667 }
668 return -1;
669 }
670 res = PyObject_IsTrue(isabstract);
671 Py_DECREF(isabstract);
672 return res;
673 }
674
675 PyObject *
676 _PyObject_GetAttrId(PyObject *v, _Py_Identifier *name)
677 {
678 PyObject *result;
679 PyObject *oname = _PyUnicode_FromId(name); /* borrowed */
680 if (!oname)
681 return NULL;
682 result = PyObject_GetAttr(v, oname);
683 return result;
684 }
685
686 int
687 _PyObject_HasAttrId(PyObject *v, _Py_Identifier *name)
688 {
689 int result;
690 PyObject *oname = _PyUnicode_FromId(name); /* borrowed */
691 if (!oname)
692 return -1;
693 result = PyObject_HasAttr(v, oname);
694 return result;
695 }
696
697 int
698 _PyObject_SetAttrId(PyObject *v, _Py_Identifier *name, PyObject *w)
699 {
700 int result;
701 PyObject *oname = _PyUnicode_FromId(name); /* borrowed */
702 if (!oname)
703 return -1;
704 result = PyObject_SetAttr(v, oname, w);
705 return result;
706 }
707
708 PyObject *
709 PyObject_GetAttr(PyObject *v, PyObject *name)
710 {
711 PyTypeObject *tp = Py_TYPE(v);
712
713 if (!PyUnicode_Check(name)) {
714 PyErr_Format(PyExc_TypeError,
715 "attribute name must be string, not '%.200s'",
716 name->ob_type->tp_name);
717 return NULL;
718 }
719 if (tp->tp_getattro != NULL)
720 return (*tp->tp_getattro)(v, name);
721 if (tp->tp_getattr != NULL) {
722 char *name_str = _PyUnicode_AsString(name);
723 if (name_str == NULL)
724 return NULL;
725 return (*tp->tp_getattr)(v, name_str);
726 }
727 PyErr_Format(PyExc_AttributeError,
728 "'%.50s' object has no attribute '%U'",
729 tp->tp_name, name);
730 return NULL;
731 }
732
733 int
734 PyObject_HasAttr(PyObject *v, PyObject *name)
735 {
736 PyObject *res = PyObject_GetAttr(v, name);
737 if (res != NULL) {
738 Py_DECREF(res);
739 return 1;
740 }
741 PyErr_Clear();
742 return 0;
743 }
744
745 int
746 PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value)
747 {
748 PyTypeObject *tp = Py_TYPE(v);
749 int err;
750
751 if (!PyUnicode_Check(name)) {
752 PyErr_Format(PyExc_TypeError,
753 "attribute name must be string, not '%.200s'",
754 name->ob_type->tp_name);
755 return -1;
756 }
757 Py_INCREF(name);
758
759 PyUnicode_InternInPlace(&name);
760 if (tp->tp_setattro != NULL) {
761 err = (*tp->tp_setattro)(v, name, value);
762 Py_DECREF(name);
763 return err;
764 }
765 if (tp->tp_setattr != NULL) {
766 char *name_str = _PyUnicode_AsString(name);
767 if (name_str == NULL)
768 return -1;
769 err = (*tp->tp_setattr)(v, name_str, value);
770 Py_DECREF(name);
771 return err;
772 }
773 Py_DECREF(name);
774 assert(name->ob_refcnt >= 1);
775 if (tp->tp_getattr == NULL && tp->tp_getattro == NULL)
776 PyErr_Format(PyExc_TypeError,
777 "'%.100s' object has no attributes "
778 "(%s .%U)",
779 tp->tp_name,
780 value==NULL ? "del" : "assign to",
781 name);
782 else
783 PyErr_Format(PyExc_TypeError,
784 "'%.100s' object has only read-only attributes "
785 "(%s .%U)",
786 tp->tp_name,
787 value==NULL ? "del" : "assign to",
788 name);
789 return -1;
790 }
791
792 /* Helper to get a pointer to an object's __dict__ slot, if any */
793
794 PyObject **
795 _PyObject_GetDictPtr(PyObject *obj)
796 {
797 Py_ssize_t dictoffset;
798 PyTypeObject *tp = Py_TYPE(obj);
799
800 dictoffset = tp->tp_dictoffset;
801 if (dictoffset == 0)
802 return NULL;
803 if (dictoffset < 0) {
804 Py_ssize_t tsize;
805 size_t size;
806
807 tsize = ((PyVarObject *)obj)->ob_size;
808 if (tsize < 0)
809 tsize = -tsize;
810 size = _PyObject_VAR_SIZE(tp, tsize);
811
812 dictoffset += (long)size;
813 assert(dictoffset > 0);
814 assert(dictoffset % SIZEOF_VOID_P == 0);
815 }
816 return (PyObject **) ((char *)obj + dictoffset);
817 }
818
819 PyObject *
820 PyObject_SelfIter(PyObject *obj)
821 {
822 Py_INCREF(obj);
823 return obj;
824 }
825
826 /* Helper used when the __next__ method is removed from a type:
827 tp_iternext is never NULL and can be safely called without checking
828 on every iteration.
829 */
830
831 PyObject *
832 _PyObject_NextNotImplemented(PyObject *self)
833 {
834 PyErr_Format(PyExc_TypeError,
835 "'%.200s' object is not iterable",
836 Py_TYPE(self)->tp_name);
837 return NULL;
838 }
839
840 /* Generic GetAttr functions - put these in your tp_[gs]etattro slot */
841
842 PyObject *
843 _PyObject_GenericGetAttrWithDict(PyObject *obj, PyObject *name, PyObject *dict)
844 {
845 PyTypeObject *tp = Py_TYPE(obj);
846 PyObject *descr = NULL;
847 PyObject *res = NULL;
848 descrgetfunc f;
849 Py_ssize_t dictoffset;
850 PyObject **dictptr;
851
852 if (!PyUnicode_Check(name)){
853 PyErr_Format(PyExc_TypeError,
854 "attribute name must be string, not '%.200s'",
855 name->ob_type->tp_name);
856 return NULL;
857 }
858 else
859 Py_INCREF(name);
860
861 if (tp->tp_dict == NULL) {
862 if (PyType_Ready(tp) < 0)
863 goto done;
864 }
865
866 descr = _PyType_Lookup(tp, name);
867 Py_XINCREF(descr);
868
869 f = NULL;
870 if (descr != NULL) {
871 f = descr->ob_type->tp_descr_get;
872 if (f != NULL && PyDescr_IsData(descr)) {
873 res = f(descr, obj, (PyObject *)obj->ob_type);
874 Py_DECREF(descr);
875 goto done;
876 }
877 }
878
879 if (dict == NULL) {
880 /* Inline _PyObject_GetDictPtr */
881 dictoffset = tp->tp_dictoffset;
882 if (dictoffset != 0) {
883 if (dictoffset < 0) {
884 Py_ssize_t tsize;
885 size_t size;
886
887 tsize = ((PyVarObject *)obj)->ob_size;
888 if (tsize < 0)
889 tsize = -tsize;
890 size = _PyObject_VAR_SIZE(tp, tsize);
891
892 dictoffset += (long)size;
893 assert(dictoffset > 0);
894 assert(dictoffset % SIZEOF_VOID_P == 0);
895 }
896 dictptr = (PyObject **) ((char *)obj + dictoffset);
897 dict = *dictptr;
898 }
899 }
900 if (dict != NULL) {
901 Py_INCREF(dict);
902 res = PyDict_GetItem(dict, name);
903 if (res != NULL) {
904 Py_INCREF(res);
905 Py_XDECREF(descr);
906 Py_DECREF(dict);
907 goto done;
908 }
909 Py_DECREF(dict);
910 }
911
912 if (f != NULL) {
913 res = f(descr, obj, (PyObject *)Py_TYPE(obj));
914 Py_DECREF(descr);
915 goto done;
916 }
917
918 if (descr != NULL) {
919 res = descr;
920 /* descr was already increfed above */
921 goto done;
922 }
923
924 PyErr_Format(PyExc_AttributeError,
925 "'%.50s' object has no attribute '%U'",
926 tp->tp_name, name);
927 done:
928 Py_DECREF(name);
929 return res;
930 }
931
932 PyObject *
933 PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
934 {
935 return _PyObject_GenericGetAttrWithDict(obj, name, NULL);
936 }
937
938 int
939 _PyObject_GenericSetAttrWithDict(PyObject *obj, PyObject *name,
940 PyObject *value, PyObject *dict)
941 {
942 PyTypeObject *tp = Py_TYPE(obj);
943 PyObject *descr;
944 descrsetfunc f;
945 PyObject **dictptr;
946 int res = -1;
947
948 if (!PyUnicode_Check(name)){
949 PyErr_Format(PyExc_TypeError,
950 "attribute name must be string, not '%.200s'",
951 name->ob_type->tp_name);
952 return -1;
953 }
954 else
955 Py_INCREF(name);
956
957 if (tp->tp_dict == NULL) {
958 if (PyType_Ready(tp) < 0)
959 goto done;
960 }
961
962 descr = _PyType_Lookup(tp, name);
963 f = NULL;
964 if (descr != NULL) {
965 f = descr->ob_type->tp_descr_set;
966 if (f != NULL && PyDescr_IsData(descr)) {
967 res = f(descr, obj, value);
968 goto done;
969 }
970 }
971
972 if (dict == NULL) {
973 dictptr = _PyObject_GetDictPtr(obj);
974 if (dictptr != NULL) {
975 dict = *dictptr;
976 if (dict == NULL && value != NULL) {
977 dict = PyDict_New();
978 if (dict == NULL)
979 goto done;
980 *dictptr = dict;
981 }
982 }
983 }
984 if (dict != NULL) {
985 Py_INCREF(dict);
986 if (value == NULL)
987 res = PyDict_DelItem(dict, name);
988 else
989 res = PyDict_SetItem(dict, name, value);
990 if (res < 0 && PyErr_ExceptionMatches(PyExc_KeyError))
991 PyErr_SetObject(PyExc_AttributeError, name);
992 Py_DECREF(dict);
993 goto done;
994 }
995
996 if (f != NULL) {
997 res = f(descr, obj, value);
998 goto done;
999 }
1000
1001 if (descr == NULL) {
1002 PyErr_Format(PyExc_AttributeError,
1003 "'%.100s' object has no attribute '%U'",
1004 tp->tp_name, name);
1005 goto done;
1006 }
1007
1008 PyErr_Format(PyExc_AttributeError,
1009 "'%.50s' object attribute '%U' is read-only",
1010 tp->tp_name, name);
1011 done:
1012 Py_DECREF(name);
1013 return res;
1014 }
1015
1016 int
1017 PyObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value)
1018 {
1019 return _PyObject_GenericSetAttrWithDict(obj, name, value, NULL);
1020 }
1021
1022
1023 /* Test a value used as condition, e.g., in a for or if statement.
1024 Return -1 if an error occurred */
1025
1026 int
1027 PyObject_IsTrue(PyObject *v)
1028 {
1029 Py_ssize_t res;
1030 if (v == Py_True)
1031 return 1;
1032 if (v == Py_False)
1033 return 0;
1034 if (v == Py_None)
1035 return 0;
1036 else if (v->ob_type->tp_as_number != NULL &&
1037 v->ob_type->tp_as_number->nb_bool != NULL)
1038 res = (*v->ob_type->tp_as_number->nb_bool)(v);
1039 else if (v->ob_type->tp_as_mapping != NULL &&
1040 v->ob_type->tp_as_mapping->mp_length != NULL)
1041 res = (*v->ob_type->tp_as_mapping->mp_length)(v);
1042 else if (v->ob_type->tp_as_sequence != NULL &&
1043 v->ob_type->tp_as_sequence->sq_length != NULL)
1044 res = (*v->ob_type->tp_as_sequence->sq_length)(v);
1045 else
1046 return 1;
1047 /* if it is negative, it should be either -1 or -2 */
1048 return (res > 0) ? 1 : Py_SAFE_DOWNCAST(res, Py_ssize_t, int);
1049 }
1050
1051 /* equivalent of 'not v'
1052 Return -1 if an error occurred */
1053
1054 int
1055 PyObject_Not(PyObject *v)
1056 {
1057 int res;
1058 res = PyObject_IsTrue(v);
1059 if (res < 0)
1060 return res;
1061 return res == 0;
1062 }
1063
1064 /* Test whether an object can be called */
1065
1066 int
1067 PyCallable_Check(PyObject *x)
1068 {
1069 if (x == NULL)
1070 return 0;
1071 return x->ob_type->tp_call != NULL;
1072 }
1073
1074
1075 /* Helper for PyObject_Dir without arguments: returns the local scope. */
1076 static PyObject *
1077 _dir_locals(void)
1078 {
1079 PyObject *names;
1080 PyObject *locals = PyEval_GetLocals();
1081
1082 if (locals == NULL) {
1083 PyErr_SetString(PyExc_SystemError, "frame does not exist");
1084 return NULL;
1085 }
1086
1087 names = PyMapping_Keys(locals);
1088 if (!names)
1089 return NULL;
1090 if (!PyList_Check(names)) {
1091 PyErr_Format(PyExc_TypeError,
1092 "dir(): expected keys() of locals to be a list, "
1093 "not '%.200s'", Py_TYPE(names)->tp_name);
1094 Py_DECREF(names);
1095 return NULL;
1096 }
1097 if (PyList_Sort(names)) {
1098 Py_DECREF(names);
1099 return NULL;
1100 }
1101 /* the locals don't need to be DECREF'd */
1102 return names;
1103 }
1104
1105 /* Helper for PyObject_Dir: object introspection. */
1106 static PyObject *
1107 _dir_object(PyObject *obj)
1108 {
1109 PyObject *result, *sorted;
1110 static PyObject *dir_str = NULL;
1111 PyObject *dirfunc = _PyObject_LookupSpecial(obj, "__dir__", &dir_str);
1112
1113 assert(obj);
1114 if (dirfunc == NULL) {
1115 if (!PyErr_Occurred())
1116 PyErr_SetString(PyExc_TypeError, "object does not provide __dir__");
1117 return NULL;
1118 }
1119 /* use __dir__ */
1120 result = PyObject_CallFunctionObjArgs(dirfunc, NULL);
1121 Py_DECREF(dirfunc);
1122 if (result == NULL)
1123 return NULL;
1124 /* return sorted(result) */
1125 sorted = PySequence_List(result);
1126 Py_DECREF(result);
1127 if (sorted == NULL)
1128 return NULL;
1129 if (PyList_Sort(sorted)) {
1130 Py_DECREF(sorted);
1131 return NULL;
1132 }
1133 return sorted;
1134 }
1135
1136 /* Implementation of dir() -- if obj is NULL, returns the names in the current
1137 (local) scope. Otherwise, performs introspection of the object: returns a
1138 sorted list of attribute names (supposedly) accessible from the object
1139 */
1140 PyObject *
1141 PyObject_Dir(PyObject *obj)
1142 {
1143 return (obj == NULL) ? _dir_locals() : _dir_object(obj);
1144 }
1145
1146 /*
1147 None is a non-NULL undefined value.
1148 There is (and should be!) no way to create other objects of this type,
1149 so there is exactly one (which is indestructible, by the way).
1150 */
1151
1152 /* ARGSUSED */
1153 static PyObject *
1154 none_repr(PyObject *op)
1155 {
1156 return PyUnicode_FromString("None");
1157 }
1158
1159 /* ARGUSED */
1160 static void
1161 none_dealloc(PyObject* ignore)
1162 {
1163 /* This should never get called, but we also don't want to SEGV if
1164 * we accidentally decref None out of existence.
1165 */
1166 Py_FatalError("deallocating None");
1167 }
1168
1169 static PyObject *
1170 none_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1171 {
1172 if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_Size(kwargs))) {
1173 PyErr_SetString(PyExc_TypeError, "NoneType takes no arguments");
1174 return NULL;
1175 }
1176 Py_RETURN_NONE;
1177 }
1178
1179 static int
1180 none_bool(PyObject *v)
1181 {
1182 return 0;
1183 }
1184
1185 static PyNumberMethods none_as_number = {
1186 0, /* nb_add */
1187 0, /* nb_subtract */
1188 0, /* nb_multiply */
1189 0, /* nb_remainder */
1190 0, /* nb_divmod */
1191 0, /* nb_power */
1192 0, /* nb_negative */
1193 0, /* nb_positive */
1194 0, /* nb_absolute */
1195 (inquiry)none_bool, /* nb_bool */
1196 0, /* nb_invert */
1197 0, /* nb_lshift */
1198 0, /* nb_rshift */
1199 0, /* nb_and */
1200 0, /* nb_xor */
1201 0, /* nb_or */
1202 0, /* nb_int */
1203 0, /* nb_reserved */
1204 0, /* nb_float */
1205 0, /* nb_inplace_add */
1206 0, /* nb_inplace_subtract */
1207 0, /* nb_inplace_multiply */
1208 0, /* nb_inplace_remainder */
1209 0, /* nb_inplace_power */
1210 0, /* nb_inplace_lshift */
1211 0, /* nb_inplace_rshift */
1212 0, /* nb_inplace_and */
1213 0, /* nb_inplace_xor */
1214 0, /* nb_inplace_or */
1215 0, /* nb_floor_divide */
1216 0, /* nb_true_divide */
1217 0, /* nb_inplace_floor_divide */
1218 0, /* nb_inplace_true_divide */
1219 0, /* nb_index */
1220 };
1221
1222 static PyTypeObject PyNone_Type = {
1223 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1224 "NoneType",
1225 0,
1226 0,
1227 none_dealloc, /*tp_dealloc*/ /*never called*/
1228 0, /*tp_print*/
1229 0, /*tp_getattr*/
1230 0, /*tp_setattr*/
1231 0, /*tp_reserved*/
1232 none_repr, /*tp_repr*/
1233 &none_as_number, /*tp_as_number*/
1234 0, /*tp_as_sequence*/
1235 0, /*tp_as_mapping*/
1236 0, /*tp_hash */
1237 0, /*tp_call */
1238 0, /*tp_str */
1239 0, /*tp_getattro */
1240 0, /*tp_setattro */
1241 0, /*tp_as_buffer */
1242 Py_TPFLAGS_DEFAULT, /*tp_flags */
1243 0, /*tp_doc */
1244 0, /*tp_traverse */
1245 0, /*tp_clear */
1246 0, /*tp_richcompare */
1247 0, /*tp_weaklistoffset */
1248 0, /*tp_iter */
1249 0, /*tp_iternext */
1250 0, /*tp_methods */
1251 0, /*tp_members */
1252 0, /*tp_getset */
1253 0, /*tp_base */
1254 0, /*tp_dict */
1255 0, /*tp_descr_get */
1256 0, /*tp_descr_set */
1257 0, /*tp_dictoffset */
1258 0, /*tp_init */
1259 0, /*tp_alloc */
1260 none_new, /*tp_new */
1261 };
1262
1263 PyObject _Py_NoneStruct = {
1264 _PyObject_EXTRA_INIT
1265 1, &PyNone_Type
1266 };
1267
1268 /* NotImplemented is an object that can be used to signal that an
1269 operation is not implemented for the given type combination. */
1270
1271 static PyObject *
1272 NotImplemented_repr(PyObject *op)
1273 {
1274 return PyUnicode_FromString("NotImplemented");
1275 }
1276
1277 static PyObject *
1278 notimplemented_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1279 {
1280 if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_Size(kwargs))) {
1281 PyErr_SetString(PyExc_TypeError, "NotImplementedType takes no arguments");
1282 return NULL;
1283 }
1284 Py_RETURN_NOTIMPLEMENTED;
1285 }
1286
1287 static PyTypeObject PyNotImplemented_Type = {
1288 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1289 "NotImplementedType",
1290 0,
1291 0,
1292 none_dealloc, /*tp_dealloc*/ /*never called*/
1293 0, /*tp_print*/
1294 0, /*tp_getattr*/
1295 0, /*tp_setattr*/
1296 0, /*tp_reserved*/
1297 NotImplemented_repr, /*tp_repr*/
1298 0, /*tp_as_number*/
1299 0, /*tp_as_sequence*/
1300 0, /*tp_as_mapping*/
1301 0, /*tp_hash */
1302 0, /*tp_call */
1303 0, /*tp_str */
1304 0, /*tp_getattro */
1305 0, /*tp_setattro */
1306 0, /*tp_as_buffer */
1307 Py_TPFLAGS_DEFAULT, /*tp_flags */
1308 0, /*tp_doc */
1309 0, /*tp_traverse */
1310 0, /*tp_clear */
1311 0, /*tp_richcompare */
1312 0, /*tp_weaklistoffset */
1313 0, /*tp_iter */
1314 0, /*tp_iternext */
1315 0, /*tp_methods */
1316 0, /*tp_members */
1317 0, /*tp_getset */
1318 0, /*tp_base */
1319 0, /*tp_dict */
1320 0, /*tp_descr_get */
1321 0, /*tp_descr_set */
1322 0, /*tp_dictoffset */
1323 0, /*tp_init */
1324 0, /*tp_alloc */
1325 notimplemented_new, /*tp_new */
1326 };
1327
1328 PyObject _Py_NotImplementedStruct = {
1329 _PyObject_EXTRA_INIT
1330 1, &PyNotImplemented_Type
1331 };
1332
1333 void
1334 _Py_ReadyTypes(void)
1335 {
1336 if (PyType_Ready(&PyType_Type) < 0)
1337 Py_FatalError("Can't initialize type type");
1338
1339 if (PyType_Ready(&_PyWeakref_RefType) < 0)
1340 Py_FatalError("Can't initialize weakref type");
1341
1342 if (PyType_Ready(&_PyWeakref_CallableProxyType) < 0)
1343 Py_FatalError("Can't initialize callable weakref proxy type");
1344
1345 if (PyType_Ready(&_PyWeakref_ProxyType) < 0)
1346 Py_FatalError("Can't initialize weakref proxy type");
1347
1348 if (PyType_Ready(&PyBool_Type) < 0)
1349 Py_FatalError("Can't initialize bool type");
1350
1351 if (PyType_Ready(&PyByteArray_Type) < 0)
1352 Py_FatalError("Can't initialize bytearray type");
1353
1354 if (PyType_Ready(&PyBytes_Type) < 0)
1355 Py_FatalError("Can't initialize 'str'");
1356
1357 if (PyType_Ready(&PyList_Type) < 0)
1358 Py_FatalError("Can't initialize list type");
1359
1360 if (PyType_Ready(&PyNone_Type) < 0)
1361 Py_FatalError("Can't initialize None type");
1362
1363 if (PyType_Ready(&PyNotImplemented_Type) < 0)
1364 Py_FatalError("Can't initialize NotImplemented type");
1365
1366 if (PyType_Ready(&PyTraceBack_Type) < 0)
1367 Py_FatalError("Can't initialize traceback type");
1368
1369 if (PyType_Ready(&PySuper_Type) < 0)
1370 Py_FatalError("Can't initialize super type");
1371
1372 if (PyType_Ready(&PyBaseObject_Type) < 0)
1373 Py_FatalError("Can't initialize object type");
1374
1375 if (PyType_Ready(&PyRange_Type) < 0)
1376 Py_FatalError("Can't initialize range type");
1377
1378 if (PyType_Ready(&PyDict_Type) < 0)
1379 Py_FatalError("Can't initialize dict type");
1380
1381 if (PyType_Ready(&PySet_Type) < 0)
1382 Py_FatalError("Can't initialize set type");
1383
1384 if (PyType_Ready(&PyUnicode_Type) < 0)
1385 Py_FatalError("Can't initialize str type");
1386
1387 if (PyType_Ready(&PySlice_Type) < 0)
1388 Py_FatalError("Can't initialize slice type");
1389
1390 if (PyType_Ready(&PyStaticMethod_Type) < 0)
1391 Py_FatalError("Can't initialize static method type");
1392
1393 if (PyType_Ready(&PyComplex_Type) < 0)
1394 Py_FatalError("Can't initialize complex type");
1395
1396 if (PyType_Ready(&PyFloat_Type) < 0)
1397 Py_FatalError("Can't initialize float type");
1398
1399 if (PyType_Ready(&PyLong_Type) < 0)
1400 Py_FatalError("Can't initialize int type");
1401
1402 if (PyType_Ready(&PyFrozenSet_Type) < 0)
1403 Py_FatalError("Can't initialize frozenset type");
1404
1405 if (PyType_Ready(&PyProperty_Type) < 0)
1406 Py_FatalError("Can't initialize property type");
1407
1408 if (PyType_Ready(&PyMemoryView_Type) < 0)
1409 Py_FatalError("Can't initialize memoryview type");
1410
1411 if (PyType_Ready(&PyTuple_Type) < 0)
1412 Py_FatalError("Can't initialize tuple type");
1413
1414 if (PyType_Ready(&PyEnum_Type) < 0)
1415 Py_FatalError("Can't initialize enumerate type");
1416
1417 if (PyType_Ready(&PyReversed_Type) < 0)
1418 Py_FatalError("Can't initialize reversed type");
1419
1420 if (PyType_Ready(&PyStdPrinter_Type) < 0)
1421 Py_FatalError("Can't initialize StdPrinter");
1422
1423 if (PyType_Ready(&PyCode_Type) < 0)
1424 Py_FatalError("Can't initialize code type");
1425
1426 if (PyType_Ready(&PyFrame_Type) < 0)
1427 Py_FatalError("Can't initialize frame type");
1428
1429 if (PyType_Ready(&PyCFunction_Type) < 0)
1430 Py_FatalError("Can't initialize builtin function type");
1431
1432 if (PyType_Ready(&PyMethod_Type) < 0)
1433 Py_FatalError("Can't initialize method type");
1434
1435 if (PyType_Ready(&PyFunction_Type) < 0)
1436 Py_FatalError("Can't initialize function type");
1437
1438 if (PyType_Ready(&PyDictProxy_Type) < 0)
1439 Py_FatalError("Can't initialize dict proxy type");
1440
1441 if (PyType_Ready(&PyGen_Type) < 0)
1442 Py_FatalError("Can't initialize generator type");
1443
1444 if (PyType_Ready(&PyGetSetDescr_Type) < 0)
1445 Py_FatalError("Can't initialize get-set descriptor type");
1446
1447 if (PyType_Ready(&PyWrapperDescr_Type) < 0)
1448 Py_FatalError("Can't initialize wrapper type");
1449
1450 if (PyType_Ready(&_PyMethodWrapper_Type) < 0)
1451 Py_FatalError("Can't initialize method wrapper type");
1452
1453 if (PyType_Ready(&PyEllipsis_Type) < 0)
1454 Py_FatalError("Can't initialize ellipsis type");
1455
1456 if (PyType_Ready(&PyMemberDescr_Type) < 0)
1457 Py_FatalError("Can't initialize member descriptor type");
1458
1459 if (PyType_Ready(&PyFilter_Type) < 0)
1460 Py_FatalError("Can't initialize filter type");
1461
1462 if (PyType_Ready(&PyMap_Type) < 0)
1463 Py_FatalError("Can't initialize map type");
1464
1465 if (PyType_Ready(&PyZip_Type) < 0)
1466 Py_FatalError("Can't initialize zip type");
1467 }
1468
1469
1470 #ifdef Py_TRACE_REFS
1471
1472 void
1473 _Py_NewReference(PyObject *op)
1474 {
1475 _Py_INC_REFTOTAL;
1476 op->ob_refcnt = 1;
1477 _Py_AddToAllObjects(op, 1);
1478 _Py_INC_TPALLOCS(op);
1479 }
1480
1481 void
1482 _Py_ForgetReference(register PyObject *op)
1483 {
1484 #ifdef SLOW_UNREF_CHECK
1485 register PyObject *p;
1486 #endif
1487 if (op->ob_refcnt < 0)
1488 Py_FatalError("UNREF negative refcnt");
1489 if (op == &refchain ||
1490 op->_ob_prev->_ob_next != op || op->_ob_next->_ob_prev != op) {
1491 fprintf(stderr, "* ob\n");
1492 _PyObject_Dump(op);
1493 fprintf(stderr, "* op->_ob_prev->_ob_next\n");
1494 _PyObject_Dump(op->_ob_prev->_ob_next);
1495 fprintf(stderr, "* op->_ob_next->_ob_prev\n");
1496 _PyObject_Dump(op->_ob_next->_ob_prev);
1497 Py_FatalError("UNREF invalid object");
1498 }
1499 #ifdef SLOW_UNREF_CHECK
1500 for (p = refchain._ob_next; p != &refchain; p = p->_ob_next) {
1501 if (p == op)
1502 break;
1503 }
1504 if (p == &refchain) /* Not found */
1505 Py_FatalError("UNREF unknown object");
1506 #endif
1507 op->_ob_next->_ob_prev = op->_ob_prev;
1508 op->_ob_prev->_ob_next = op->_ob_next;
1509 op->_ob_next = op->_ob_prev = NULL;
1510 _Py_INC_TPFREES(op);
1511 }
1512
1513 void
1514 _Py_Dealloc(PyObject *op)
1515 {
1516 destructor dealloc = Py_TYPE(op)->tp_dealloc;
1517 _Py_ForgetReference(op);
1518 (*dealloc)(op);
1519 }
1520
1521 /* Print all live objects. Because PyObject_Print is called, the
1522 * interpreter must be in a healthy state.
1523 */
1524 void
1525 _Py_PrintReferences(FILE *fp)
1526 {
1527 PyObject *op;
1528 fprintf(fp, "Remaining objects:\n");
1529 for (op = refchain._ob_next; op != &refchain; op = op->_ob_next) {
1530 fprintf(fp, "%p [%" PY_FORMAT_SIZE_T "d] ", op, op->ob_refcnt);
1531 if (PyObject_Print(op, fp, 0) != 0)
1532 PyErr_Clear();
1533 putc('\n', fp);
1534 }
1535 }
1536
1537 /* Print the addresses of all live objects. Unlike _Py_PrintReferences, this
1538 * doesn't make any calls to the Python C API, so is always safe to call.
1539 */
1540 void
1541 _Py_PrintReferenceAddresses(FILE *fp)
1542 {
1543 PyObject *op;
1544 fprintf(fp, "Remaining object addresses:\n");
1545 for (op = refchain._ob_next; op != &refchain; op = op->_ob_next)
1546 fprintf(fp, "%p [%" PY_FORMAT_SIZE_T "d] %s\n", op,
1547 op->ob_refcnt, Py_TYPE(op)->tp_name);
1548 }
1549
1550 PyObject *
1551 _Py_GetObjects(PyObject *self, PyObject *args)
1552 {
1553 int i, n;
1554 PyObject *t = NULL;
1555 PyObject *res, *op;
1556
1557 if (!PyArg_ParseTuple(args, "i|O", &n, &t))
1558 return NULL;
1559 op = refchain._ob_next;
1560 res = PyList_New(0);
1561 if (res == NULL)
1562 return NULL;
1563 for (i = 0; (n == 0 || i < n) && op != &refchain; i++) {
1564 while (op == self || op == args || op == res || op == t ||
1565 (t != NULL && Py_TYPE(op) != (PyTypeObject *) t)) {
1566 op = op->_ob_next;
1567 if (op == &refchain)
1568 return res;
1569 }
1570 if (PyList_Append(res, op) < 0) {
1571 Py_DECREF(res);
1572 return NULL;
1573 }
1574 op = op->_ob_next;
1575 }
1576 return res;
1577 }
1578
1579 #endif
1580
1581 /* Hack to force loading of pycapsule.o */
1582 PyTypeObject *_PyCapsule_hack = &PyCapsule_Type;
1583
1584
1585 /* Hack to force loading of abstract.o */
1586 Py_ssize_t (*_Py_abstract_hack)(PyObject *) = PyObject_Size;
1587
1588
1589 /* Python's malloc wrappers (see pymem.h) */
1590
1591 void *
1592 PyMem_Malloc(size_t nbytes)
1593 {
1594 return PyMem_MALLOC(nbytes);
1595 }
1596
1597 void *
1598 PyMem_Realloc(void *p, size_t nbytes)
1599 {
1600 return PyMem_REALLOC(p, nbytes);
1601 }
1602
1603 void
1604 PyMem_Free(void *p)
1605 {
1606 PyMem_FREE(p);
1607 }
1608
1609
1610 /* These methods are used to control infinite recursion in repr, str, print,
1611 etc. Container objects that may recursively contain themselves,
1612 e.g. builtin dictionaries and lists, should used Py_ReprEnter() and
1613 Py_ReprLeave() to avoid infinite recursion.
1614
1615 Py_ReprEnter() returns 0 the first time it is called for a particular
1616 object and 1 every time thereafter. It returns -1 if an exception
1617 occurred. Py_ReprLeave() has no return value.
1618
1619 See dictobject.c and listobject.c for examples of use.
1620 */
1621
1622 #define KEY "Py_Repr"
1623
1624 int
1625 Py_ReprEnter(PyObject *obj)
1626 {
1627 PyObject *dict;
1628 PyObject *list;
1629 Py_ssize_t i;
1630
1631 dict = PyThreadState_GetDict();
1632 if (dict == NULL)
1633 return 0;
1634 list = PyDict_GetItemString(dict, KEY);
1635 if (list == NULL) {
1636 list = PyList_New(0);
1637 if (list == NULL)
1638 return -1;
1639 if (PyDict_SetItemString(dict, KEY, list) < 0)
1640 return -1;
1641 Py_DECREF(list);
1642 }
1643 i = PyList_GET_SIZE(list);
1644 while (--i >= 0) {
1645 if (PyList_GET_ITEM(list, i) == obj)
1646 return 1;
1647 }
1648 PyList_Append(list, obj);
1649 return 0;
1650 }
1651
1652 void
1653 Py_ReprLeave(PyObject *obj)
1654 {
1655 PyObject *dict;
1656 PyObject *list;
1657 Py_ssize_t i;
1658
1659 dict = PyThreadState_GetDict();
1660 if (dict == NULL)
1661 return;
1662 list = PyDict_GetItemString(dict, KEY);
1663 if (list == NULL || !PyList_Check(list))
1664 return;
1665 i = PyList_GET_SIZE(list);
1666 /* Count backwards because we always expect obj to be list[-1] */
1667 while (--i >= 0) {
1668 if (PyList_GET_ITEM(list, i) == obj) {
1669 PyList_SetSlice(list, i, i + 1, NULL);
1670 break;
1671 }
1672 }
1673 }
1674
1675 /* Trashcan support. */
1676
1677 /* Current call-stack depth of tp_dealloc calls. */
1678 int _PyTrash_delete_nesting = 0;
1679
1680 /* List of objects that still need to be cleaned up, singly linked via their
1681 * gc headers' gc_prev pointers.
1682 */
1683 PyObject *_PyTrash_delete_later = NULL;
1684
1685 /* Add op to the _PyTrash_delete_later list. Called when the current
1686 * call-stack depth gets large. op must be a currently untracked gc'ed
1687 * object, with refcount 0. Py_DECREF must already have been called on it.
1688 */
1689 void
1690 _PyTrash_deposit_object(PyObject *op)
1691 {
1692 assert(PyObject_IS_GC(op));
1693 assert(_Py_AS_GC(op)->gc.gc_refs == _PyGC_REFS_UNTRACKED);
1694 assert(op->ob_refcnt == 0);
1695 _Py_AS_GC(op)->gc.gc_prev = (PyGC_Head *)_PyTrash_delete_later;
1696 _PyTrash_delete_later = op;
1697 }
1698
1699 /* Dealloccate all the objects in the _PyTrash_delete_later list. Called when
1700 * the call-stack unwinds again.
1701 */
1702 void
1703 _PyTrash_destroy_chain(void)
1704 {
1705 while (_PyTrash_delete_later) {
1706 PyObject *op = _PyTrash_delete_later;
1707 destructor dealloc = Py_TYPE(op)->tp_dealloc;
1708
1709 _PyTrash_delete_later =
1710 (PyObject*) _Py_AS_GC(op)->gc.gc_prev;
1711
1712 /* Call the deallocator directly. This used to try to
1713 * fool Py_DECREF into calling it indirectly, but
1714 * Py_DECREF was already called on this object, and in
1715 * assorted non-release builds calling Py_DECREF again ends
1716 * up distorting allocation statistics.
1717 */
1718 assert(op->ob_refcnt == 0);
1719 ++_PyTrash_delete_nesting;
1720 (*dealloc)(op);
1721 --_PyTrash_delete_nesting;
1722 }
1723 }
1724
1725 #ifndef Py_TRACE_REFS
1726 /* For Py_LIMITED_API, we need an out-of-line version of _Py_Dealloc.
1727 Define this here, so we can undefine the macro. */
1728 #undef _Py_Dealloc
1729 PyAPI_FUNC(void) _Py_Dealloc(PyObject *);
1730 void
1731 _Py_Dealloc(PyObject *op)
1732 {
1733 _Py_INC_TPFREES(op) _Py_COUNT_ALLOCS_COMMA
1734 (*Py_TYPE(op)->tp_dealloc)(op);
1735 }
1736 #endif
1737