The ast module shows that elements of the syntax tree have line and
column numbers. Would it be sensible to attempt to revise them to
achieve effects like the #line directive in C?
Context: Using noweb, a literate programming tool, which from a source
file foo.nw produces foo.py. The lines in the two files may be in
completely different sequenes. For debugging, it is useful to receive
error reports that refer to the original line number in foo.nw.
I am not sure how such rewriting would interact with debugger commands
that set a breakpoint at a file and line number. I'm also not sure it
would change the reported line numbers of errors.
The lack of a file name could be problematic if multiple sources
contributed to the same .py file, but that is an unlikely scenario.
As an extension or alternate, could there be a decorator like
for classes and methods that could do the conversion on the fly? I
don't know if there's a way to go from the function (or class) object
the decorator receives to the AST.
No [easy] way to go from bytecodes back to AST, but I see no reason why you
can't create a new code object with your filename and line numbers and then
create a new function using your modified code object.
If you don't have a 1:1 correspondence of lines then you'll need to pick
out all the existing line numbers from the code object co_lnotab and modify
them: see dis.py findlinestarts() for how to do this.
Classes would be harder: the decorator doesn't run until after the class
body has executed, so you can't change the line numbers that way until it's
too late. The only thing I can think would be to put all of the generated
code inside a function and fix up that function with a decorator that scans
the bytecode to find all contained classes and fix them up.
Or you could generate a .pyc file and then fix up line numbers in the whole
file: see http://nedbatchelder.com/blog/200804/the_structure_of_pyc_fi[..] for
some code that shows you what's in a .pyc
Duncan Booth http://kupuguy.blogspot.com