Python源码分析5 – 语法分析器PyParser
来源:互联网 发布:大华解码器软件 编辑:程序博客网 时间:2024/06/04 18:06
Introduction
上一篇文章我们分析了Python是如何对语法文件Grammar进行预处理,生成语法数据,并在运行时生成Acclerators加速语法分析的过程。当分析完这些内容之后,下一步便是分析Python中语法分析的机制。回顾一下Python的整个处理流程:
1. PyTokenizer进行词法分析,把源程序分解为Token
2. PyParser根据Token创建CST
3. CST被转换为AST
4. AST被编译为字节码
5. 执行字节码
语法分析处于整个流程的第二步,其目标是处理token生成CST(Concrete Syntax Tree)。因此,在具体分析PyParser的工作方式之前,我们先看一下什么是CST。
CST (Concrete Syntax Tree)
CST (Concrete Syntax Tree) 和AST (Abstract Syntax Tree) 类似,都是语法分析所获得的中间结果。他们的不同之处在于,CST直接对应语法分析的匹配的过程,是直接生成的,含有大量冗余信息。而AST省略了中间的冗余信息,直接对应实际的语义,也就是分析的结果。用例子说明要清楚一些:
假设有这样一个表达式a,
CST是这样的:(->表示从父结点到子结点)
file_input -> stmt -> simple_stmt -> small_stmt -> expr_stmt -> testlist -> test ->or_test ->and_test ->not_test -> comparison -> expr -> xor_expr -> and_expr -> shift_expr -> arith_expr -> term -> factor -> power -> atom -> (NAME, “a”)
而AST则是:
(stmt_ty, expr_kind) -> (expr_ty, name_kind) ->(“a”)
可以看到CST表述了整个分析a的过程,从file_input一直推导到最后的NAME,每一步推导都成了树的结点,而大部分信息都可以说是无用的。AST的结构要简单和直接的多,直接表明a是一个表达式语句(假定a是一个单独的语句),内容是一个标示符,值为”a”。Python的语法分析生成的是CST而非AST,之后Python会调用PyAst_FromNode将CST转换为AST。
CST的结点称为Node,其结构定义在node.h中:
typedef struct _node {
short n_type;
char *n_str;
int n_lineno;
int n_col_offset;
int n_nchildren;
struct _node *n_child;
} node;
Field
Description
n_type
结点类型,终结符定义在token.h中,而非终结符定义在graminit.h中
n_str
结点所对应的字符串的内容
n_lineno
对应的行号
n_col_offset
列号
n_nchildren
子结点的个数
n_child
子结点数组,动态分配内存
Python提供了下面的函数/宏来操作CST,同样定义在node.h中:
PyAPI_FUNC(node *) PyNode_New(int type);
PyAPI_FUNC(int) PyNode_AddChild(node *n, int type,
char *str, int lineno, int col_offset);
PyAPI_FUNC(void) PyNode_Free(node *n);
/* Node access functions */
#define NCH(n) ((n)->n_nchildren)
#define CHILD(n, i) (&(n)->n_child[i])
#define RCHILD(n, i) (CHILD(n, NCH(n) + i))
#define TYPE(n) ((n)->n_type)
#define STR(n) ((n)->n_str)
/* Assert that the type of a node is what we expect */
#define REQ(n, type) assert(TYPE(n) == (type))
PyAPI_FUNC(void) PyNode_ListTree(node *);
PyNode_New和PyNode_Delete负责创建和释放node结构:
node *
PyNode_New(int type)
{
node *n = (node *) PyObject_MALLOC(1 * sizeof(node));
if (n == NULL)
return NULL;
n->n_type = type;
n->n_str = NULL;
n->n_lineno = 0;
n->n_nchildren = 0;
n->n_child = NULL;
return n;
}
void
PyNode_Free(node *n)
{
if (n != NULL) {
freechildren(n);
PyObject_FREE(n);
}
}
static void
freechildren(node *n)
{
int i;
for (i = NCH(n); --i >= 0; )
freechildren(CHILD(n, i));
if (n->n_child != NULL)
PyObject_FREE(n->n_child);
if (STR(n) != NULL)
PyObject_FREE(STR(n));
}
NCH/CHILD/RCHILD/TYPE/STR是用来封装对node的成员的访问的。需要提一下的是,CHILD(n, i)是从左边开始算,传入i的是正数,而RCHILD(n, i)则是从右边往左,传入的参数i是负数。
PyNode_AddChild将一个新的子结点加入到子结点数组中。由于结点数量是动态变化的,因此在当前分配的结点数组大小不够的时候,Python会调用realloc重新分配内存。内存分配是一个非常耗时的动作,因此Python在PyNode_AddChild之中用到了和std::vector类似的技巧来尽量减少内存分配的次数,每次增长的时候都会根据某个规则进行RoundUp,而不是需要多少就分配多少。XXXROUNDUP函数负责进行此运算。n<=1时, 返回n。1<n<=128的时候,会RoundUp到4的倍数。n>128, 会调用fancy_roundup来RoundUp到2的幂。
#define XXXROUNDUP(n) ((n) <= 1 ? (n) : /
(n) <= 128 ? (((n) + 3) & ~3) : /
fancy_roundup(n))
有了XXXROUNDUP之后,实现PyNode_AddChild就非常直接了:
int
PyNode_AddChild(register node *n1, int type, char *str, int lineno, int col_offset)
{
const int nch = n1->n_nchildren;
int current_capacity;
int required_capacity;
node *n;
if (nch == INT_MAX || nch < 0)
return E_OVERFLOW;
current_capacity = XXXROUNDUP(nch);
required_capacity = XXXROUNDUP(nch + 1);
if (current_capacity < 0 || required_capacity < 0)
return E_OVERFLOW;
if (current_capacity < required_capacity) {
n = n1->n_child;
n = (node *) PyObject_REALLOC(n,
required_capacity * sizeof(node));
if (n == NULL)
return E_NOMEM;
n1->n_child = n;
}
n = &n1->n_child[n1->n_nchildren++];
n->n_type = type;
n->n_str = str;
n->n_lineno = lineno;
n->n_col_offset = col_offset;
n->n_nchildren = 0;
n->n_child = NULL;
return 0;
}
值得注意的是该函数并没有记录下当前的最大容量,这个可以通过XXXROUNDUP(nch)计算出来。
PyParser
PyParser所作的事情就是根据token生成CST。整个生成树的过程其实也就是一个遍历语法图的过程。在前一篇文章中我们知道语法图是由多个DFA组成的,而输入的token和当前的所处的状态结点可以决定下一个状态结点。由于PyParser是在多个DFA中遍历,因此当结束了某个DFA的遍历需要回到上一个DFA,这些信息都是由一个专门的栈保存着。PyParser所对应的结构是parser_state,这个结构保存着PyParser的内部状态,如下:
typedef struct {
stack p_stack; /* Stack of parser states */
grammar *p_grammar; /* Grammar to use */
node *p_tree; /* Top of parse tree */
#ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD
unsigned long p_flags; /* see co_flags in Include/code.h */
#endif
} parser_state;
Field
Description
p_stack
PyParser状态栈,每一个状态都对应着某个DFA中的某个状态
p_grammar
语法图的指针
p_tree
CST的根结点
p_flags
PyParser的flags,唯一用到的是CO_FUTURE_WITH_STATEMENT
状态栈的定义如下:
typedef struct {
stackentry *s_top; /* Top entry */
stackentry s_base[MAXSTACK]; /* Array of stack entries */
/* NB The stack grows down */
} stack;
状态栈中的状态如下:
typedef struct {
int s_state; /* State in current DFA */
dfa *s_dfa; /* Current DFA */
struct _node *s_parent; /* Where to add next node */
} stackentry;
Field
Description
s_state
当前DFA中的状态ID
s_dfa
当前DFA指针
s_parent
当前的parent结点。PyParser会把新的结点作为Child加到栈顶状态的s_parent结点中去
PyParser调用下面这些函数来操作栈:
static void s_reset(stack *s);
#define s_empty(s) ((s)->s_top == &(s)->s_base[MAXSTACK])
static int s_push(register stack *s, dfa *d, node *parent)
#define s_pop(s) (s)->s_top++
这些函数的实现非常简单,不再赘述。
PyParser所支持的“成员”函数如下:
parser_state *PyParser_New(grammar *g, int start);
void PyParser_Delete(parser_state *ps);
int PyParser_AddToken(parser_state *ps, int type, char *str,
int lineno, int col_offset,int *expected_ret);
void PyGrammar_AddAccelerators(grammar *g);
PyParser_New & PyParser_Delete显然是用于创建和销毁PyParser的实例的,和PyTokenizer一致。PyGrammar_AddAccelerators在我的前一篇Python源码研究4中提到过,主要用于处理Python的Grammar数据生成Accelerator加快语法分析的速度。在这些函数中,最为核心的是PyParser_AddToken,这个函数的作用是根据PyTokenizer所获得的token和当前所处的状态/DFA,跳转到下一个状态,并添加到CST中。在parsetok函数中,有如下的代码(省略了大部分):
parser_state *ps;
ps = PyParser_New(g, start);
for (;;) {
char *a, *b;
int type;
type = PyTokenizer_Get(tok, &a, &b);
PyParser_AddToken(ps, (int)type, str, tok->lineno, col_offset, &(err_ret->expected));
}
Parsetok的作用是分析某段代码。可以看到,parsetok会反复调用PyTokenizer_Get获得下一个token,然后将反复将获得的token传给PyParser_AddToken来逐步构造整个CST,当所有token都处理过了之后,整棵树也就建立完毕了。
PyParser API
Python不会直接调用PyParser和PyTokenizer的函数,而是直接调用下面的这些Python API:
PyAPI_FUNC(node *) PyParser_ParseString(const char *, grammar *, int,
perrdetail *);
PyAPI_FUNC(node *) PyParser_ParseFile (FILE *, const char *, grammar *, int,
char *, char *, perrdetail *);
PyAPI_FUNC(node *) PyParser_ParseStringFlags(const char *, grammar *, int,
perrdetail *, int);
PyAPI_FUNC(node *) PyParser_ParseFileFlags(FILE *, const char *, grammar *,
int, char *, char *,
perrdetail *, int);
PyAPI_FUNC(node *) PyParser_ParseStringFlagsFilename(const char *,
const char *,
grammar *, int,
perrdetail *, int);
/* Note that he following function is defined in pythonrun.c not parsetok.c. */
PyAPI_FUNC(void) PyParser_SetError(perrdetail *);
PyAPI_FUNC宏是用于定义公用的Python API,表明这些函数可以被外界调用。在Windows上面Python Core被编译成一个DLL,因此PyAPI_FUNC等价于大家常用的__declspec(dllexport)/__declspec(dllimport)。这些函数把PyParser和PyTokenizer对象的接口和细节包装起来,使用者可以直接调用PyParser_ParseXXXX函数来使用PyParser和PyTokenizer的功能而无需知道PyPaser/PyTokenizer的工作方式,这可以看作是一个典型的Façade模式。以PyParser_ParseFile为例,该函数分析传入的FILE返回生成的CST。其他的函数与此类似,只是分析的对象不同和传入参数的不同。
PyParser_AddToken implementation
在全面了解了PyParser的接口和调用方式之后,我们来看一下PyParser_AddToken的具体实现。PyParser_AddToken会调用3个内部函数来做处理:classify, push, shift
Classify根据type和str,确定对应的Label,实现如下:
static int
classify(parser_state *ps, int type, char *str)
{
grammar *g = ps->p_grammar;
register int n = g->g_ll.ll_nlabels;
if (type == NAME) {
register char *s = str;
register label *l = g->g_ll.ll_label;
register int i;
for (i = n; i > 0; i--, l++) {
if (l->lb_type != NAME || l->lb_str == NULL ||
l->lb_str[0] != s[0] ||
strcmp(l->lb_str, s) != 0)
continue;
#ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD
if (!(ps->p_flags & CO_FUTURE_WITH_STATEMENT)) {
if (s[0] == 'w' && strcmp(s, "with") == 0)
break; /* not a keyword yet */
else if (s[0] == 'a' && strcmp(s, "as") == 0)
break; /* not a keyword yet */
}
#endif
D(printf("It's a keyword/n"));
return n - i;
}
}
{
register label *l = g->g_ll.ll_label;
register int i;
for (i = n; i > 0; i--, l++) {
if (l->lb_type == type && l->lb_str == NULL) {
D(printf("It's a token we know/n"));
return n - i;
}
}
}
D(printf("Illegal token/n"));
return -1;
}
可以看到classify作了一些针对NAME的特殊处理。有两种NAME,一种是标示符,一种是关键字。语法图中标示符的str是NULL(因为在语法图中无法实现知道标示符的内容,也不用知道),而关键字的str是有值的,不同的关键字对应着不同的语句,因此需要进行比较。classify首先处理关键字的情况,如果不是关键字则当普通情况下处理。两种情况下都需要遍历整个LabelList来确定Label的ID,唯一不同的是关键字的情况下需要比较具体的str内容而其他情况下无须比较。这里的效率看起来还是有改进的余地,在非关键字情况下可以用一个数组来做索引,直接根据type查找到id。在关键字的情况下至少可以把关键字作为一个单独的Token/非终结符来识别,这样就不用和普通标示符的情况弄混了,而目前的实现即使是普通标示符也会进到第一个if语句中进行关键字的判断。还可以使用hash来快速查找等。
Shift改变当前栈顶的状态(注意并不跳转到另外的DFA,这个改变只限于单个DFA中,跳转到另外一个DFA需要调用push压栈),并把当前的type/str作为一个新的子结点加入到栈顶的s_parent结点,通常s_parent结点对应着当前的DFA的结点。
假设我们在DFA0中,当前栈顶为(DFA0, s1),type=NAME
NAME
DFA0: s0 -> s1 -> s2
从s1跳转到s2不会离开DFA0,不用进栈,只需改变当前(DFA0, s1)到(DFA0, s2)即可。
static int
shift(register stack *s, int type, char *str, int newstate, int lineno, int col_offset)
{
int err;
assert(!s_empty(s));
err = PyNode_AddChild(s->s_top->s_parent, type, str, lineno, col_offset);
if (err)
return err;
s->s_top->s_state = newstate;
return 0;
}
Push同样也会把type/str作为新的子结点n加入到当前s_parent结点并改变当前栈顶的状态为newstate。但是newstate并非是下一个状态,而是当新的DFA遍历完毕之后退栈才会到。然后,把目标DFA压栈。新生成的子结点n作为新的s_parent。
还是举一个例子比较容易说明这个过程:
‘a’
DFA 1: s0 -> s1
DFA1
DFA 0: s1 -> s2
假设当前我们处于(DFA0, s1), type/str告诉我们下一个状态为s2,label是非终结符DFA1,对应着DFA1,因此我们会把当前栈顶(DFA0, s1)修改为(DFA0, s2),然后跳转到DFA1中进行匹配,同时(DFA1, s0)作为新的栈顶压栈,当(DFA1,s0)退栈之后,说明DFA1匹配完毕,回到(DFA0, s2)。
具体的实现如下:
static int
push(register stack *s, int type, dfa *d, int newstate, int lineno, int col_offset)
{
int err;
register node *n;
n = s->s_top->s_parent;
assert(!s_empty(s));
err = PyNode_AddChild(n, type, (char *)NULL, lineno, col_offset);
if (err)
return err;
s->s_top->s_state = newstate;
return s_push(s, d, CHILD(n, NCH(n)-1));
}
在讨论完这些函数之后就可以开始着手研究PyParser_AddToken的实现了:
int
PyParser_AddToken(register parser_state *ps, register int type, char *str,
int lineno, int col_offset, int *expected_ret)
{
register int ilabel;
int err;
D(printf("Token %s/'%s' ... ", _PyParser_TokenNames[type], str));
/* Find out which label this token is */
ilabel = classify(ps, type, str);
if (ilabel < 0)
return E_SYNTAX;
PyParser_AddToken第一步是根据type和str,调用classify获得对应的label。
PyParser_AddToken获得了对应的label之后,进入一个for loop:
/* Loop until the token is shifted or an error occurred */
for (;;) {
/* Fetch the current dfa and state */
register dfa *d = ps->p_stack.s_top->s_dfa;
register state *s = &d->d_state[ps->p_stack.s_top->s_state];
D(printf(" DFA '%s', state %d:",
d->d_name, ps->p_stack.s_top->s_state));
这个for loop反复拿到当前栈顶,也就是DFA和DFA状态,然后根据当前的状态和Label决定下一步的动作。基本的规则如下:
/* Check accelerator */
if (s->s_lower <= ilabel && ilabel < s->s_upper) {
register int x = s->s_accel[ilabel - s->s_lower];
有对应的Accelerator,为x
1. X第8位为1,说明x对应着一个非终结符,记录着目标状态的DFA ID和状态
DFA ID
1
目标状态,7bit
在这种情况下会跳转到另外一个DFA,把目标DFA+状态压栈。
if (x != -1) {
if (x & (1<<7)) {
/* Push non-terminal */
int nt = (x >> 8) + NT_OFFSET;
int arrow = x & ((1<<7)-1);
dfa *d1 = PyGrammar_FindDFA(
ps->p_grammar, nt);
if ((err = push(&ps->p_stack, nt, d1,
arrow, lineno, col_offset)) > 0) {
D(printf(" MemError: push/n"));
return err;
}
D(printf(" Push .../n"));
continue;
}
2. 否则,x对应终结符,调用Shift来改变栈顶的状态并把结点添加到CST中。如果栈顶对应着一个Accept状态的话,说明当前DFA已经匹配完毕,反复退栈直到当前状态不为Accept状态为止。
/* Shift the token */
if ((err = shift(&ps->p_stack, type, str,
x, lineno, col_offset)) > 0) {
D(printf(" MemError: shift./n"));
return err;
}
D(printf(" Shift./n"));
/* Pop while we are in an accept-only state */
while (s = &d->d_state
[ps->p_stack.s_top->s_state],
s->s_accept && s->s_narcs == 1) {
D(printf(" DFA '%s', state %d: "
"Direct pop./n",
d->d_name,
ps->p_stack.s_top->s_state));
#ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD
if (d->d_name[0] == 'i' &&
strcmp(d->d_name,
"import_stmt") == 0)
future_hack(ps);
#endif
s_pop(&ps->p_stack);
if (s_empty(&ps->p_stack)) {
D(printf(" ACCEPT./n"));
return E_DONE;
}
d = ps->p_stack.s_top->s_dfa;
}
return E_OK;
如果没有Acclerator,有可能该结点已经是Accept状态,同样退栈:
if (s->s_accept) {
#ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD
if (d->d_name[0] == 'i' &&
strcmp(d->d_name, "import_stmt") == 0)
future_hack(ps);
#endif
/* Pop this dfa and try again */
s_pop(&ps->p_stack);
D(printf(" Pop .../n"));
if (s_empty(&ps->p_stack)) {
D(printf(" Error: bottom of stack./n"));
return E_SYNTAX;
}
continue;
}
否则,语法错误,假如可能遇到的token只有一种可能的话,设置expected_ret为当前我们所期望看到的token,这样Python才可以显示语法错误信息。
/* Stuck, report syntax error */
D(printf(" Error./n"));
if (expected_ret) {
if (s->s_lower == s->s_upper - 1) {
/* Only one possible expected token */
*expected_ret = ps->p_grammar->
g_ll.ll_label[s->s_lower].lb_type;
}
else
*expected_ret = -1;
}
return E_SYNTAX;
至此PyParser已经分析完毕。下一篇文章将着重分析从CST到AST转换过程。
作者: ATField
E-Mail: atfield_zhang@hotmail.com
Blog: http://blog.csdn.net/atfield
- Python源码分析5 – 语法分析器PyParser
- Python源码分析5 – 语法分析器PyParser
- Python源码分析5 – 语法分析器PyParser
- Python源码分析3 – 词法分析器PyTokenizer
- Python源码分析3 – 词法分析器PyTokenizer
- Python源码分析3 – 词法分析器PyTokenizer
- hive原理与源码分析-语法分析器和语义分析器(二)
- lucene4.5源码分析系列:分析器
- Python源码分析3 – 词法分析器PyTokenizer http://blog.csdn.net/atfield/article/details/1439068
- 语法分析器---预测分析程序
- 语法分析器 (基于预测分析表)
- 语法分析器
- 语法分析器
- 语法分析器
- 语法分析器
- 语法分析器
- C语言版 计算器-词法分析器-源码分析
- Java实现C的语法分析器(预测分析法)
- CSS学习笔记
- 酒与美年达
- 关于继承的方法和变量
- sudo使用小记
- String与StringBuffer
- Python源码分析5 – 语法分析器PyParser
- 关于权限的理解
- 如何点击按钮弹出新窗口,输入数据后返回并刷新页面?
- C#学习之路
- xoWidgets 数据类型和数据结构
- Windows CMD命令大全
- 第一次开始
- 不允许一个变量声明语句作为一条语句在for、while 或do中
- 杰出的程序员人生在于有无目标