/usr/lib/python2.7/dist-packages/kajiki/lnotab.py is in python-kajiki 0.5.3-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 | # -*- coding: utf-8 -*-
'''Comment copied from Python/compile.c:
All about a_lnotab.
c_lnotab is an array of unsigned bytes disguised as a Python string.
It is used to map bytecode offsets to source code line #s (when needed
for tracebacks).
The array is conceptually a list of
(bytecode offset increment, line number increment)
pairs. The details are important and delicate, best illustrated by example:
byte code offset source code line number
0 1
6 2
50 7
350 307
361 308
The first trick is that these numbers aren't stored, only the increments
from one row to the next (this doesn't really work, but it's a start):
0, 1, 6, 1, 44, 5, 300, 300, 11, 1
The second trick is that an unsigned byte can't hold negative values, or
values larger than 255, so (a) there's a deep assumption that byte code
offsets and their corresponding line #s both increase monotonically, and (b)
if at least one column jumps by more than 255 from one row to the next, more
than one pair is written to the table. In case #b, there's no way to know
from looking at the table later how many were written. That's the delicate
part. A user of c_lnotab desiring to find the source line number
corresponding to a bytecode address A should do something like this
lineno = addr = 0
for addr_incr, line_incr in c_lnotab:
addr += addr_incr
if addr > A:
return lineno
lineno += line_incr
In order for this to work, when the addr field increments by more than 255,
the line # increment in each pair generated must be 0 until the remaining addr
increment is < 256. So, in the example above, assemble_lnotab (it used
to be called com_set_lineno) should not (as was actually done until 2.2)
expand 300, 300 to 255, 255, 45, 45,
but to 255, 0, 45, 255, 0, 45.
'''
from __future__ import (absolute_import, division, print_function)
from nine import IS_PYTHON2
if IS_PYTHON2:
int2byte = chr
byte2int = ord
else:
def int2byte(i):
return bytes([i])
def byte2int(b):
return b
def lnotab(pairs, first_lineno=0):
"""Yields byte integers representing the pairs of integers passed in."""
assert first_lineno <= pairs[0][1]
cur_byte, cur_line = 0, first_lineno
for byte_off, line_off in pairs:
byte_delta = byte_off - cur_byte
line_delta = line_off - cur_line
assert byte_delta >= 0
assert line_delta >= 0
while byte_delta > 255:
yield 255 # byte
yield 0 # line
byte_delta -= 255
yield byte_delta
while line_delta > 255:
yield 255 # line
yield 0 # byte
line_delta -= 255
yield line_delta
cur_byte, cur_line = byte_off, line_off
def lnotab_string(pairs, first_lineno=0):
return b"".join(int2byte(b) for b in lnotab(pairs, first_lineno))
def byte_pairs(lnotab):
"""Yield pairs of integers from a string."""
for i in range(0, len(lnotab), 2):
yield byte2int(lnotab[i]), byte2int(lnotab[i + 1])
def lnotab_numbers(lnotab, first_lineno=0):
"""Yields the byte, line offset pairs from a packed lnotab string."""
last_line = None
cur_byte, cur_line = 0, first_lineno
for byte_delta, line_delta in byte_pairs(lnotab):
if byte_delta:
if cur_line != last_line:
yield cur_byte, cur_line
last_line = cur_line
cur_byte += byte_delta
cur_line += line_delta
if cur_line != last_line:
yield cur_byte, cur_line
|