Objects/codeobject.c

   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 {
  31         Py_ssize_t i;
  32
  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         }
  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;
  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         }
 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;
 139         Py_ssize_t i, len;
 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);
 148                 if (PyString_CheckExact(item)) {
 149                         Py_INCREF(item);
 150                 }
 151                 else if (!PyString_Check(item)) {
 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 {
 161                         item = PyString_FromStringAndSize(
 162                                 PyString_AS_STRING(item),
 163                                 PyString_GET_SIZE(item));
 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);
 269         if (co->co_zombieframe != NULL)
 270                 PyObject_GC_Del(co->co_zombieframe);
 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;
 284         if (co->co_filename && PyString_Check(co->co_filename))
 285                 filename = PyString_AS_STRING(co->co_filename);
 286         if (co->co_name && PyString_Check(co->co_name))
 287                 name = PyString_AS_STRING(co->co_name);
 288         PyOS_snprintf(buf, sizeof(buf),
 289                       "<code object %.100s at %p, file \"%.300s\", line %d>",
 290                       name, co, filename, lineno);
 291         return PyString_FromString(buf);
 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
 330 static PyObject *
 331 code_richcompare(PyObject *self, PyObject *other, int op)
 332 {
 333         PyCodeObject *co, *cp;
 334         int eq;
 335         PyObject *res;
 336
 337         if ((op != Py_EQ && op != Py_NE) ||
 338             !PyCode_Check(self) ||
 339             !PyCode_Check(other)) {
 340
 341                 /* Py3K warning if types are not equal and comparison
 342                 isn't == or !=  */
 343                 if (PyErr_WarnPy3k("code inequality comparisons not supported "
 344                                    "in 3.x", 1) < 0) {
 345                         return NULL;
 346                 }
 347
 348                 Py_INCREF(Py_NotImplemented);
 349                 return Py_NotImplemented;
 350         }
 351
 352         co = (PyCodeObject *)self;
 353         cp = (PyCodeObject *)other;
 354
 355         eq = PyObject_RichCompareBool(co->co_name, cp->co_name, Py_EQ);
 356         if (eq <= 0) goto unequal;
 357         eq = co->co_argcount == cp->co_argcount;
 358         if (!eq) goto unequal;
 359         eq = co->co_nlocals == cp->co_nlocals;
 360         if (!eq) goto unequal;
 361         eq = co->co_flags == cp->co_flags;
 362         if (!eq) goto unequal;
 363         eq = co->co_firstlineno == cp->co_firstlineno;
 364         if (!eq) goto unequal;
 365         eq = PyObject_RichCompareBool(co->co_code, cp->co_code, Py_EQ);
 366         if (eq <= 0) goto unequal;
 367         eq = PyObject_RichCompareBool(co->co_consts, cp->co_consts, Py_EQ);
 368         if (eq <= 0) goto unequal;
 369         eq = PyObject_RichCompareBool(co->co_names, cp->co_names, Py_EQ);
 370         if (eq <= 0) goto unequal;
 371         eq = PyObject_RichCompareBool(co->co_varnames, cp->co_varnames, Py_EQ);
 372         if (eq <= 0) goto unequal;
 373         eq = PyObject_RichCompareBool(co->co_freevars, cp->co_freevars, Py_EQ);
 374         if (eq <= 0) goto unequal;
 375         eq = PyObject_RichCompareBool(co->co_cellvars, cp->co_cellvars, Py_EQ);
 376         if (eq <= 0) goto unequal;
 377
 378         if (op == Py_EQ)
 379                 res = Py_True;
 380         else
 381                 res = Py_False;
 382         goto done;
 383
 384   unequal:
 385         if (eq < 0)
 386                 return NULL;
 387         if (op == Py_NE)
 388                 res = Py_True;
 389         else
 390                 res = Py_False;
 391
 392   done:
 393         Py_INCREF(res);
 394         return res;
 395 }
 396
 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 = {
 424         PyVarObject_HEAD_INIT(&PyType_Type, 0)
 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 */
 447         code_richcompare,                               /* tp_richcompare */
 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 {
 511         int size = PyString_Size(co->co_lnotab) / 2;
 512         unsigned char *p = (unsigned char*)PyString_AsString(co->co_lnotab);
 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 }
 523
 524 /*
 525    Check whether the current instruction is at the start of a line.
 526
 527  */
 528
 529         /* The theory of SET_LINENO-less tracing.
 530
 531            In a nutshell, we use the co_lnotab field of the code object
 532            to tell when execution has moved onto a different line.
 533
 534            As mentioned above, the basic idea is so set things up so
 535            that
 536
 537                  *instr_lb <= frame->f_lasti < *instr_ub
 538
 539            is true so long as execution does not change lines.
 540
 541            This is all fairly simple.  Digging the information out of
 542            co_lnotab takes some work, but is conceptually clear.
 543
 544            Somewhat harder to explain is why we don't *always* call the
 545            line trace function when the above test fails.
 546
 547            Consider this code:
 548
 549            1: def f(a):
 550            2:     if a:
 551            3:        print 1
 552            4:     else:
 553            5:        print 2
 554
 555            which compiles to this:
 556
 557            2           0 LOAD_FAST                0 (a)
 558                        3 JUMP_IF_FALSE            9 (to 15)
 559                        6 POP_TOP
 560
 561            3           7 LOAD_CONST               1 (1)
 562                       10 PRINT_ITEM
 563                       11 PRINT_NEWLINE
 564                       12 JUMP_FORWARD             6 (to 21)
 565                  >>   15 POP_TOP
 566
 567            5          16 LOAD_CONST               2 (2)
 568                       19 PRINT_ITEM
 569                       20 PRINT_NEWLINE
 570                  >>   21 LOAD_CONST               0 (None)
 571                       24 RETURN_VALUE
 572
 573            If 'a' is false, execution will jump to instruction at offset
 574            15 and the co_lnotab will claim that execution has moved to
 575            line 3.  This is at best misleading.  In this case we could
 576            associate the POP_TOP with line 4, but that doesn't make
 577            sense in all cases (I think).
 578
 579            What we do is only call the line trace function if the co_lnotab
 580            indicates we have jumped to the *start* of a line, i.e. if the
 581            current instruction offset matches the offset given for the
 582            start of a line by the co_lnotab.
 583
 584            This also takes care of the situation where 'a' is true.
 585            Execution will jump from instruction offset 12 to offset 21.
 586            Then the co_lnotab would imply that execution has moved to line
 587            5, which is again misleading.
 588
 589            Why do we set f_lineno when tracing?  Well, consider the code
 590            above when 'a' is true.  If stepping through this with 'n' in
 591            pdb, you would stop at line 1 with a "call" type event, then
 592            line events on lines 2 and 3, then a "return" type event -- but
 593            you would be shown line 5 during this event.  This is a change
 594            from the behaviour in 2.2 and before, and I've found it
 595            confusing in practice.  By setting and using f_lineno when
 596            tracing, one can report a line number different from that
 597            suggested by f_lasti on this one occasion where it's desirable.
 598         */
 599
 600
 601 int
 602 PyCode_CheckLineNumber(PyCodeObject* co, int lasti, PyAddrPair *bounds)
 603 {
 604         int size, addr, line;
 605         unsigned char* p;
 606
 607         p = (unsigned char*)PyString_AS_STRING(co->co_lnotab);
 608         size = PyString_GET_SIZE(co->co_lnotab) / 2;
 609
 610         addr = 0;
 611         line = co->co_firstlineno;
 612         assert(line > 0);
 613
 614         /* possible optimization: if f->f_lasti == instr_ub
 615            (likely to be a common case) then we already know
 616            instr_lb -- if we stored the matching value of p
 617            somwhere we could skip the first while loop. */
 618
 619         /* see comments in compile.c for the description of
 620            co_lnotab.  A point to remember: increments to p
 621            should come in pairs -- although we don't care about
 622            the line increments here, treating them as byte
 623            increments gets confusing, to say the least. */
 624
 625         bounds->ap_lower = 0;
 626         while (size > 0) {
 627                 if (addr + *p > lasti)
 628                         break;
 629                 addr += *p++;
 630                 if (*p)
 631                         bounds->ap_lower = addr;
 632                 line += *p++;
 633                 --size;
 634         }
 635
 636         /* If lasti and addr don't match exactly, we don't want to
 637            change the lineno slot on the frame or execute a trace
 638            function.  Return -1 instead.
 639         */
 640         if (addr != lasti)
 641                 line = -1;
 642
 643         if (size > 0) {
 644                 while (--size >= 0) {
 645                         addr += *p++;
 646                         if (*p++)
 647                                 break;
 648                 }
 649                 bounds->ap_upper = addr;
 650         }
 651         else {
 652                 bounds->ap_upper = INT_MAX;
 653         }
 654
 655         return line;
 656 }