Pythonparser访问Python解析树

创建 ST 对象¶

ST objects may be created from source code or from a parse tree. When creating

an ST object from source, different functions are used to create the 'eval'

and 'exec' forms.

parser.expr(source)¶

The expr() function parses the parameter source as if it were an input

to compile(source,'file.py','eval'). If the parse succeeds, an ST object

is created to hold the internal parse tree representation, otherwise an

appropriate exception is raised.

parser.suite(source)¶

The suite() function parses the parameter source as if it were an input

to compile(source,'file.py','exec'). If the parse succeeds, an ST object

is created to hold the internal parse tree representation, otherwise an

appropriate exception is raised.

parser.sequence2st(sequence)¶

This function accepts a parse tree represented as a sequence and builds an

internal representation if possible. If it can validate that the tree conforms

to the Python grammar and all nodes are valid node types in the host version of

Python, an ST object is created from the internal representation and returned

to the called. If there is a problem creating the internal representation, or

if the tree cannot be validated, a ParserError exception is raised. An

ST object created this way should not be assumed to compile correctly; normal

exceptions raised by compilation may still be initiated when the ST object is

passed to compilest(). This may indicate problems not related to syntax

(such as a MemoryError exception), but may also be due to constructs such

as the result of parsing delf(0), which escapes the Python parser but is

checked by the bytecode compiler.

Sequences representing terminal tokens may be represented as either two-element

lists of the form (1,'name') or as three-element lists of the form (1,

'name',56). If the third element is present, it is assumed to be a valid

line number. The line number may be specified for any subset of the terminal

symbols in the input tree.

parser.tuple2st(sequence)¶

This is the same function as sequence2st(). This entry point is

maintained for backward compatibility.

转换 ST 对象¶

ST objects, regardless of the input used to create them, may be converted to

parse trees represented as list- or tuple- trees, or may be compiled into

executable code objects. Parse trees may be extracted with or without line

numbering information.

parser.st2list(st, line_info=False, col_info=False)¶

This function accepts an ST object from the caller in st and returns a

Python list representing the equivalent parse tree. The resulting list

representation can be used for inspection or the creation of a new parse tree in

list form. This function does not fail so long as memory is available to build

the list representation. If the parse tree will only be used for inspection,

st2tuple() should be used instead to reduce memory consumption and

fragmentation. When the list representation is required, this function is

significantly faster than retrieving a tuple representation and converting that

to nested lists.

If line_info is true, line number information will be included for all

terminal tokens as a third element of the list representing the token. Note

that the line number provided specifies the line on which the token ends.

This information is omitted if the flag is false or omitted.

parser.st2tuple(st, line_info=False, col_info=False)¶

This function accepts an ST object from the caller in st and returns a

Python tuple representing the equivalent parse tree. Other than returning a

tuple instead of a list, this function is identical to st2list().

If line_info is true, line number information will be included for all

terminal tokens as a third element of the list representing the token. This

information is omitted if the flag is false or omitted.

parser.compilest(st, filename='<syntax-tree>')¶

The Python byte compiler can be invoked on an ST object to produce code objects

which can be used as part of a call to the built-in exec() or eval()

functions. This function provides the interface to the compiler, passing the

internal parse tree from st to the parser, using the source file name

specified by the filename parameter. The default value supplied for filename

indicates that the source was an ST object.

Compiling an ST object may result in exceptions related to compilation; an

example would be a SyntaxError caused by the parse tree for delf(0):

this statement is considered legal within the formal grammar for Python but is

not a legal language construct. The SyntaxError raised for this

condition is actually generated by the Python byte-compiler normally, which is

why it can be raised at this point by the parser module. Most causes of

compilation failure can be diagnosed programmatically by inspection of the parse

tree.

Queries on ST Objects¶

Two functions are provided which allow an application to determine if an ST was

created as an expression or a suite. Neither of these functions can be used to

determine if an ST was created from source code via expr() or

suite() or from a parse tree via sequence2st().

parser.isexpr(st)¶

When st represents an 'eval' form, this function returns True, otherwise

it returns False. This is useful, since code objects normally cannot be queried

for this information using existing built-in functions. Note that the code

objects created by compilest() cannot be queried like this either, and

are identical to those created by the built-in compile() function.

parser.issuite(st)¶

This function mirrors isexpr() in that it reports whether an ST object

represents an 'exec' form, commonly known as a "suite." It is not safe to

assume that this function is equivalent to notisexpr(st), as additional

syntactic fragments may be supported in the future.

异常和错误处理¶

The parser module defines a single exception, but may also pass other built-in

exceptions from other portions of the Python runtime environment. See each

function for information about the exceptions it can raise.

exception parser.ParserError¶

Exception raised when a failure occurs within the parser module. This is

generally produced for validation failures rather than the built-in

SyntaxError raised during normal parsing. The exception argument is

either a string describing the reason of the failure or a tuple containing a

sequence causing the failure from a parse tree passed to sequence2st()

and an explanatory string. Calls to sequence2st() need to be able to

handle either type of exception, while calls to other functions in the module

will only need to be aware of the simple string values.

Note that the functions compilest(), expr(), and suite() may

raise exceptions which are normally raised by the parsing and compilation

process. These include the built in exceptions MemoryError,

OverflowError, SyntaxError, and SystemError. In these

cases, these exceptions carry all the meaning normally associated with them.

Refer to the descriptions of each function for detailed information.

ST 对象¶

Ordered and equality comparisons are supported between ST objects. Pickling of

ST objects (using the pickle module) is also supported.

parser.STType¶

The type of the objects returned by expr(), suite() and

sequence2st().

ST 对象具有以下方法:

ST.compile(filename='<syntax-tree>')¶

和 compilest(st,filename) 相同.

ST.isexpr()¶

和 isexpr(st) 相同。

ST.issuite()¶

和 issuite(st) 相同。

ST.tolist(line_info=False, col_info=False)¶

和 st2list(st,line_info,col_info) 相同。

ST.totuple(line_info=False, col_info=False)¶

和 st2tuple(st,line_info,col_info) 相同。

示例: compile() 的模拟¶

While many useful operations may take place between parsing and bytecode

generation, the simplest operation is to do nothing. For this purpose, using

the parser module to produce an intermediate data structure is equivalent

to the code

>>> code=compile('a + 5','file.py','eval')
>>> a=5
>>> eval(code)
10

The equivalent operation using the parser module is somewhat longer, and

allows the intermediate internal parse tree to be retained as an ST object:

>>> importparser
>>> st=parser.expr('a + 5')
>>> code=st.compile('file.py')
>>> a=5
>>> eval(code)
10

An application which needs both ST and code objects can package this code into

readily available functions:

importparser
defload_suite(source_string):
st=parser.suite(source_string)
returnst,st.compile()
defload_expression(source_string):
st=parser.expr(source_string)
returnst,st.compile()