Mercurial > cpython-lru_cache-weakref
annotate Objects/codeobject.c @ 49955:878d40468c4e legacy-trunk
Issue #4384: Added logging integration with warnings module using captureWarnings(). This change includes a NullHandler which does nothing; it will be of use to library developers who want to avoid the "No handlers could be found for logger XXX" message which can appear if the library user doesn't configure logging.
| author | Vinay Sajip <vinay_sajip@yahoo.co.uk> |
|---|---|
| date | Wed, 03 Dec 2008 23:22:58 +0000 |
| parents | 52294af4b663 |
| children | e38335d4df91 a171048daf76 |
| rev | line source |
|---|---|
| 35742 | 1 #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 | |
| 10 static int | |
| 11 all_name_chars(unsigned char *s) | |
| 12 { | |
| 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) { | |
| 22 if (ok_name_char[*s++] == 0) | |
| 23 return 0; | |
| 24 } | |
| 25 return 1; | |
| 26 } | |
| 27 | |
| 28 static void | |
| 29 intern_strings(PyObject *tuple) | |
| 30 { | |
|
36501
7fdc639bc5b4
Merge ssize_t branch.
Martin v. Löwis <martin@v.loewis.de>
parents:
35742
diff
changeset
|
31 Py_ssize_t i; |
| 35742 | 32 |
| 33 for (i = PyTuple_GET_SIZE(tuple); --i >= 0; ) { | |
| 34 PyObject *v = PyTuple_GET_ITEM(tuple, i); | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
35 if (v == NULL || !PyString_CheckExact(v)) { |
| 35742 | 36 Py_FatalError("non-string found in code slot"); |
| 37 } | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
38 PyString_InternInPlace(&PyTuple_GET_ITEM(tuple, i)); |
| 35742 | 39 } |
| 40 } | |
| 41 | |
| 42 | |
| 43 PyCodeObject * | |
| 44 PyCode_New(int argcount, int nlocals, int stacksize, int flags, | |
| 45 PyObject *code, PyObject *consts, PyObject *names, | |
| 46 PyObject *varnames, PyObject *freevars, PyObject *cellvars, | |
| 47 PyObject *filename, PyObject *name, int firstlineno, | |
| 48 PyObject *lnotab) | |
| 49 { | |
| 50 PyCodeObject *co; | |
|
36501
7fdc639bc5b4
Merge ssize_t branch.
Martin v. Löwis <martin@v.loewis.de>
parents:
35742
diff
changeset
|
51 Py_ssize_t i; |
| 35742 | 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) || | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
60 name == NULL || !PyString_Check(name) || |
|
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
61 filename == NULL || !PyString_Check(filename) || |
|
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
62 lnotab == NULL || !PyString_Check(lnotab) || |
| 35742 | 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); | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
74 if (!PyString_Check(v)) |
| 35742 | 75 continue; |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
76 if (!all_name_chars((unsigned char *)PyString_AS_STRING(v))) |
| 35742 | 77 continue; |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
78 PyString_InternInPlace(&PyTuple_GET_ITEM(consts, i)); |
| 35742 | 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; | |
|
38244
a637c78bf119
Merge from rjones-funccall branch.
Richard Jones <richard@commonground.com.au>
parents:
37838
diff
changeset
|
105 co->co_zombieframe = NULL; |
| 35742 | 106 } |
| 107 return co; | |
| 108 } | |
| 109 | |
| 110 | |
| 111 #define OFF(x) offsetof(PyCodeObject, x) | |
| 112 | |
| 113 static PyMemberDef code_memberlist[] = { | |
| 114 {"co_argcount", T_INT, OFF(co_argcount), READONLY}, | |
| 115 {"co_nlocals", T_INT, OFF(co_nlocals), READONLY}, | |
| 116 {"co_stacksize",T_INT, OFF(co_stacksize), READONLY}, | |
| 117 {"co_flags", T_INT, OFF(co_flags), READONLY}, | |
| 118 {"co_code", T_OBJECT, OFF(co_code), READONLY}, | |
| 119 {"co_consts", T_OBJECT, OFF(co_consts), READONLY}, | |
| 120 {"co_names", T_OBJECT, OFF(co_names), READONLY}, | |
| 121 {"co_varnames", T_OBJECT, OFF(co_varnames), READONLY}, | |
| 122 {"co_freevars", T_OBJECT, OFF(co_freevars), READONLY}, | |
| 123 {"co_cellvars", T_OBJECT, OFF(co_cellvars), READONLY}, | |
| 124 {"co_filename", T_OBJECT, OFF(co_filename), READONLY}, | |
| 125 {"co_name", T_OBJECT, OFF(co_name), READONLY}, | |
| 126 {"co_firstlineno", T_INT, OFF(co_firstlineno), READONLY}, | |
| 127 {"co_lnotab", T_OBJECT, OFF(co_lnotab), READONLY}, | |
| 128 {NULL} /* Sentinel */ | |
| 129 }; | |
| 130 | |
| 131 /* Helper for code_new: return a shallow copy of a tuple that is | |
| 132 guaranteed to contain exact strings, by converting string subclasses | |
| 133 to exact strings and complaining if a non-string is found. */ | |
| 134 static PyObject* | |
| 135 validate_and_copy_tuple(PyObject *tup) | |
| 136 { | |
| 137 PyObject *newtuple; | |
| 138 PyObject *item; | |
|
36501
7fdc639bc5b4
Merge ssize_t branch.
Martin v. Löwis <martin@v.loewis.de>
parents:
35742
diff
changeset
|
139 Py_ssize_t i, len; |
| 35742 | 140 |
| 141 len = PyTuple_GET_SIZE(tup); | |
| 142 newtuple = PyTuple_New(len); | |
| 143 if (newtuple == NULL) | |
| 144 return NULL; | |
| 145 | |
| 146 for (i = 0; i < len; i++) { | |
| 147 item = PyTuple_GET_ITEM(tup, i); | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
148 if (PyString_CheckExact(item)) { |
| 35742 | 149 Py_INCREF(item); |
| 150 } | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
151 else if (!PyString_Check(item)) { |
| 35742 | 152 PyErr_Format( |
| 153 PyExc_TypeError, | |
| 154 "name tuples must contain only " | |
| 155 "strings, not '%.500s'", | |
| 156 item->ob_type->tp_name); | |
| 157 Py_DECREF(newtuple); | |
| 158 return NULL; | |
| 159 } | |
| 160 else { | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
161 item = PyString_FromStringAndSize( |
|
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
162 PyString_AS_STRING(item), |
|
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
163 PyString_GET_SIZE(item)); |
| 35742 | 164 if (item == NULL) { |
| 165 Py_DECREF(newtuple); | |
| 166 return NULL; | |
| 167 } | |
| 168 } | |
| 169 PyTuple_SET_ITEM(newtuple, i, item); | |
| 170 } | |
| 171 | |
| 172 return newtuple; | |
| 173 } | |
| 174 | |
| 175 PyDoc_STRVAR(code_doc, | |
| 176 "code(argcount, nlocals, stacksize, flags, codestring, constants, names,\n\ | |
| 177 varnames, filename, name, firstlineno, lnotab[, freevars[, cellvars]])\n\ | |
| 178 \n\ | |
| 179 Create a code object. Not for the faint of heart."); | |
| 180 | |
| 181 static PyObject * | |
| 182 code_new(PyTypeObject *type, PyObject *args, PyObject *kw) | |
| 183 { | |
| 184 int argcount; | |
| 185 int nlocals; | |
| 186 int stacksize; | |
| 187 int flags; | |
| 188 PyObject *co = NULL; | |
| 189 PyObject *code; | |
| 190 PyObject *consts; | |
| 191 PyObject *names, *ournames = NULL; | |
| 192 PyObject *varnames, *ourvarnames = NULL; | |
| 193 PyObject *freevars = NULL, *ourfreevars = NULL; | |
| 194 PyObject *cellvars = NULL, *ourcellvars = NULL; | |
| 195 PyObject *filename; | |
| 196 PyObject *name; | |
| 197 int firstlineno; | |
| 198 PyObject *lnotab; | |
| 199 | |
| 200 if (!PyArg_ParseTuple(args, "iiiiSO!O!O!SSiS|O!O!:code", | |
| 201 &argcount, &nlocals, &stacksize, &flags, | |
| 202 &code, | |
| 203 &PyTuple_Type, &consts, | |
| 204 &PyTuple_Type, &names, | |
| 205 &PyTuple_Type, &varnames, | |
| 206 &filename, &name, | |
| 207 &firstlineno, &lnotab, | |
| 208 &PyTuple_Type, &freevars, | |
| 209 &PyTuple_Type, &cellvars)) | |
| 210 return NULL; | |
| 211 | |
| 212 if (argcount < 0) { | |
| 213 PyErr_SetString( | |
| 214 PyExc_ValueError, | |
| 215 "code: argcount must not be negative"); | |
| 216 goto cleanup; | |
| 217 } | |
| 218 | |
| 219 if (nlocals < 0) { | |
| 220 PyErr_SetString( | |
| 221 PyExc_ValueError, | |
| 222 "code: nlocals must not be negative"); | |
| 223 goto cleanup; | |
| 224 } | |
| 225 | |
| 226 ournames = validate_and_copy_tuple(names); | |
| 227 if (ournames == NULL) | |
| 228 goto cleanup; | |
| 229 ourvarnames = validate_and_copy_tuple(varnames); | |
| 230 if (ourvarnames == NULL) | |
| 231 goto cleanup; | |
| 232 if (freevars) | |
| 233 ourfreevars = validate_and_copy_tuple(freevars); | |
| 234 else | |
| 235 ourfreevars = PyTuple_New(0); | |
| 236 if (ourfreevars == NULL) | |
| 237 goto cleanup; | |
| 238 if (cellvars) | |
| 239 ourcellvars = validate_and_copy_tuple(cellvars); | |
| 240 else | |
| 241 ourcellvars = PyTuple_New(0); | |
| 242 if (ourcellvars == NULL) | |
| 243 goto cleanup; | |
| 244 | |
| 245 co = (PyObject *)PyCode_New(argcount, nlocals, stacksize, flags, | |
| 246 code, consts, ournames, ourvarnames, | |
| 247 ourfreevars, ourcellvars, filename, | |
| 248 name, firstlineno, lnotab); | |
| 249 cleanup: | |
| 250 Py_XDECREF(ournames); | |
| 251 Py_XDECREF(ourvarnames); | |
| 252 Py_XDECREF(ourfreevars); | |
| 253 Py_XDECREF(ourcellvars); | |
| 254 return co; | |
| 255 } | |
| 256 | |
| 257 static void | |
| 258 code_dealloc(PyCodeObject *co) | |
| 259 { | |
| 260 Py_XDECREF(co->co_code); | |
| 261 Py_XDECREF(co->co_consts); | |
| 262 Py_XDECREF(co->co_names); | |
| 263 Py_XDECREF(co->co_varnames); | |
| 264 Py_XDECREF(co->co_freevars); | |
| 265 Py_XDECREF(co->co_cellvars); | |
| 266 Py_XDECREF(co->co_filename); | |
| 267 Py_XDECREF(co->co_name); | |
| 268 Py_XDECREF(co->co_lnotab); | |
|
38244
a637c78bf119
Merge from rjones-funccall branch.
Richard Jones <richard@commonground.com.au>
parents:
37838
diff
changeset
|
269 if (co->co_zombieframe != NULL) |
|
a637c78bf119
Merge from rjones-funccall branch.
Richard Jones <richard@commonground.com.au>
parents:
37838
diff
changeset
|
270 PyObject_GC_Del(co->co_zombieframe); |
| 35742 | 271 PyObject_DEL(co); |
| 272 } | |
| 273 | |
| 274 static PyObject * | |
| 275 code_repr(PyCodeObject *co) | |
| 276 { | |
| 277 char buf[500]; | |
| 278 int lineno = -1; | |
| 279 char *filename = "???"; | |
| 280 char *name = "???"; | |
| 281 | |
| 282 if (co->co_firstlineno != 0) | |
| 283 lineno = co->co_firstlineno; | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
284 if (co->co_filename && PyString_Check(co->co_filename)) |
|
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
285 filename = PyString_AS_STRING(co->co_filename); |
|
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
286 if (co->co_name && PyString_Check(co->co_name)) |
|
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
287 name = PyString_AS_STRING(co->co_name); |
| 35742 | 288 PyOS_snprintf(buf, sizeof(buf), |
| 289 "<code object %.100s at %p, file \"%.300s\", line %d>", | |
| 290 name, co, filename, lineno); | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
291 return PyString_FromString(buf); |
| 35742 | 292 } |
| 293 | |
| 294 static int | |
| 295 code_compare(PyCodeObject *co, PyCodeObject *cp) | |
| 296 { | |
| 297 int cmp; | |
| 298 cmp = PyObject_Compare(co->co_name, cp->co_name); | |
| 299 if (cmp) return cmp; | |
| 300 cmp = co->co_argcount - cp->co_argcount; | |
| 301 if (cmp) goto normalize; | |
| 302 cmp = co->co_nlocals - cp->co_nlocals; | |
| 303 if (cmp) goto normalize; | |
| 304 cmp = co->co_flags - cp->co_flags; | |
| 305 if (cmp) goto normalize; | |
| 306 cmp = co->co_firstlineno - cp->co_firstlineno; | |
| 307 if (cmp) goto normalize; | |
| 308 cmp = PyObject_Compare(co->co_code, cp->co_code); | |
| 309 if (cmp) return cmp; | |
| 310 cmp = PyObject_Compare(co->co_consts, cp->co_consts); | |
| 311 if (cmp) return cmp; | |
| 312 cmp = PyObject_Compare(co->co_names, cp->co_names); | |
| 313 if (cmp) return cmp; | |
| 314 cmp = PyObject_Compare(co->co_varnames, cp->co_varnames); | |
| 315 if (cmp) return cmp; | |
| 316 cmp = PyObject_Compare(co->co_freevars, cp->co_freevars); | |
| 317 if (cmp) return cmp; | |
| 318 cmp = PyObject_Compare(co->co_cellvars, cp->co_cellvars); | |
| 319 return cmp; | |
| 320 | |
| 321 normalize: | |
| 322 if (cmp > 0) | |
| 323 return 1; | |
| 324 else if (cmp < 0) | |
| 325 return -1; | |
| 326 else | |
| 327 return 0; | |
| 328 } | |
| 329 | |
|
45885
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
330 static PyObject * |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
331 code_richcompare(PyObject *self, PyObject *other, int op) |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
332 { |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
333 PyCodeObject *co, *cp; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
334 int eq; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
335 PyObject *res; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
336 |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
337 if ((op != Py_EQ && op != Py_NE) || |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
338 !PyCode_Check(self) || |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
339 !PyCode_Check(other)) { |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
340 |
|
46075
84bb7701efba
Make Py3k warnings consistent w.r.t. punctuation; also respect the
Georg Brandl <georg@python.org>
parents:
45885
diff
changeset
|
341 /* Py3K warning if types are not equal and comparison |
|
46578
7670005da8c5
A little reformating of Py3k warnings
Benjamin Peterson <benjamin@python.org>
parents:
46573
diff
changeset
|
342 isn't == or != */ |
|
46573
aef3501d8e77
Use PyErr_WarnPy3k throughout
Benjamin Peterson <benjamin@python.org>
parents:
46075
diff
changeset
|
343 if (PyErr_WarnPy3k("code inequality comparisons not supported " |
|
46578
7670005da8c5
A little reformating of Py3k warnings
Benjamin Peterson <benjamin@python.org>
parents:
46573
diff
changeset
|
344 "in 3.x", 1) < 0) { |
|
45885
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
345 return NULL; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
346 } |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
347 |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
348 Py_INCREF(Py_NotImplemented); |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
349 return Py_NotImplemented; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
350 } |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
351 |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
352 co = (PyCodeObject *)self; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
353 cp = (PyCodeObject *)other; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
354 |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
355 eq = PyObject_RichCompareBool(co->co_name, cp->co_name, Py_EQ); |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
356 if (eq <= 0) goto unequal; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
357 eq = co->co_argcount == cp->co_argcount; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
358 if (!eq) goto unequal; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
359 eq = co->co_nlocals == cp->co_nlocals; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
360 if (!eq) goto unequal; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
361 eq = co->co_flags == cp->co_flags; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
362 if (!eq) goto unequal; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
363 eq = co->co_firstlineno == cp->co_firstlineno; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
364 if (!eq) goto unequal; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
365 eq = PyObject_RichCompareBool(co->co_code, cp->co_code, Py_EQ); |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
366 if (eq <= 0) goto unequal; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
367 eq = PyObject_RichCompareBool(co->co_consts, cp->co_consts, Py_EQ); |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
368 if (eq <= 0) goto unequal; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
369 eq = PyObject_RichCompareBool(co->co_names, cp->co_names, Py_EQ); |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
370 if (eq <= 0) goto unequal; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
371 eq = PyObject_RichCompareBool(co->co_varnames, cp->co_varnames, Py_EQ); |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
372 if (eq <= 0) goto unequal; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
373 eq = PyObject_RichCompareBool(co->co_freevars, cp->co_freevars, Py_EQ); |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
374 if (eq <= 0) goto unequal; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
375 eq = PyObject_RichCompareBool(co->co_cellvars, cp->co_cellvars, Py_EQ); |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
376 if (eq <= 0) goto unequal; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
377 |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
378 if (op == Py_EQ) |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
379 res = Py_True; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
380 else |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
381 res = Py_False; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
382 goto done; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
383 |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
384 unequal: |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
385 if (eq < 0) |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
386 return NULL; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
387 if (op == Py_NE) |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
388 res = Py_True; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
389 else |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
390 res = Py_False; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
391 |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
392 done: |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
393 Py_INCREF(res); |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
394 return res; |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
395 } |
|
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
396 |
| 35742 | 397 static long |
| 398 code_hash(PyCodeObject *co) | |
| 399 { | |
| 400 long h, h0, h1, h2, h3, h4, h5, h6; | |
| 401 h0 = PyObject_Hash(co->co_name); | |
| 402 if (h0 == -1) return -1; | |
| 403 h1 = PyObject_Hash(co->co_code); | |
| 404 if (h1 == -1) return -1; | |
| 405 h2 = PyObject_Hash(co->co_consts); | |
| 406 if (h2 == -1) return -1; | |
| 407 h3 = PyObject_Hash(co->co_names); | |
| 408 if (h3 == -1) return -1; | |
| 409 h4 = PyObject_Hash(co->co_varnames); | |
| 410 if (h4 == -1) return -1; | |
| 411 h5 = PyObject_Hash(co->co_freevars); | |
| 412 if (h5 == -1) return -1; | |
| 413 h6 = PyObject_Hash(co->co_cellvars); | |
| 414 if (h6 == -1) return -1; | |
| 415 h = h0 ^ h1 ^ h2 ^ h3 ^ h4 ^ h5 ^ h6 ^ | |
| 416 co->co_argcount ^ co->co_nlocals ^ co->co_flags; | |
| 417 if (h == -1) h = -2; | |
| 418 return h; | |
| 419 } | |
| 420 | |
| 421 /* XXX code objects need to participate in GC? */ | |
| 422 | |
| 423 PyTypeObject PyCode_Type = { | |
|
42333
6620a510e9a9
PEP 3123: Provide forward compatibility with Python 3.0, while keeping
Martin v. Löwis <martin@v.loewis.de>
parents:
39069
diff
changeset
|
424 PyVarObject_HEAD_INIT(&PyType_Type, 0) |
| 35742 | 425 "code", |
| 426 sizeof(PyCodeObject), | |
| 427 0, | |
| 428 (destructor)code_dealloc, /* tp_dealloc */ | |
| 429 0, /* tp_print */ | |
| 430 0, /* tp_getattr */ | |
| 431 0, /* tp_setattr */ | |
| 432 (cmpfunc)code_compare, /* tp_compare */ | |
| 433 (reprfunc)code_repr, /* tp_repr */ | |
| 434 0, /* tp_as_number */ | |
| 435 0, /* tp_as_sequence */ | |
| 436 0, /* tp_as_mapping */ | |
| 437 (hashfunc)code_hash, /* tp_hash */ | |
| 438 0, /* tp_call */ | |
| 439 0, /* tp_str */ | |
| 440 PyObject_GenericGetAttr, /* tp_getattro */ | |
| 441 0, /* tp_setattro */ | |
| 442 0, /* tp_as_buffer */ | |
| 443 Py_TPFLAGS_DEFAULT, /* tp_flags */ | |
| 444 code_doc, /* tp_doc */ | |
| 445 0, /* tp_traverse */ | |
| 446 0, /* tp_clear */ | |
|
45885
860e23a61e55
Add py3k warnings for code and method inequality comparisons. This should resolve issue 2373. The codeobject.c and methodobject.c changes are both just backports of the Python 3 code.
Steven Bethard <steven.bethard@gmail.com>
parents:
42333
diff
changeset
|
447 code_richcompare, /* tp_richcompare */ |
| 35742 | 448 0, /* tp_weaklistoffset */ |
| 449 0, /* tp_iter */ | |
| 450 0, /* tp_iternext */ | |
| 451 0, /* tp_methods */ | |
| 452 code_memberlist, /* tp_members */ | |
| 453 0, /* tp_getset */ | |
| 454 0, /* tp_base */ | |
| 455 0, /* tp_dict */ | |
| 456 0, /* tp_descr_get */ | |
| 457 0, /* tp_descr_set */ | |
| 458 0, /* tp_dictoffset */ | |
| 459 0, /* tp_init */ | |
| 460 0, /* tp_alloc */ | |
| 461 code_new, /* tp_new */ | |
| 462 }; | |
| 463 | |
| 464 /* All about c_lnotab. | |
| 465 | |
| 466 c_lnotab is an array of unsigned bytes disguised as a Python string. In -O | |
| 467 mode, SET_LINENO opcodes aren't generated, and bytecode offsets are mapped | |
| 468 to source code line #s (when needed for tracebacks) via c_lnotab instead. | |
| 469 The array is conceptually a list of | |
| 470 (bytecode offset increment, line number increment) | |
| 471 pairs. The details are important and delicate, best illustrated by example: | |
| 472 | |
| 473 byte code offset source code line number | |
| 474 0 1 | |
| 475 6 2 | |
| 476 50 7 | |
| 477 350 307 | |
| 478 361 308 | |
| 479 | |
| 480 The first trick is that these numbers aren't stored, only the increments | |
| 481 from one row to the next (this doesn't really work, but it's a start): | |
| 482 | |
| 483 0, 1, 6, 1, 44, 5, 300, 300, 11, 1 | |
| 484 | |
| 485 The second trick is that an unsigned byte can't hold negative values, or | |
| 486 values larger than 255, so (a) there's a deep assumption that byte code | |
| 487 offsets and their corresponding line #s both increase monotonically, and (b) | |
| 488 if at least one column jumps by more than 255 from one row to the next, more | |
| 489 than one pair is written to the table. In case #b, there's no way to know | |
| 490 from looking at the table later how many were written. That's the delicate | |
| 491 part. A user of c_lnotab desiring to find the source line number | |
| 492 corresponding to a bytecode address A should do something like this | |
| 493 | |
| 494 lineno = addr = 0 | |
| 495 for addr_incr, line_incr in c_lnotab: | |
| 496 addr += addr_incr | |
| 497 if addr > A: | |
| 498 return lineno | |
| 499 lineno += line_incr | |
| 500 | |
| 501 In order for this to work, when the addr field increments by more than 255, | |
| 502 the line # increment in each pair generated must be 0 until the remaining addr | |
| 503 increment is < 256. So, in the example above, com_set_lineno should not (as | |
| 504 was actually done until 2.2) expand 300, 300 to 255, 255, 45, 45, but to | |
| 505 255, 0, 45, 255, 0, 45. | |
| 506 */ | |
| 507 | |
| 508 int | |
| 509 PyCode_Addr2Line(PyCodeObject *co, int addrq) | |
| 510 { | |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
511 int size = PyString_Size(co->co_lnotab) / 2; |
|
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
512 unsigned char *p = (unsigned char*)PyString_AsString(co->co_lnotab); |
| 35742 | 513 int line = co->co_firstlineno; |
| 514 int addr = 0; | |
| 515 while (--size >= 0) { | |
| 516 addr += *p++; | |
| 517 if (addr > addrq) | |
| 518 break; | |
| 519 line += *p++; | |
| 520 } | |
| 521 return line; | |
| 522 } | |
|
37838
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
523 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
524 /* |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
525 Check whether the current instruction is at the start of a line. |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
526 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
527 */ |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
528 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
529 /* The theory of SET_LINENO-less tracing. |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
530 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
531 In a nutshell, we use the co_lnotab field of the code object |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
532 to tell when execution has moved onto a different line. |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
533 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
534 As mentioned above, the basic idea is so set things up so |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
535 that |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
536 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
537 *instr_lb <= frame->f_lasti < *instr_ub |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
538 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
539 is true so long as execution does not change lines. |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
540 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
541 This is all fairly simple. Digging the information out of |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
542 co_lnotab takes some work, but is conceptually clear. |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
543 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
544 Somewhat harder to explain is why we don't *always* call the |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
545 line trace function when the above test fails. |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
546 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
547 Consider this code: |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
548 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
549 1: def f(a): |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
550 2: if a: |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
551 3: print 1 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
552 4: else: |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
553 5: print 2 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
554 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
555 which compiles to this: |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
556 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
557 2 0 LOAD_FAST 0 (a) |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
558 3 JUMP_IF_FALSE 9 (to 15) |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
559 6 POP_TOP |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
560 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
561 3 7 LOAD_CONST 1 (1) |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
562 10 PRINT_ITEM |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
563 11 PRINT_NEWLINE |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
564 12 JUMP_FORWARD 6 (to 21) |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
565 >> 15 POP_TOP |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
566 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
567 5 16 LOAD_CONST 2 (2) |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
568 19 PRINT_ITEM |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
569 20 PRINT_NEWLINE |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
570 >> 21 LOAD_CONST 0 (None) |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
571 24 RETURN_VALUE |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
572 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
573 If 'a' is false, execution will jump to instruction at offset |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
574 15 and the co_lnotab will claim that execution has moved to |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
575 line 3. This is at best misleading. In this case we could |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
576 associate the POP_TOP with line 4, but that doesn't make |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
577 sense in all cases (I think). |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
578 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
579 What we do is only call the line trace function if the co_lnotab |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
580 indicates we have jumped to the *start* of a line, i.e. if the |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
581 current instruction offset matches the offset given for the |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
582 start of a line by the co_lnotab. |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
583 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
584 This also takes care of the situation where 'a' is true. |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
585 Execution will jump from instruction offset 12 to offset 21. |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
586 Then the co_lnotab would imply that execution has moved to line |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
587 5, which is again misleading. |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
588 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
589 Why do we set f_lineno when tracing? Well, consider the code |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
590 above when 'a' is true. If stepping through this with 'n' in |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
591 pdb, you would stop at line 1 with a "call" type event, then |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
592 line events on lines 2 and 3, then a "return" type event -- but |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
593 you would be shown line 5 during this event. This is a change |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
594 from the behaviour in 2.2 and before, and I've found it |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
595 confusing in practice. By setting and using f_lineno when |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
596 tracing, one can report a line number different from that |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
597 suggested by f_lasti on this one occasion where it's desirable. |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
598 */ |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
599 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
600 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
601 int |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
602 PyCode_CheckLineNumber(PyCodeObject* co, int lasti, PyAddrPair *bounds) |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
603 { |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
604 int size, addr, line; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
605 unsigned char* p; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
606 |
|
47527
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
607 p = (unsigned char*)PyString_AS_STRING(co->co_lnotab); |
|
52294af4b663
This reverts r63675 based on the discussion in this thread:
Gregory P. Smith <greg@mad-scientist.com>
parents:
47294
diff
changeset
|
608 size = PyString_GET_SIZE(co->co_lnotab) / 2; |
|
37838
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
609 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
610 addr = 0; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
611 line = co->co_firstlineno; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
612 assert(line > 0); |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
613 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
614 /* possible optimization: if f->f_lasti == instr_ub |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
615 (likely to be a common case) then we already know |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
616 instr_lb -- if we stored the matching value of p |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
617 somwhere we could skip the first while loop. */ |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
618 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
619 /* see comments in compile.c for the description of |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
620 co_lnotab. A point to remember: increments to p |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
621 should come in pairs -- although we don't care about |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
622 the line increments here, treating them as byte |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
623 increments gets confusing, to say the least. */ |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
624 |
|
39069
476cd83777f2
Fix uninitialized memory read reported by Valgrind when running doctest.
Neal Norwitz <nnorwitz@gmail.com>
parents:
38244
diff
changeset
|
625 bounds->ap_lower = 0; |
|
37838
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
626 while (size > 0) { |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
627 if (addr + *p > lasti) |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
628 break; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
629 addr += *p++; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
630 if (*p) |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
631 bounds->ap_lower = addr; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
632 line += *p++; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
633 --size; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
634 } |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
635 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
636 /* If lasti and addr don't match exactly, we don't want to |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
637 change the lineno slot on the frame or execute a trace |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
638 function. Return -1 instead. |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
639 */ |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
640 if (addr != lasti) |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
641 line = -1; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
642 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
643 if (size > 0) { |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
644 while (--size >= 0) { |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
645 addr += *p++; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
646 if (*p++) |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
647 break; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
648 } |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
649 bounds->ap_upper = addr; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
650 } |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
651 else { |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
652 bounds->ap_upper = INT_MAX; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
653 } |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
654 |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
655 return line; |
|
cc48985c3266
Refactor: Move code that uses co_lnotab from ceval to codeobject
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
36501
diff
changeset
|
656 } |