mirror of
https://github.com/python/cpython.git
synced 2025-09-26 18:29:57 +00:00
Untabify C files. Will watch buildbots.
This commit is contained in:
Antoine Pitrou
parent
368ede83d9
commit
c83ea137d7
318 changed files with 198669 additions and 198669 deletions
532
Parser/parser.c
532
Parser/parser.c
|
|
@ -29,7 +29,7 @@ static void s_reset(stack *);
|
|||
static void
|
||||
s_reset(stack *s)
|
||||
{
|
||||
s->s_top = &s->s_base[MAXSTACK];
|
||||
s->s_top = &s->s_base[MAXSTACK];
|
||||
}
|
||||
|
||||
#define s_empty(s) ((s)->s_top == &(s)->s_base[MAXSTACK])
|
||||
|
|
@ -37,16 +37,16 @@ s_reset(stack *s)
|
|||
static int
|
||||
s_push(register stack *s, dfa *d, node *parent)
|
||||
{
|
||||
register stackentry *top;
|
||||
if (s->s_top == s->s_base) {
|
||||
fprintf(stderr, "s_push: parser stack overflow\n");
|
||||
return E_NOMEM;
|
||||
}
|
||||
top = --s->s_top;
|
||||
top->s_dfa = d;
|
||||
top->s_parent = parent;
|
||||
top->s_state = 0;
|
||||
return 0;
|
||||
register stackentry *top;
|
||||
if (s->s_top == s->s_base) {
|
||||
fprintf(stderr, "s_push: parser stack overflow\n");
|
||||
return E_NOMEM;
|
||||
}
|
||||
top = --s->s_top;
|
||||
top->s_dfa = d;
|
||||
top->s_parent = parent;
|
||||
top->s_state = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef Py_DEBUG
|
||||
|
|
@ -54,9 +54,9 @@ s_push(register stack *s, dfa *d, node *parent)
|
|||
static void
|
||||
s_pop(register stack *s)
|
||||
{
|
||||
if (s_empty(s))
|
||||
Py_FatalError("s_pop: parser stack underflow -- FATAL");
|
||||
s->s_top++;
|
||||
if (s_empty(s))
|
||||
Py_FatalError("s_pop: parser stack underflow -- FATAL");
|
||||
s->s_top++;
|
||||
}
|
||||
|
||||
#else /* !Py_DEBUG */
|
||||
|
|
@ -71,34 +71,34 @@ s_pop(register stack *s)
|
|||
parser_state *
|
||||
PyParser_New(grammar *g, int start)
|
||||
{
|
||||
parser_state *ps;
|
||||
|
||||
if (!g->g_accel)
|
||||
PyGrammar_AddAccelerators(g);
|
||||
ps = (parser_state *)PyMem_MALLOC(sizeof(parser_state));
|
||||
if (ps == NULL)
|
||||
return NULL;
|
||||
ps->p_grammar = g;
|
||||
parser_state *ps;
|
||||
|
||||
if (!g->g_accel)
|
||||
PyGrammar_AddAccelerators(g);
|
||||
ps = (parser_state *)PyMem_MALLOC(sizeof(parser_state));
|
||||
if (ps == NULL)
|
||||
return NULL;
|
||||
ps->p_grammar = g;
|
||||
#ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD
|
||||
ps->p_flags = 0;
|
||||
ps->p_flags = 0;
|
||||
#endif
|
||||
ps->p_tree = PyNode_New(start);
|
||||
if (ps->p_tree == NULL) {
|
||||
PyMem_FREE(ps);
|
||||
return NULL;
|
||||
}
|
||||
s_reset(&ps->p_stack);
|
||||
(void) s_push(&ps->p_stack, PyGrammar_FindDFA(g, start), ps->p_tree);
|
||||
return ps;
|
||||
ps->p_tree = PyNode_New(start);
|
||||
if (ps->p_tree == NULL) {
|
||||
PyMem_FREE(ps);
|
||||
return NULL;
|
||||
}
|
||||
s_reset(&ps->p_stack);
|
||||
(void) s_push(&ps->p_stack, PyGrammar_FindDFA(g, start), ps->p_tree);
|
||||
return ps;
|
||||
}
|
||||
|
||||
void
|
||||
PyParser_Delete(parser_state *ps)
|
||||
{
|
||||
/* NB If you want to save the parse tree,
|
||||
you must set p_tree to NULL before calling delparser! */
|
||||
PyNode_Free(ps->p_tree);
|
||||
PyMem_FREE(ps);
|
||||
/* NB If you want to save the parse tree,
|
||||
you must set p_tree to NULL before calling delparser! */
|
||||
PyNode_Free(ps->p_tree);
|
||||
PyMem_FREE(ps);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -107,27 +107,27 @@ PyParser_Delete(parser_state *ps)
|
|||
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;
|
||||
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;
|
||||
}
|
||||
|
||||
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));
|
||||
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));
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -136,189 +136,189 @@ push(register stack *s, int type, dfa *d, int newstate, int lineno, int col_offs
|
|||
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;
|
||||
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_PRINT_FUNCTION &&
|
||||
s[0] == 'p' && strcmp(s, "print") == 0) {
|
||||
break; /* no longer a keyword */
|
||||
}
|
||||
if (ps->p_flags & CO_FUTURE_PRINT_FUNCTION &&
|
||||
s[0] == 'p' && strcmp(s, "print") == 0) {
|
||||
break; /* no longer a keyword */
|
||||
}
|
||||
#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;
|
||||
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;
|
||||
}
|
||||
|
||||
#ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD
|
||||
static void
|
||||
future_hack(parser_state *ps)
|
||||
{
|
||||
node *n = ps->p_stack.s_top->s_parent;
|
||||
node *ch, *cch;
|
||||
int i;
|
||||
node *n = ps->p_stack.s_top->s_parent;
|
||||
node *ch, *cch;
|
||||
int i;
|
||||
|
||||
/* from __future__ import ..., must have at least 4 children */
|
||||
n = CHILD(n, 0);
|
||||
if (NCH(n) < 4)
|
||||
return;
|
||||
ch = CHILD(n, 0);
|
||||
if (STR(ch) == NULL || strcmp(STR(ch), "from") != 0)
|
||||
return;
|
||||
ch = CHILD(n, 1);
|
||||
if (NCH(ch) == 1 && STR(CHILD(ch, 0)) &&
|
||||
strcmp(STR(CHILD(ch, 0)), "__future__") != 0)
|
||||
return;
|
||||
ch = CHILD(n, 3);
|
||||
/* ch can be a star, a parenthesis or import_as_names */
|
||||
if (TYPE(ch) == STAR)
|
||||
return;
|
||||
if (TYPE(ch) == LPAR)
|
||||
ch = CHILD(n, 4);
|
||||
|
||||
for (i = 0; i < NCH(ch); i += 2) {
|
||||
cch = CHILD(ch, i);
|
||||
if (NCH(cch) >= 1 && TYPE(CHILD(cch, 0)) == NAME) {
|
||||
char *str_ch = STR(CHILD(cch, 0));
|
||||
if (strcmp(str_ch, FUTURE_WITH_STATEMENT) == 0) {
|
||||
ps->p_flags |= CO_FUTURE_WITH_STATEMENT;
|
||||
} else if (strcmp(str_ch, FUTURE_PRINT_FUNCTION) == 0) {
|
||||
ps->p_flags |= CO_FUTURE_PRINT_FUNCTION;
|
||||
} else if (strcmp(str_ch, FUTURE_UNICODE_LITERALS) == 0) {
|
||||
ps->p_flags |= CO_FUTURE_UNICODE_LITERALS;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* from __future__ import ..., must have at least 4 children */
|
||||
n = CHILD(n, 0);
|
||||
if (NCH(n) < 4)
|
||||
return;
|
||||
ch = CHILD(n, 0);
|
||||
if (STR(ch) == NULL || strcmp(STR(ch), "from") != 0)
|
||||
return;
|
||||
ch = CHILD(n, 1);
|
||||
if (NCH(ch) == 1 && STR(CHILD(ch, 0)) &&
|
||||
strcmp(STR(CHILD(ch, 0)), "__future__") != 0)
|
||||
return;
|
||||
ch = CHILD(n, 3);
|
||||
/* ch can be a star, a parenthesis or import_as_names */
|
||||
if (TYPE(ch) == STAR)
|
||||
return;
|
||||
if (TYPE(ch) == LPAR)
|
||||
ch = CHILD(n, 4);
|
||||
|
||||
for (i = 0; i < NCH(ch); i += 2) {
|
||||
cch = CHILD(ch, i);
|
||||
if (NCH(cch) >= 1 && TYPE(CHILD(cch, 0)) == NAME) {
|
||||
char *str_ch = STR(CHILD(cch, 0));
|
||||
if (strcmp(str_ch, FUTURE_WITH_STATEMENT) == 0) {
|
||||
ps->p_flags |= CO_FUTURE_WITH_STATEMENT;
|
||||
} else if (strcmp(str_ch, FUTURE_PRINT_FUNCTION) == 0) {
|
||||
ps->p_flags |= CO_FUTURE_PRINT_FUNCTION;
|
||||
} else if (strcmp(str_ch, FUTURE_UNICODE_LITERALS) == 0) {
|
||||
ps->p_flags |= CO_FUTURE_UNICODE_LITERALS;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* future keyword */
|
||||
|
||||
int
|
||||
PyParser_AddToken(register parser_state *ps, register int type, char *str,
|
||||
int lineno, int col_offset, int *expected_ret)
|
||||
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;
|
||||
|
||||
/* 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));
|
||||
|
||||
/* Check accelerator */
|
||||
if (s->s_lower <= ilabel && ilabel < s->s_upper) {
|
||||
register int x = s->s_accel[ilabel - s->s_lower];
|
||||
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;
|
||||
}
|
||||
|
||||
/* 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));
|
||||
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;
|
||||
|
||||
/* 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));
|
||||
|
||||
/* Check accelerator */
|
||||
if (s->s_lower <= ilabel && ilabel < s->s_upper) {
|
||||
register int x = s->s_accel[ilabel - s->s_lower];
|
||||
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;
|
||||
}
|
||||
|
||||
/* 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);
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
if (s->s_accept) {
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
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;
|
||||
}
|
||||
|
||||
/* 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;
|
||||
}
|
||||
/* 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;
|
||||
}
|
||||
|
||||
/* 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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -329,62 +329,62 @@ PyParser_AddToken(register parser_state *ps, register int type, char *str,
|
|||
void
|
||||
dumptree(grammar *g, node *n)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (n == NULL)
|
||||
printf("NIL");
|
||||
else {
|
||||
label l;
|
||||
l.lb_type = TYPE(n);
|
||||
l.lb_str = STR(n);
|
||||
printf("%s", PyGrammar_LabelRepr(&l));
|
||||
if (ISNONTERMINAL(TYPE(n))) {
|
||||
printf("(");
|
||||
for (i = 0; i < NCH(n); i++) {
|
||||
if (i > 0)
|
||||
printf(",");
|
||||
dumptree(g, CHILD(n, i));
|
||||
}
|
||||
printf(")");
|
||||
}
|
||||
}
|
||||
int i;
|
||||
|
||||
if (n == NULL)
|
||||
printf("NIL");
|
||||
else {
|
||||
label l;
|
||||
l.lb_type = TYPE(n);
|
||||
l.lb_str = STR(n);
|
||||
printf("%s", PyGrammar_LabelRepr(&l));
|
||||
if (ISNONTERMINAL(TYPE(n))) {
|
||||
printf("(");
|
||||
for (i = 0; i < NCH(n); i++) {
|
||||
if (i > 0)
|
||||
printf(",");
|
||||
dumptree(g, CHILD(n, i));
|
||||
}
|
||||
printf(")");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
showtree(grammar *g, node *n)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (n == NULL)
|
||||
return;
|
||||
if (ISNONTERMINAL(TYPE(n))) {
|
||||
for (i = 0; i < NCH(n); i++)
|
||||
showtree(g, CHILD(n, i));
|
||||
}
|
||||
else if (ISTERMINAL(TYPE(n))) {
|
||||
printf("%s", _PyParser_TokenNames[TYPE(n)]);
|
||||
if (TYPE(n) == NUMBER || TYPE(n) == NAME)
|
||||
printf("(%s)", STR(n));
|
||||
printf(" ");
|
||||
}
|
||||
else
|
||||
printf("? ");
|
||||
int i;
|
||||
|
||||
if (n == NULL)
|
||||
return;
|
||||
if (ISNONTERMINAL(TYPE(n))) {
|
||||
for (i = 0; i < NCH(n); i++)
|
||||
showtree(g, CHILD(n, i));
|
||||
}
|
||||
else if (ISTERMINAL(TYPE(n))) {
|
||||
printf("%s", _PyParser_TokenNames[TYPE(n)]);
|
||||
if (TYPE(n) == NUMBER || TYPE(n) == NAME)
|
||||
printf("(%s)", STR(n));
|
||||
printf(" ");
|
||||
}
|
||||
else
|
||||
printf("? ");
|
||||
}
|
||||
|
||||
void
|
||||
printtree(parser_state *ps)
|
||||
{
|
||||
if (Py_DebugFlag) {
|
||||
printf("Parse tree:\n");
|
||||
dumptree(ps->p_grammar, ps->p_tree);
|
||||
printf("\n");
|
||||
printf("Tokens:\n");
|
||||
showtree(ps->p_grammar, ps->p_tree);
|
||||
printf("\n");
|
||||
}
|
||||
printf("Listing:\n");
|
||||
PyNode_ListTree(ps->p_tree);
|
||||
printf("\n");
|
||||
if (Py_DebugFlag) {
|
||||
printf("Parse tree:\n");
|
||||
dumptree(ps->p_grammar, ps->p_tree);
|
||||
printf("\n");
|
||||
printf("Tokens:\n");
|
||||
showtree(ps->p_grammar, ps->p_tree);
|
||||
printf("\n");
|
||||
}
|
||||
printf("Listing:\n");
|
||||
PyNode_ListTree(ps->p_tree);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
#endif /* Py_DEBUG */
|
||||
|
|
@ -419,15 +419,15 @@ symbol.
|
|||
|
||||
As an example, consider this grammar:
|
||||
|
||||
expr: term (OP term)*
|
||||
term: CONSTANT | '(' expr ')'
|
||||
expr: term (OP term)*
|
||||
term: CONSTANT | '(' expr ')'
|
||||
|
||||
The DFA corresponding to the rule for expr is:
|
||||
|
||||
------->.---term-->.------->
|
||||
^ |
|
||||
| |
|
||||
\----OP----/
|
||||
^ |
|
||||
| |
|
||||
\----OP----/
|
||||
|
||||
The parse tree generated for the input a+b is:
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue