source: python/trunk/Objects/codeobject.c

Last change on this file was 391, checked in by dmik, 11 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 18.2 KB
RevLine 
[2]1#include "Python.h"
2#include "code.h"
3#include "structmember.h"
4
5#define NAME_CHARS \
[391]6 "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"
[2]7
8/* all_name_chars(s): true iff all chars in s are valid NAME_CHARS */
9
10static int
11all_name_chars(unsigned char *s)
12{
[391]13 static char ok_name_char[256];
14 static unsigned char *name_chars = (unsigned char *)NAME_CHARS;
[2]15
[391]16 if (ok_name_char[*name_chars] == 0) {
17 unsigned char *p;
18 for (p = name_chars; *p; p++)
19 ok_name_char[*p] = 1;
20 }
21 while (*s) {
22 if (ok_name_char[*s++] == 0)
23 return 0;
24 }
25 return 1;
[2]26}
27
28static void
29intern_strings(PyObject *tuple)
30{
[391]31 Py_ssize_t i;
[2]32
[391]33 for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) {
34 PyObject *v = PyTuple_GET_ITEM(tuple, i);
35 if (v == NULL || !PyString_CheckExact(v)) {
36 Py_FatalError("non-string found in code slot");
37 }
38 PyString_InternInPlace(&PyTuple_GET_ITEM(tuple, i));
39 }
[2]40}
41
42
43PyCodeObject *
44PyCode_New(int argcount, int nlocals, int stacksize, int flags,
[391]45 PyObject *code, PyObject *consts, PyObject *names,
46 PyObject *varnames, PyObject *freevars, PyObject *cellvars,
47 PyObject *filename, PyObject *name, int firstlineno,
48 PyObject *lnotab)
[2]49{
[391]50 PyCodeObject *co;
51 Py_ssize_t i;
52 /* Check argument types */
53 if (argcount < 0 || nlocals < 0 ||
54 code == NULL ||
55 consts == NULL || !PyTuple_Check(consts) ||
56 names == NULL || !PyTuple_Check(names) ||
57 varnames == NULL || !PyTuple_Check(varnames) ||
58 freevars == NULL || !PyTuple_Check(freevars) ||
59 cellvars == NULL || !PyTuple_Check(cellvars) ||
60 name == NULL || !PyString_Check(name) ||
61 filename == NULL || !PyString_Check(filename) ||
62 lnotab == NULL || !PyString_Check(lnotab) ||
63 !PyObject_CheckReadBuffer(code)) {
64 PyErr_BadInternalCall();
65 return NULL;
66 }
67 intern_strings(names);
68 intern_strings(varnames);
69 intern_strings(freevars);
70 intern_strings(cellvars);
71 /* Intern selected string constants */
72 for (i = PyTuple_Size(consts); --i >= 0; ) {
73 PyObject *v = PyTuple_GetItem(consts, i);
74 if (!PyString_Check(v))
75 continue;
76 if (!all_name_chars((unsigned char *)PyString_AS_STRING(v)))
77 continue;
78 PyString_InternInPlace(&PyTuple_GET_ITEM(consts, i));
79 }
80 co = PyObject_NEW(PyCodeObject, &PyCode_Type);
81 if (co != NULL) {
82 co->co_argcount = argcount;
83 co->co_nlocals = nlocals;
84 co->co_stacksize = stacksize;
85 co->co_flags = flags;
86 Py_INCREF(code);
87 co->co_code = code;
88 Py_INCREF(consts);
89 co->co_consts = consts;
90 Py_INCREF(names);
91 co->co_names = names;
92 Py_INCREF(varnames);
93 co->co_varnames = varnames;
94 Py_INCREF(freevars);
95 co->co_freevars = freevars;
96 Py_INCREF(cellvars);
97 co->co_cellvars = cellvars;
98 Py_INCREF(filename);
99 co->co_filename = filename;
100 Py_INCREF(name);
101 co->co_name = name;
102 co->co_firstlineno = firstlineno;
103 Py_INCREF(lnotab);
104 co->co_lnotab = lnotab;
105 co->co_zombieframe = NULL;
106 co->co_weakreflist = NULL;
107 }
108 return co;
[2]109}
110
[391]111PyCodeObject *
112PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno)
113{
114 static PyObject *emptystring = NULL;
115 static PyObject *nulltuple = NULL;
116 PyObject *filename_ob = NULL;
117 PyObject *funcname_ob = NULL;
118 PyCodeObject *result = NULL;
119 if (emptystring == NULL) {
120 emptystring = PyString_FromString("");
121 if (emptystring == NULL)
122 goto failed;
123 }
124 if (nulltuple == NULL) {
125 nulltuple = PyTuple_New(0);
126 if (nulltuple == NULL)
127 goto failed;
128 }
129 funcname_ob = PyString_FromString(funcname);
130 if (funcname_ob == NULL)
131 goto failed;
132 filename_ob = PyString_FromString(filename);
133 if (filename_ob == NULL)
134 goto failed;
[2]135
[391]136 result = PyCode_New(0, /* argcount */
137 0, /* nlocals */
138 0, /* stacksize */
139 0, /* flags */
140 emptystring, /* code */
141 nulltuple, /* consts */
142 nulltuple, /* names */
143 nulltuple, /* varnames */
144 nulltuple, /* freevars */
145 nulltuple, /* cellvars */
146 filename_ob, /* filename */
147 funcname_ob, /* name */
148 firstlineno, /* firstlineno */
149 emptystring /* lnotab */
150 );
151
152failed:
153 Py_XDECREF(funcname_ob);
154 Py_XDECREF(filename_ob);
155 return result;
156}
157
[2]158#define OFF(x) offsetof(PyCodeObject, x)
159
160static PyMemberDef code_memberlist[] = {
[391]161 {"co_argcount", T_INT, OFF(co_argcount), READONLY},
162 {"co_nlocals", T_INT, OFF(co_nlocals), READONLY},
163 {"co_stacksize",T_INT, OFF(co_stacksize), READONLY},
164 {"co_flags", T_INT, OFF(co_flags), READONLY},
165 {"co_code", T_OBJECT, OFF(co_code), READONLY},
166 {"co_consts", T_OBJECT, OFF(co_consts), READONLY},
167 {"co_names", T_OBJECT, OFF(co_names), READONLY},
168 {"co_varnames", T_OBJECT, OFF(co_varnames), READONLY},
169 {"co_freevars", T_OBJECT, OFF(co_freevars), READONLY},
170 {"co_cellvars", T_OBJECT, OFF(co_cellvars), READONLY},
171 {"co_filename", T_OBJECT, OFF(co_filename), READONLY},
172 {"co_name", T_OBJECT, OFF(co_name), READONLY},
173 {"co_firstlineno", T_INT, OFF(co_firstlineno), READONLY},
174 {"co_lnotab", T_OBJECT, OFF(co_lnotab), READONLY},
175 {NULL} /* Sentinel */
[2]176};
177
178/* Helper for code_new: return a shallow copy of a tuple that is
179 guaranteed to contain exact strings, by converting string subclasses
180 to exact strings and complaining if a non-string is found. */
181static PyObject*
182validate_and_copy_tuple(PyObject *tup)
183{
[391]184 PyObject *newtuple;
185 PyObject *item;
186 Py_ssize_t i, len;
[2]187
[391]188 len = PyTuple_GET_SIZE(tup);
189 newtuple = PyTuple_New(len);
190 if (newtuple == NULL)
191 return NULL;
[2]192
[391]193 for (i = 0; i < len; i++) {
194 item = PyTuple_GET_ITEM(tup, i);
195 if (PyString_CheckExact(item)) {
196 Py_INCREF(item);
197 }
198 else if (!PyString_Check(item)) {
199 PyErr_Format(
200 PyExc_TypeError,
201 "name tuples must contain only "
202 "strings, not '%.500s'",
203 item->ob_type->tp_name);
204 Py_DECREF(newtuple);
205 return NULL;
206 }
207 else {
208 item = PyString_FromStringAndSize(
209 PyString_AS_STRING(item),
210 PyString_GET_SIZE(item));
211 if (item == NULL) {
212 Py_DECREF(newtuple);
213 return NULL;
214 }
215 }
216 PyTuple_SET_ITEM(newtuple, i, item);
217 }
[2]218
[391]219 return newtuple;
[2]220}
221
222PyDoc_STRVAR(code_doc,
223"code(argcount, nlocals, stacksize, flags, codestring, constants, names,\n\
224 varnames, filename, name, firstlineno, lnotab[, freevars[, cellvars]])\n\
225\n\
226Create a code object. Not for the faint of heart.");
227
228static PyObject *
229code_new(PyTypeObject *type, PyObject *args, PyObject *kw)
230{
[391]231 int argcount;
232 int nlocals;
233 int stacksize;
234 int flags;
235 PyObject *co = NULL;
236 PyObject *code;
237 PyObject *consts;
238 PyObject *names, *ournames = NULL;
239 PyObject *varnames, *ourvarnames = NULL;
240 PyObject *freevars = NULL, *ourfreevars = NULL;
241 PyObject *cellvars = NULL, *ourcellvars = NULL;
242 PyObject *filename;
243 PyObject *name;
244 int firstlineno;
245 PyObject *lnotab;
[2]246
[391]247 if (!PyArg_ParseTuple(args, "iiiiSO!O!O!SSiS|O!O!:code",
248 &argcount, &nlocals, &stacksize, &flags,
249 &code,
250 &PyTuple_Type, &consts,
251 &PyTuple_Type, &names,
252 &PyTuple_Type, &varnames,
253 &filename, &name,
254 &firstlineno, &lnotab,
255 &PyTuple_Type, &freevars,
256 &PyTuple_Type, &cellvars))
257 return NULL;
[2]258
[391]259 if (argcount < 0) {
260 PyErr_SetString(
261 PyExc_ValueError,
262 "code: argcount must not be negative");
263 goto cleanup;
264 }
[2]265
[391]266 if (nlocals < 0) {
267 PyErr_SetString(
268 PyExc_ValueError,
269 "code: nlocals must not be negative");
270 goto cleanup;
271 }
[2]272
[391]273 ournames = validate_and_copy_tuple(names);
274 if (ournames == NULL)
275 goto cleanup;
276 ourvarnames = validate_and_copy_tuple(varnames);
277 if (ourvarnames == NULL)
278 goto cleanup;
279 if (freevars)
280 ourfreevars = validate_and_copy_tuple(freevars);
281 else
282 ourfreevars = PyTuple_New(0);
283 if (ourfreevars == NULL)
284 goto cleanup;
285 if (cellvars)
286 ourcellvars = validate_and_copy_tuple(cellvars);
287 else
288 ourcellvars = PyTuple_New(0);
289 if (ourcellvars == NULL)
290 goto cleanup;
[2]291
[391]292 co = (PyObject *)PyCode_New(argcount, nlocals, stacksize, flags,
293 code, consts, ournames, ourvarnames,
294 ourfreevars, ourcellvars, filename,
295 name, firstlineno, lnotab);
[2]296 cleanup:
[391]297 Py_XDECREF(ournames);
298 Py_XDECREF(ourvarnames);
299 Py_XDECREF(ourfreevars);
300 Py_XDECREF(ourcellvars);
301 return co;
[2]302}
303
304static void
305code_dealloc(PyCodeObject *co)
306{
[391]307 Py_XDECREF(co->co_code);
308 Py_XDECREF(co->co_consts);
309 Py_XDECREF(co->co_names);
310 Py_XDECREF(co->co_varnames);
311 Py_XDECREF(co->co_freevars);
312 Py_XDECREF(co->co_cellvars);
313 Py_XDECREF(co->co_filename);
314 Py_XDECREF(co->co_name);
315 Py_XDECREF(co->co_lnotab);
316 if (co->co_zombieframe != NULL)
317 PyObject_GC_Del(co->co_zombieframe);
318 if (co->co_weakreflist != NULL)
319 PyObject_ClearWeakRefs((PyObject*)co);
320 PyObject_DEL(co);
[2]321}
322
323static PyObject *
324code_repr(PyCodeObject *co)
325{
[391]326 char buf[500];
327 int lineno = -1;
328 char *filename = "???";
329 char *name = "???";
[2]330
[391]331 if (co->co_firstlineno != 0)
332 lineno = co->co_firstlineno;
333 if (co->co_filename && PyString_Check(co->co_filename))
334 filename = PyString_AS_STRING(co->co_filename);
335 if (co->co_name && PyString_Check(co->co_name))
336 name = PyString_AS_STRING(co->co_name);
337 PyOS_snprintf(buf, sizeof(buf),
338 "<code object %.100s at %p, file \"%.300s\", line %d>",
339 name, co, filename, lineno);
340 return PyString_FromString(buf);
[2]341}
342
343static int
344code_compare(PyCodeObject *co, PyCodeObject *cp)
345{
[391]346 int cmp;
347 cmp = PyObject_Compare(co->co_name, cp->co_name);
348 if (cmp) return cmp;
349 cmp = co->co_argcount - cp->co_argcount;
350 if (cmp) goto normalize;
351 cmp = co->co_nlocals - cp->co_nlocals;
352 if (cmp) goto normalize;
353 cmp = co->co_flags - cp->co_flags;
354 if (cmp) goto normalize;
355 cmp = co->co_firstlineno - cp->co_firstlineno;
356 if (cmp) goto normalize;
357 cmp = PyObject_Compare(co->co_code, cp->co_code);
358 if (cmp) return cmp;
359 cmp = PyObject_Compare(co->co_consts, cp->co_consts);
360 if (cmp) return cmp;
361 cmp = PyObject_Compare(co->co_names, cp->co_names);
362 if (cmp) return cmp;
363 cmp = PyObject_Compare(co->co_varnames, cp->co_varnames);
364 if (cmp) return cmp;
365 cmp = PyObject_Compare(co->co_freevars, cp->co_freevars);
366 if (cmp) return cmp;
367 cmp = PyObject_Compare(co->co_cellvars, cp->co_cellvars);
368 return cmp;
[2]369
370 normalize:
[391]371 if (cmp > 0)
372 return 1;
373 else if (cmp < 0)
374 return -1;
375 else
376 return 0;
[2]377}
378
379static PyObject *
380code_richcompare(PyObject *self, PyObject *other, int op)
381{
[391]382 PyCodeObject *co, *cp;
383 int eq;
384 PyObject *res;
[2]385
[391]386 if ((op != Py_EQ && op != Py_NE) ||
387 !PyCode_Check(self) ||
388 !PyCode_Check(other)) {
[2]389
[391]390 /* Py3K warning if types are not equal and comparison
391 isn't == or != */
392 if (PyErr_WarnPy3k("code inequality comparisons not supported "
393 "in 3.x", 1) < 0) {
394 return NULL;
395 }
[2]396
[391]397 Py_INCREF(Py_NotImplemented);
398 return Py_NotImplemented;
399 }
[2]400
[391]401 co = (PyCodeObject *)self;
402 cp = (PyCodeObject *)other;
[2]403
[391]404 eq = PyObject_RichCompareBool(co->co_name, cp->co_name, Py_EQ);
405 if (eq <= 0) goto unequal;
406 eq = co->co_argcount == cp->co_argcount;
407 if (!eq) goto unequal;
408 eq = co->co_nlocals == cp->co_nlocals;
409 if (!eq) goto unequal;
410 eq = co->co_flags == cp->co_flags;
411 if (!eq) goto unequal;
412 eq = co->co_firstlineno == cp->co_firstlineno;
413 if (!eq) goto unequal;
414 eq = PyObject_RichCompareBool(co->co_code, cp->co_code, Py_EQ);
415 if (eq <= 0) goto unequal;
416 eq = PyObject_RichCompareBool(co->co_consts, cp->co_consts, Py_EQ);
417 if (eq <= 0) goto unequal;
418 eq = PyObject_RichCompareBool(co->co_names, cp->co_names, Py_EQ);
419 if (eq <= 0) goto unequal;
420 eq = PyObject_RichCompareBool(co->co_varnames, cp->co_varnames, Py_EQ);
421 if (eq <= 0) goto unequal;
422 eq = PyObject_RichCompareBool(co->co_freevars, cp->co_freevars, Py_EQ);
423 if (eq <= 0) goto unequal;
424 eq = PyObject_RichCompareBool(co->co_cellvars, cp->co_cellvars, Py_EQ);
425 if (eq <= 0) goto unequal;
[2]426
[391]427 if (op == Py_EQ)
428 res = Py_True;
429 else
430 res = Py_False;
431 goto done;
[2]432
433 unequal:
[391]434 if (eq < 0)
435 return NULL;
436 if (op == Py_NE)
437 res = Py_True;
438 else
439 res = Py_False;
[2]440
441 done:
[391]442 Py_INCREF(res);
443 return res;
[2]444}
445
446static long
447code_hash(PyCodeObject *co)
448{
[391]449 long h, h0, h1, h2, h3, h4, h5, h6;
450 h0 = PyObject_Hash(co->co_name);
451 if (h0 == -1) return -1;
452 h1 = PyObject_Hash(co->co_code);
453 if (h1 == -1) return -1;
454 h2 = PyObject_Hash(co->co_consts);
455 if (h2 == -1) return -1;
456 h3 = PyObject_Hash(co->co_names);
457 if (h3 == -1) return -1;
458 h4 = PyObject_Hash(co->co_varnames);
459 if (h4 == -1) return -1;
460 h5 = PyObject_Hash(co->co_freevars);
461 if (h5 == -1) return -1;
462 h6 = PyObject_Hash(co->co_cellvars);
463 if (h6 == -1) return -1;
464 h = h0 ^ h1 ^ h2 ^ h3 ^ h4 ^ h5 ^ h6 ^
465 co->co_argcount ^ co->co_nlocals ^ co->co_flags;
466 if (h == -1) h = -2;
467 return h;
[2]468}
469
470/* XXX code objects need to participate in GC? */
471
472PyTypeObject PyCode_Type = {
[391]473 PyVarObject_HEAD_INIT(&PyType_Type, 0)
474 "code",
475 sizeof(PyCodeObject),
476 0,
477 (destructor)code_dealloc, /* tp_dealloc */
478 0, /* tp_print */
479 0, /* tp_getattr */
480 0, /* tp_setattr */
481 (cmpfunc)code_compare, /* tp_compare */
482 (reprfunc)code_repr, /* tp_repr */
483 0, /* tp_as_number */
484 0, /* tp_as_sequence */
485 0, /* tp_as_mapping */
486 (hashfunc)code_hash, /* tp_hash */
487 0, /* tp_call */
488 0, /* tp_str */
489 PyObject_GenericGetAttr, /* tp_getattro */
490 0, /* tp_setattro */
491 0, /* tp_as_buffer */
492 Py_TPFLAGS_DEFAULT, /* tp_flags */
493 code_doc, /* tp_doc */
494 0, /* tp_traverse */
495 0, /* tp_clear */
496 code_richcompare, /* tp_richcompare */
497 offsetof(PyCodeObject, co_weakreflist), /* tp_weaklistoffset */
498 0, /* tp_iter */
499 0, /* tp_iternext */
500 0, /* tp_methods */
501 code_memberlist, /* tp_members */
502 0, /* tp_getset */
503 0, /* tp_base */
504 0, /* tp_dict */
505 0, /* tp_descr_get */
506 0, /* tp_descr_set */
507 0, /* tp_dictoffset */
508 0, /* tp_init */
509 0, /* tp_alloc */
510 code_new, /* tp_new */
[2]511};
512
[391]513/* Use co_lnotab to compute the line number from a bytecode index, addrq. See
514 lnotab_notes.txt for the details of the lnotab representation.
[2]515*/
516
517int
518PyCode_Addr2Line(PyCodeObject *co, int addrq)
519{
[391]520 int size = PyString_Size(co->co_lnotab) / 2;
521 unsigned char *p = (unsigned char*)PyString_AsString(co->co_lnotab);
522 int line = co->co_firstlineno;
523 int addr = 0;
524 while (--size >= 0) {
525 addr += *p++;
526 if (addr > addrq)
527 break;
528 line += *p++;
529 }
530 return line;
[2]531}
532
[391]533/* Update *bounds to describe the first and one-past-the-last instructions in
534 the same line as lasti. Return the number of that line. */
535int
536_PyCode_CheckLineNumber(PyCodeObject* co, int lasti, PyAddrPair *bounds)
[2]537{
[391]538 int size, addr, line;
539 unsigned char* p;
[2]540
[391]541 p = (unsigned char*)PyString_AS_STRING(co->co_lnotab);
542 size = PyString_GET_SIZE(co->co_lnotab) / 2;
[2]543
[391]544 addr = 0;
545 line = co->co_firstlineno;
546 assert(line > 0);
[2]547
[391]548 /* possible optimization: if f->f_lasti == instr_ub
549 (likely to be a common case) then we already know
550 instr_lb -- if we stored the matching value of p
551 somwhere we could skip the first while loop. */
[2]552
[391]553 /* See lnotab_notes.txt for the description of
554 co_lnotab. A point to remember: increments to p
555 come in (addr, line) pairs. */
[2]556
[391]557 bounds->ap_lower = 0;
558 while (size > 0) {
559 if (addr + *p > lasti)
560 break;
561 addr += *p++;
562 if (*p)
563 bounds->ap_lower = addr;
564 line += *p++;
565 --size;
566 }
[2]567
[391]568 if (size > 0) {
569 while (--size >= 0) {
570 addr += *p++;
571 if (*p++)
572 break;
[2]573 }
[391]574 bounds->ap_upper = addr;
575 }
576 else {
577 bounds->ap_upper = INT_MAX;
578 }
[2]579
[391]580 return line;
[2]581}
Note: See TracBrowser for help on using the repository browser.