blob: 832b4e90e3849591d27f1f0782aaf469fe7a5f46 [file] [log] [blame]
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00001#include "Python.h"
2#include "code.h"
3#include "structmember.h"
4
5#define NAME_CHARS \
6 "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"
7
8/* all_name_chars(s): true iff all chars in s are valid NAME_CHARS */
9
10static int
Guido van Rossum98297ee2007-11-06 21:34:58 +000011all_name_chars(Py_UNICODE *s)
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000012{
13 static char ok_name_char[256];
14 static unsigned char *name_chars = (unsigned char *)NAME_CHARS;
15
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) {
Guido van Rossum98297ee2007-11-06 21:34:58 +000022 if (*s >= 128)
23 return 0;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000024 if (ok_name_char[*s++] == 0)
25 return 0;
26 }
27 return 1;
28}
29
30static void
31intern_strings(PyObject *tuple)
32{
Martin v. Löwis18e16552006-02-15 17:27:45 +000033 Py_ssize_t i;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000034
35 for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) {
36 PyObject *v = PyTuple_GET_ITEM(tuple, i);
Martin v. Löwis5b222132007-06-10 09:51:05 +000037 if (v == NULL || !PyUnicode_CheckExact(v)) {
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000038 Py_FatalError("non-string found in code slot");
39 }
Martin v. Löwis5b222132007-06-10 09:51:05 +000040 PyUnicode_InternInPlace(&PyTuple_GET_ITEM(tuple, i));
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000041 }
42}
43
44
45PyCodeObject *
Guido van Rossum4f72a782006-10-27 23:31:49 +000046PyCode_New(int argcount, int kwonlyargcount,
47 int nlocals, int stacksize, int flags,
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000048 PyObject *code, PyObject *consts, PyObject *names,
49 PyObject *varnames, PyObject *freevars, PyObject *cellvars,
50 PyObject *filename, PyObject *name, int firstlineno,
51 PyObject *lnotab)
52{
53 PyCodeObject *co;
Martin v. Löwis18e16552006-02-15 17:27:45 +000054 Py_ssize_t i;
Guido van Rossum00bc0e02007-10-15 02:52:41 +000055
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000056 /* Check argument types */
57 if (argcount < 0 || nlocals < 0 ||
58 code == NULL ||
59 consts == NULL || !PyTuple_Check(consts) ||
60 names == NULL || !PyTuple_Check(names) ||
61 varnames == NULL || !PyTuple_Check(varnames) ||
62 freevars == NULL || !PyTuple_Check(freevars) ||
63 cellvars == NULL || !PyTuple_Check(cellvars) ||
Guido van Rossum00bc0e02007-10-15 02:52:41 +000064 name == NULL || !PyUnicode_Check(name) ||
65 filename == NULL || !PyUnicode_Check(filename) ||
Christian Heimes72b710a2008-05-26 13:28:38 +000066 lnotab == NULL || !PyBytes_Check(lnotab) ||
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000067 !PyObject_CheckReadBuffer(code)) {
68 PyErr_BadInternalCall();
69 return NULL;
70 }
71 intern_strings(names);
72 intern_strings(varnames);
73 intern_strings(freevars);
74 intern_strings(cellvars);
75 /* Intern selected string constants */
76 for (i = PyTuple_Size(consts); --i >= 0; ) {
77 PyObject *v = PyTuple_GetItem(consts, i);
Guido van Rossum98297ee2007-11-06 21:34:58 +000078 if (!PyUnicode_Check(v))
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000079 continue;
Guido van Rossum98297ee2007-11-06 21:34:58 +000080 if (!all_name_chars(PyUnicode_AS_UNICODE(v)))
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000081 continue;
Guido van Rossum98297ee2007-11-06 21:34:58 +000082 PyUnicode_InternInPlace(&PyTuple_GET_ITEM(consts, i));
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000083 }
84 co = PyObject_NEW(PyCodeObject, &PyCode_Type);
85 if (co != NULL) {
86 co->co_argcount = argcount;
Guido van Rossum4f72a782006-10-27 23:31:49 +000087 co->co_kwonlyargcount = kwonlyargcount;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000088 co->co_nlocals = nlocals;
89 co->co_stacksize = stacksize;
90 co->co_flags = flags;
91 Py_INCREF(code);
92 co->co_code = code;
93 Py_INCREF(consts);
94 co->co_consts = consts;
95 Py_INCREF(names);
96 co->co_names = names;
97 Py_INCREF(varnames);
98 co->co_varnames = varnames;
99 Py_INCREF(freevars);
100 co->co_freevars = freevars;
101 Py_INCREF(cellvars);
102 co->co_cellvars = cellvars;
103 Py_INCREF(filename);
104 co->co_filename = filename;
105 Py_INCREF(name);
106 co->co_name = name;
107 co->co_firstlineno = firstlineno;
108 Py_INCREF(lnotab);
109 co->co_lnotab = lnotab;
Thomas Wouters477c8d52006-05-27 19:21:47 +0000110 co->co_zombieframe = NULL;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000111 }
112 return co;
113}
114
115
116#define OFF(x) offsetof(PyCodeObject, x)
117
118static PyMemberDef code_memberlist[] = {
119 {"co_argcount", T_INT, OFF(co_argcount), READONLY},
Guido van Rossum4f72a782006-10-27 23:31:49 +0000120 {"co_kwonlyargcount", T_INT, OFF(co_kwonlyargcount), READONLY},
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000121 {"co_nlocals", T_INT, OFF(co_nlocals), READONLY},
122 {"co_stacksize",T_INT, OFF(co_stacksize), READONLY},
123 {"co_flags", T_INT, OFF(co_flags), READONLY},
124 {"co_code", T_OBJECT, OFF(co_code), READONLY},
125 {"co_consts", T_OBJECT, OFF(co_consts), READONLY},
126 {"co_names", T_OBJECT, OFF(co_names), READONLY},
127 {"co_varnames", T_OBJECT, OFF(co_varnames), READONLY},
128 {"co_freevars", T_OBJECT, OFF(co_freevars), READONLY},
129 {"co_cellvars", T_OBJECT, OFF(co_cellvars), READONLY},
130 {"co_filename", T_OBJECT, OFF(co_filename), READONLY},
131 {"co_name", T_OBJECT, OFF(co_name), READONLY},
132 {"co_firstlineno", T_INT, OFF(co_firstlineno), READONLY},
133 {"co_lnotab", T_OBJECT, OFF(co_lnotab), READONLY},
134 {NULL} /* Sentinel */
135};
136
137/* Helper for code_new: return a shallow copy of a tuple that is
138 guaranteed to contain exact strings, by converting string subclasses
139 to exact strings and complaining if a non-string is found. */
140static PyObject*
141validate_and_copy_tuple(PyObject *tup)
142{
143 PyObject *newtuple;
144 PyObject *item;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000145 Py_ssize_t i, len;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000146
147 len = PyTuple_GET_SIZE(tup);
148 newtuple = PyTuple_New(len);
149 if (newtuple == NULL)
150 return NULL;
151
152 for (i = 0; i < len; i++) {
153 item = PyTuple_GET_ITEM(tup, i);
Martin v. Löwis5b222132007-06-10 09:51:05 +0000154 if (PyUnicode_CheckExact(item)) {
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000155 Py_INCREF(item);
156 }
Martin v. Löwis5b222132007-06-10 09:51:05 +0000157 else if (!PyUnicode_Check(item)) {
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000158 PyErr_Format(
159 PyExc_TypeError,
160 "name tuples must contain only "
161 "strings, not '%.500s'",
162 item->ob_type->tp_name);
163 Py_DECREF(newtuple);
164 return NULL;
165 }
166 else {
Martin v. Löwis5b222132007-06-10 09:51:05 +0000167 item = PyUnicode_FromUnicode(
168 PyUnicode_AS_UNICODE(item),
169 PyUnicode_GET_SIZE(item));
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000170 if (item == NULL) {
171 Py_DECREF(newtuple);
172 return NULL;
173 }
174 }
175 PyTuple_SET_ITEM(newtuple, i, item);
176 }
177
178 return newtuple;
179}
180
181PyDoc_STRVAR(code_doc,
Georg Brandlc5605df2009-08-13 08:26:44 +0000182"code(argcount, kwonlyargcount, nlocals, stacksize, flags, codestring,\n\
Georg Brandla1e7e132008-01-26 09:39:23 +0000183 constants, names, varnames, filename, name, firstlineno,\n\
184 lnotab[, freevars[, cellvars]])\n\
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000185\n\
186Create a code object. Not for the faint of heart.");
187
188static PyObject *
189code_new(PyTypeObject *type, PyObject *args, PyObject *kw)
190{
191 int argcount;
Guido van Rossum4f72a782006-10-27 23:31:49 +0000192 int kwonlyargcount;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000193 int nlocals;
194 int stacksize;
195 int flags;
196 PyObject *co = NULL;
197 PyObject *code;
198 PyObject *consts;
199 PyObject *names, *ournames = NULL;
200 PyObject *varnames, *ourvarnames = NULL;
201 PyObject *freevars = NULL, *ourfreevars = NULL;
202 PyObject *cellvars = NULL, *ourcellvars = NULL;
203 PyObject *filename;
204 PyObject *name;
205 int firstlineno;
206 PyObject *lnotab;
207
Guido van Rossum98297ee2007-11-06 21:34:58 +0000208 if (!PyArg_ParseTuple(args, "iiiiiSO!O!O!UUiS|O!O!:code",
Guido van Rossum4f72a782006-10-27 23:31:49 +0000209 &argcount, &kwonlyargcount,
210 &nlocals, &stacksize, &flags,
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000211 &code,
212 &PyTuple_Type, &consts,
213 &PyTuple_Type, &names,
214 &PyTuple_Type, &varnames,
215 &filename, &name,
216 &firstlineno, &lnotab,
217 &PyTuple_Type, &freevars,
218 &PyTuple_Type, &cellvars))
219 return NULL;
220
221 if (argcount < 0) {
222 PyErr_SetString(
223 PyExc_ValueError,
224 "code: argcount must not be negative");
225 goto cleanup;
226 }
227
Guido van Rossum4f72a782006-10-27 23:31:49 +0000228 if (kwonlyargcount < 0) {
229 PyErr_SetString(
230 PyExc_ValueError,
231 "code: kwonlyargcount must not be negative");
232 goto cleanup;
233 }
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000234 if (nlocals < 0) {
235 PyErr_SetString(
236 PyExc_ValueError,
237 "code: nlocals must not be negative");
238 goto cleanup;
239 }
240
241 ournames = validate_and_copy_tuple(names);
242 if (ournames == NULL)
243 goto cleanup;
244 ourvarnames = validate_and_copy_tuple(varnames);
245 if (ourvarnames == NULL)
246 goto cleanup;
247 if (freevars)
248 ourfreevars = validate_and_copy_tuple(freevars);
249 else
250 ourfreevars = PyTuple_New(0);
251 if (ourfreevars == NULL)
252 goto cleanup;
253 if (cellvars)
254 ourcellvars = validate_and_copy_tuple(cellvars);
255 else
256 ourcellvars = PyTuple_New(0);
257 if (ourcellvars == NULL)
258 goto cleanup;
259
Guido van Rossum4f72a782006-10-27 23:31:49 +0000260 co = (PyObject *)PyCode_New(argcount, kwonlyargcount,
261 nlocals, stacksize, flags,
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000262 code, consts, ournames, ourvarnames,
263 ourfreevars, ourcellvars, filename,
264 name, firstlineno, lnotab);
265 cleanup:
266 Py_XDECREF(ournames);
267 Py_XDECREF(ourvarnames);
268 Py_XDECREF(ourfreevars);
269 Py_XDECREF(ourcellvars);
270 return co;
271}
272
273static void
274code_dealloc(PyCodeObject *co)
275{
276 Py_XDECREF(co->co_code);
277 Py_XDECREF(co->co_consts);
278 Py_XDECREF(co->co_names);
279 Py_XDECREF(co->co_varnames);
280 Py_XDECREF(co->co_freevars);
281 Py_XDECREF(co->co_cellvars);
282 Py_XDECREF(co->co_filename);
283 Py_XDECREF(co->co_name);
284 Py_XDECREF(co->co_lnotab);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000285 if (co->co_zombieframe != NULL)
286 PyObject_GC_Del(co->co_zombieframe);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000287 PyObject_DEL(co);
288}
289
290static PyObject *
291code_repr(PyCodeObject *co)
292{
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000293 int lineno = -1;
294 char *filename = "???";
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000295
296 if (co->co_firstlineno != 0)
297 lineno = co->co_firstlineno;
Guido van Rossum00bc0e02007-10-15 02:52:41 +0000298 if (co->co_filename && PyUnicode_Check(co->co_filename))
Marc-André Lemburg4cc0f242008-08-07 18:54:33 +0000299 filename = _PyUnicode_AsString(co->co_filename);
Walter Dörwald933daed2007-06-06 15:15:34 +0000300 return PyUnicode_FromFormat(
Neal Norwitz41103bf2007-08-24 23:12:06 +0000301 "<code object %.100U at %p, file \"%.300s\", line %d>",
302 co->co_name, co, filename, lineno);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000303}
304
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000305static PyObject *
306code_richcompare(PyObject *self, PyObject *other, int op)
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000307{
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000308 PyCodeObject *co, *cp;
309 int eq;
310 PyObject *res;
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000311
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000312 if ((op != Py_EQ && op != Py_NE) ||
313 !PyCode_Check(self) ||
314 !PyCode_Check(other)) {
315 Py_INCREF(Py_NotImplemented);
316 return Py_NotImplemented;
317 }
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000318
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000319 co = (PyCodeObject *)self;
320 cp = (PyCodeObject *)other;
321
Guido van Rossumf1624cd2006-08-24 23:43:52 +0000322 eq = PyObject_RichCompareBool(co->co_name, cp->co_name, Py_EQ);
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000323 if (eq <= 0) goto unequal;
324 eq = co->co_argcount == cp->co_argcount;
325 if (!eq) goto unequal;
Guido van Rossum4f72a782006-10-27 23:31:49 +0000326 eq = co->co_kwonlyargcount == cp->co_kwonlyargcount;
327 if (!eq) goto unequal;
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000328 eq = co->co_nlocals == cp->co_nlocals;
329 if (!eq) goto unequal;
330 eq = co->co_flags == cp->co_flags;
331 if (!eq) goto unequal;
332 eq = co->co_firstlineno == cp->co_firstlineno;
333 if (!eq) goto unequal;
Guido van Rossumf1624cd2006-08-24 23:43:52 +0000334 eq = PyObject_RichCompareBool(co->co_code, cp->co_code, Py_EQ);
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000335 if (eq <= 0) goto unequal;
Guido van Rossumf1624cd2006-08-24 23:43:52 +0000336 eq = PyObject_RichCompareBool(co->co_consts, cp->co_consts, Py_EQ);
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000337 if (eq <= 0) goto unequal;
Guido van Rossumf1624cd2006-08-24 23:43:52 +0000338 eq = PyObject_RichCompareBool(co->co_names, cp->co_names, Py_EQ);
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000339 if (eq <= 0) goto unequal;
Guido van Rossumf1624cd2006-08-24 23:43:52 +0000340 eq = PyObject_RichCompareBool(co->co_varnames, cp->co_varnames, Py_EQ);
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000341 if (eq <= 0) goto unequal;
Guido van Rossumf1624cd2006-08-24 23:43:52 +0000342 eq = PyObject_RichCompareBool(co->co_freevars, cp->co_freevars, Py_EQ);
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000343 if (eq <= 0) goto unequal;
Guido van Rossumf1624cd2006-08-24 23:43:52 +0000344 eq = PyObject_RichCompareBool(co->co_cellvars, cp->co_cellvars, Py_EQ);
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000345 if (eq <= 0) goto unequal;
346
347 if (op == Py_EQ)
348 res = Py_True;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000349 else
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000350 res = Py_False;
351 goto done;
352
353 unequal:
354 if (eq < 0)
355 return NULL;
356 if (op == Py_NE)
357 res = Py_True;
358 else
359 res = Py_False;
360
361 done:
362 Py_INCREF(res);
363 return res;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000364}
365
366static long
367code_hash(PyCodeObject *co)
368{
369 long h, h0, h1, h2, h3, h4, h5, h6;
370 h0 = PyObject_Hash(co->co_name);
371 if (h0 == -1) return -1;
372 h1 = PyObject_Hash(co->co_code);
373 if (h1 == -1) return -1;
374 h2 = PyObject_Hash(co->co_consts);
375 if (h2 == -1) return -1;
376 h3 = PyObject_Hash(co->co_names);
377 if (h3 == -1) return -1;
378 h4 = PyObject_Hash(co->co_varnames);
379 if (h4 == -1) return -1;
380 h5 = PyObject_Hash(co->co_freevars);
381 if (h5 == -1) return -1;
382 h6 = PyObject_Hash(co->co_cellvars);
383 if (h6 == -1) return -1;
384 h = h0 ^ h1 ^ h2 ^ h3 ^ h4 ^ h5 ^ h6 ^
Guido van Rossum4f72a782006-10-27 23:31:49 +0000385 co->co_argcount ^ co->co_kwonlyargcount ^
386 co->co_nlocals ^ co->co_flags;
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000387 if (h == -1) h = -2;
388 return h;
389}
390
391/* XXX code objects need to participate in GC? */
392
393PyTypeObject PyCode_Type = {
Martin v. Löwis9f2e3462007-07-21 17:22:18 +0000394 PyVarObject_HEAD_INIT(&PyType_Type, 0)
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000395 "code",
396 sizeof(PyCodeObject),
397 0,
398 (destructor)code_dealloc, /* tp_dealloc */
399 0, /* tp_print */
400 0, /* tp_getattr */
401 0, /* tp_setattr */
Mark Dickinsone94c6792009-02-02 20:36:42 +0000402 0, /* tp_reserved */
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000403 (reprfunc)code_repr, /* tp_repr */
404 0, /* tp_as_number */
405 0, /* tp_as_sequence */
406 0, /* tp_as_mapping */
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000407 (hashfunc)code_hash, /* tp_hash */
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000408 0, /* tp_call */
409 0, /* tp_str */
410 PyObject_GenericGetAttr, /* tp_getattro */
411 0, /* tp_setattro */
412 0, /* tp_as_buffer */
413 Py_TPFLAGS_DEFAULT, /* tp_flags */
414 code_doc, /* tp_doc */
415 0, /* tp_traverse */
416 0, /* tp_clear */
Guido van Rossumb6bb0c72006-08-24 04:12:18 +0000417 code_richcompare, /* tp_richcompare */
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000418 0, /* tp_weaklistoffset */
419 0, /* tp_iter */
420 0, /* tp_iternext */
421 0, /* tp_methods */
422 code_memberlist, /* tp_members */
423 0, /* tp_getset */
424 0, /* tp_base */
425 0, /* tp_dict */
426 0, /* tp_descr_get */
427 0, /* tp_descr_set */
428 0, /* tp_dictoffset */
429 0, /* tp_init */
430 0, /* tp_alloc */
431 code_new, /* tp_new */
432};
433
434/* All about c_lnotab.
435
436c_lnotab is an array of unsigned bytes disguised as a Python string. In -O
437mode, SET_LINENO opcodes aren't generated, and bytecode offsets are mapped
438to source code line #s (when needed for tracebacks) via c_lnotab instead.
439The array is conceptually a list of
440 (bytecode offset increment, line number increment)
441pairs. The details are important and delicate, best illustrated by example:
442
443 byte code offset source code line number
444 0 1
445 6 2
446 50 7
447 350 307
448 361 308
449
450The first trick is that these numbers aren't stored, only the increments
451from one row to the next (this doesn't really work, but it's a start):
452
453 0, 1, 6, 1, 44, 5, 300, 300, 11, 1
454
455The second trick is that an unsigned byte can't hold negative values, or
456values larger than 255, so (a) there's a deep assumption that byte code
457offsets and their corresponding line #s both increase monotonically, and (b)
458if at least one column jumps by more than 255 from one row to the next, more
459than one pair is written to the table. In case #b, there's no way to know
460from looking at the table later how many were written. That's the delicate
461part. A user of c_lnotab desiring to find the source line number
462corresponding to a bytecode address A should do something like this
463
464 lineno = addr = 0
465 for addr_incr, line_incr in c_lnotab:
466 addr += addr_incr
467 if addr > A:
468 return lineno
469 lineno += line_incr
470
471In order for this to work, when the addr field increments by more than 255,
472the line # increment in each pair generated must be 0 until the remaining addr
473increment is < 256. So, in the example above, com_set_lineno should not (as
474was actually done until 2.2) expand 300, 300 to 255, 255, 45, 45, but to
475255, 0, 45, 255, 0, 45.
476*/
477
478int
479PyCode_Addr2Line(PyCodeObject *co, int addrq)
480{
Christian Heimes72b710a2008-05-26 13:28:38 +0000481 int size = PyBytes_Size(co->co_lnotab) / 2;
482 unsigned char *p = (unsigned char*)PyBytes_AsString(co->co_lnotab);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000483 int line = co->co_firstlineno;
484 int addr = 0;
485 while (--size >= 0) {
486 addr += *p++;
487 if (addr > addrq)
488 break;
489 line += *p++;
490 }
491 return line;
492}
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000493
494/*
495 Check whether the current instruction is at the start of a line.
496
497 */
498
499 /* The theory of SET_LINENO-less tracing.
500
501 In a nutshell, we use the co_lnotab field of the code object
502 to tell when execution has moved onto a different line.
503
504 As mentioned above, the basic idea is so set things up so
505 that
506
507 *instr_lb <= frame->f_lasti < *instr_ub
508
509 is true so long as execution does not change lines.
510
511 This is all fairly simple. Digging the information out of
512 co_lnotab takes some work, but is conceptually clear.
513
514 Somewhat harder to explain is why we don't *always* call the
515 line trace function when the above test fails.
516
517 Consider this code:
518
519 1: def f(a):
520 2: if a:
521 3: print 1
522 4: else:
523 5: print 2
524
525 which compiles to this:
526
527 2 0 LOAD_FAST 0 (a)
528 3 JUMP_IF_FALSE 9 (to 15)
529 6 POP_TOP
530
531 3 7 LOAD_CONST 1 (1)
532 10 PRINT_ITEM
533 11 PRINT_NEWLINE
534 12 JUMP_FORWARD 6 (to 21)
535 >> 15 POP_TOP
536
537 5 16 LOAD_CONST 2 (2)
538 19 PRINT_ITEM
539 20 PRINT_NEWLINE
540 >> 21 LOAD_CONST 0 (None)
541 24 RETURN_VALUE
542
543 If 'a' is false, execution will jump to instruction at offset
544 15 and the co_lnotab will claim that execution has moved to
545 line 3. This is at best misleading. In this case we could
546 associate the POP_TOP with line 4, but that doesn't make
547 sense in all cases (I think).
548
549 What we do is only call the line trace function if the co_lnotab
550 indicates we have jumped to the *start* of a line, i.e. if the
551 current instruction offset matches the offset given for the
552 start of a line by the co_lnotab.
553
554 This also takes care of the situation where 'a' is true.
555 Execution will jump from instruction offset 12 to offset 21.
556 Then the co_lnotab would imply that execution has moved to line
557 5, which is again misleading.
558
559 Why do we set f_lineno when tracing? Well, consider the code
560 above when 'a' is true. If stepping through this with 'n' in
561 pdb, you would stop at line 1 with a "call" type event, then
562 line events on lines 2 and 3, then a "return" type event -- but
563 you would be shown line 5 during this event. This is a change
564 from the behaviour in 2.2 and before, and I've found it
565 confusing in practice. By setting and using f_lineno when
566 tracing, one can report a line number different from that
567 suggested by f_lasti on this one occasion where it's desirable.
568 */
569
570
571int
572PyCode_CheckLineNumber(PyCodeObject* co, int lasti, PyAddrPair *bounds)
573{
574 int size, addr, line;
575 unsigned char* p;
576
Christian Heimes72b710a2008-05-26 13:28:38 +0000577 p = (unsigned char*)PyBytes_AS_STRING(co->co_lnotab);
578 size = PyBytes_GET_SIZE(co->co_lnotab) / 2;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000579
580 addr = 0;
581 line = co->co_firstlineno;
582 assert(line > 0);
583
584 /* possible optimization: if f->f_lasti == instr_ub
585 (likely to be a common case) then we already know
586 instr_lb -- if we stored the matching value of p
587 somwhere we could skip the first while loop. */
588
589 /* see comments in compile.c for the description of
590 co_lnotab. A point to remember: increments to p
591 should come in pairs -- although we don't care about
592 the line increments here, treating them as byte
593 increments gets confusing, to say the least. */
594
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000595 bounds->ap_lower = 0;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000596 while (size > 0) {
597 if (addr + *p > lasti)
598 break;
599 addr += *p++;
600 if (*p)
601 bounds->ap_lower = addr;
602 line += *p++;
603 --size;
604 }
605
606 /* If lasti and addr don't match exactly, we don't want to
607 change the lineno slot on the frame or execute a trace
608 function. Return -1 instead.
609 */
610 if (addr != lasti)
611 line = -1;
612
613 if (size > 0) {
614 while (--size >= 0) {
615 addr += *p++;
616 if (*p++)
617 break;
618 }
619 bounds->ap_upper = addr;
620 }
621 else {
622 bounds->ap_upper = INT_MAX;
623 }
624
625 return line;
626}