C++写的一个简单的语法分析器（分析C语言）

本程序实现一个分析C语言的词法分析+语法分析。

注意：

1.文法简略，没有实现的部分，可以在此文法的基础上进行扩充，本程序的采用自顶向下的LL(1)文法。

2.可以自动实现求First 集和 Follow 集。

3.处终结符外（有些硬编码的成分），终结符的文法可以自定义，也就是说读者可以自定义文法。

4.为方便理解，C语言的文法描述写成中文。

5.程序将词法分析和语法分析结合起来，词法分析的结果作为语法分析的输入。

6.最终结果在控制台显示的有：词法分析、First集、Follow集、Select集，在preciateResult.txt 中写入了语法分析结果，在preciateTable.txt 中写入了预测分析表。

7.文法的词素之间必须有空格分开。

项目结构如下：

文法如下：

wenfa.txt:

<函数定义> -> <修饰词闭包> <类型> <变量> ( <参数声明> ) { <函数块> }
<修饰词闭包> -> <修饰词> <修饰词闭包> | $
<修饰词> -> describe
<类型> -> type <取地址>
<取地址> -> <星号闭包>
<星号闭包> -> <星号> <星号闭包> | $
<星号> -> *
<变量> -> <标志符> <数组下标>
<标志符> -> id
<数组下标> -> [ <因式> ] | $
<因式> -> ( <表达式> ) | <变量> | <数字>
<数字> -> digit
<表达式> -> <因子> <项>
<因子> -> <因式> <因式递归>
<因式递归> -> * <因式> <因式递归> | / <因式> <因式递归> | $
<项> -> + <因子> <项> | - <因子> <项> | $
<参数声明> -> <声明> <声明闭包> | $
<声明> -> <修饰词闭包> <类型> <变量> <赋初值>
<赋初值> -> = <右值> | $
<右值> -> <表达式> | { <多个数据> }
<多个数据> -> <数字> <数字闭包>
<数字闭包> -> , <数字> <数字闭包> | $
<声明闭包> -> , <声明> <声明闭包> | $
<函数块> -> <声明语句闭包> <函数块闭包>
<声明语句闭包> -> <声明语句> <声明语句闭包> | $
<声明语句> -> <声明> ;
<函数块闭包> -> <赋值函数> <函数块闭包> |  <函数块闭包> | <条件语句> <函数块闭包> | <函数返回> <函数块闭包> | $
<赋值函数> -> <变量> <赋值或函数调用>
<赋值或函数调用> -> = <右值> ; | ( <参数列表> ) ;
<参数列表> -> <参数> <参数闭包>
<参数闭包> -> , <参数> <参数闭包> | $
<参数> -> <标志符> | <数字> | <字符串>
<字符串> -> string
 -> for ( <赋值函数> <逻辑表达式> ; <后缀表达式> ) { <函数块> }
<逻辑表达式> -> <表达式> <逻辑运算符> <表达式>
<逻辑运算符> -> < | > | == | !=
<后缀表达式> -> <变量> <后缀运算符>
<后缀运算符> -> ++ | --
<条件语句> -> if ( <逻辑表达式> ) { <函数块> } <否则语句>
<否则语句> -> else { <函数块> } | $
<函数返回> -> return <因式> ;

词法分析头文件：

LexAnalysis.h

//LexAnalysis.h
#ifndef _LEXANALYSIS_H
#define _LEXANALYSIS_H

//关键字
#define AUTO 1
#define BREAK 2
#define CASE 3
#define CHAR 4
#define CONST 5
#define CONTINUE 6
#define DEFAULT 7
#define DO 8
#define DOUBLE 9
#define ELSE 10
#define ENUM 11
#define EXTERN 12
#define FLOAT 13
#define FOR 14
#define GOTO 15
#define IF 16
#define INT 17
#define LONG 18
#define REGISTER 19
#define RETURN 20
#define SHORT 21
#define SIGNED 22
#define SIZEOF 23
#define STATIC 24
#define STRUCT 25
#define SWITCH 26
#define TYPEDEF 27
#define UNION 28
#define UNSIGNED 29
#define VOID 30
#define VOLATILE 31
#define WHILE 32
#define KEY_DESC "关键字"

//标志符
#define IDENTIFER 40
#define IDENTIFER_DESC "标志符"

//常量
#define INT_VAL 51 //整形常量
#define CHAR_VAL 52 //字符常量
#define FLOAT_VAL 53 //浮点数常量
#define STRING_VAL 54 //双精度浮点数常量
#define MACRO_VAL 55 //宏常量
#define CONSTANT_DESC "常量"

//运算符
#define NOT 61   // !
#define BYTE_AND 62 //&
#define COMPLEMENT 63 // ~
#define BYTE_XOR  64 // ^
#define MUL 65 // *
#define DIV 66// /
#define MOD 67 // %
#define ADD 68 // +
#define SUB 69 // -
#define LES_THAN 70 // <
#define GRT_THAN 71 // >
#define ASG 72 // =
#define ARROW 73 // ->
#define SELF_ADD 74 // ++
#define SELF_SUB 75 // --
#define LEFT_MOVE 76 // <<
#define RIGHT_MOVE 77 // >>
#define LES_EQUAL 78 // <=
#define GRT_EQUAL 79 // >=
#define EQUAL 80 // ==
#define NOT_EQUAL 81 // !=
#define AND 82 // &&
#define OR 83 // ||
#define COMPLETE_ADD 84 // +=
#define COMPLETE_SUB 85 // -=
#define COMPLETE_MUL 86 // *=
#define COMPLETE_DIV 87 // /=
#define COMPLETE_BYTE_XOR 88 // ^=
#define COMPLETE_BYTE_AND 89 // &=
#define COMPLETE_COMPLEMENT 90 // ~=
#define COMPLETE_MOD 91 //%=
#define BYTE_OR 92 // |

#define OPE_DESC "运算符"

//限界符
#define LEFT_BRA 100 // (
#define RIGHT_BRA 101 // )
#define LEFT_INDEX 102 // [
#define RIGHT_INDEX 103 // ]
#define L_BOUNDER 104 //  {
#define R_BOUNDER 105 // }
#define POINTER 106 // .
#define JING 107 // #
#define UNDER_LINE 108 // _
#define COMMA 109 // ,
#define SEMI 110 // ;
#define SIN_QUE 111 // '
#define DOU_QUE 112 // "

#define CLE_OPE_DESC "限界符"

#define NOTE1 120 // "/**/"注释
#define NOTE2 121 // "//"注释
#define NOTE_DESC "注释"


#define HEADER 130 //头文件
#define HEADER_DESC "头文件"

//错误类型
#define FLOAT_ERROR "float表示错误"
#define FLOAT_ERROR_NUM 1
#define DOUBLE_ERROR "double表示错误"
#define DOUBLE_ERROR_NUM 2
#define NOTE_ERROR "注释没有结束符"
#define NOTE_ERROR_NUM 3
#define STRING_ERROR "字符串常量没有结束符"
#define STRING_ERROR_NUM 4
#define CHARCONST_ERROR "字符常量没有结束符"
#define CHARCONST_ERROR_NUM 5
#define CHAR_ERROR "非法字符"
#define CHAR_ERROR_NUM 6
#define LEFT_BRA_ERROR "'('没有对应项"
#define LEFT_BRA_ERROR_NUM 7
#define RIGHT_BRA_ERROR "')'没有对应项"
#define RIGHT_BRA_ERROR_NUM 8
#define LEFT_INDEX_ERROR "'['没有对应项"
#define LEFT_INDEX_ERROR_NUM 9
#define RIGHT_INDEX_ERROR "']'没有对应项"
#define RIGHT_INDEX_ERROR_NUM 10
#define L_BOUNDER_ERROR "'{'没有对应项"
#define L_BOUNDER_ERROR_NUM 11
#define R_BOUNDER_ERROR "'}'没有对应项"
#define R_BOUNDER_ERROR_NUM 12
#define PRE_PROCESS_ERROR "预处理错误" //头文件或者宏定义错误
#define PRE_PROCESS_ERROR_NUM  13

#define _NULL "无"

#define DESCRIBE 4000
#define TYPE 4001
#define STRING 4002
#define DIGIT 4003

struct NormalNode
{
    char content[30];//内容
    char describe[30];//描述
    int type;//种别码
    int addr;//入口地址
    int line;//所在行数
    NormalNode * next;//下一个节点
};

void initKeyMapping();
void initOperMapping();
void initLimitMapping();

void initNode();
void createNewNode(char * content,char *descirbe,int type,int addr,int line);
void createNewError(char * content,char *descirbe,int type,int line);
int createNewIden(char * content,char *descirbe,int type,int addr,int line);
void printNodeLink();
void printErrorLink();
void printIdentLink();
int mystrlen(char * word);
void preProcess(char * word,int line);
void close();
int seekKey(char * word);
void scanner();
void BraMappingError();


#endif

语法分析头文件：

SynAnalysis.h

//SynAnalysis.h
#ifndef _SYNANALYSIS_H
#define _SYNANALYSIS_H

#define GRAMMAR_ARROW 2000 //->
#define GRAMMAR_OR 2001 // |
#define GRAMMAR_NULL 2002 //空值
#define GRAMMAR_SPECIAL 2003 //特殊符号#
#define GRAMMAR_BASE 2010 //动态生成的基值

#define Stack_Size 5000

typedef struct
{
    int elem[Stack_Size];
    int top;
} SeqStack;

void initGrammer();
int seekCodeNum(char * word);
void ceshi();
void First();
void Follow();
void Select();
void MTable();
void Analysis();
#endif

词法分析Cpp文件：(与先前写过的一片博客相类似，改了部分)

LexAnalysis.cpp

//LexAnalysis.cpp
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "LexAnalysis.h"

using namespace std;

int leftSmall = 0;//左小括号
int rightSmall = 0;//右小括号
int leftMiddle = 0;//左中括号
int rightMiddle = 0;//右中括号
int leftBig = 0;//左大括号
int rightBig = 0;//右大括号
int lineBra[6][1000] = {0};//括号和行数的对应关系，第一维代表左右6种括号
int static_iden_number = 0;//模拟标志符的地址，自增
//Token节点


NormalNode * normalHead;//首结点

//错误节点
struct ErrorNode
{
    char content[30];//错误内容
    char describe[30];//错误描述
    int type;
    int line;//所在行数
    ErrorNode * next;//下一个节点
};

ErrorNode * errorHead;//首节点

//标志符节点
struct IdentiferNode
{
    char content[30];//内容
    char describe[30];//描述
    int type;//种别码
    int addr;//入口地址
    int line;//所在行数
    IdentiferNode * next;//下一个节点
};
IdentiferNode * idenHead;//首节点

vector > keyMap;
vector > operMap;
vector > limitMap;



//初始化C语言的关键字的集合
void initKeyMapping()
{
    keyMap.clear();
    keyMap.push_back(make_pair("auto",AUTO));
    keyMap.push_back(make_pair("break",BREAK));
    keyMap.push_back(make_pair("case",CASE));
    keyMap.push_back(make_pair("char",CHAR));
    keyMap.push_back(make_pair("const",CONST));
    keyMap.push_back(make_pair("continue",CONTINUE));
    keyMap.push_back(make_pair("default",DEFAULT));
    keyMap.push_back(make_pair("do",DO));
    keyMap.push_back(make_pair("double",DOUBLE));
    keyMap.push_back(make_pair("else",ELSE));
    keyMap.push_back(make_pair("enum",ENUM));
    keyMap.push_back(make_pair("extern",EXTERN));
    keyMap.push_back(make_pair("float",FLOAT));
    keyMap.push_back(make_pair("for",FOR));
    keyMap.push_back(make_pair("goto",GOTO));
    keyMap.push_back(make_pair("if",IF));
    keyMap.push_back(make_pair("int",INT));
    keyMap.push_back(make_pair("long",LONG));
    keyMap.push_back(make_pair("register",REGISTER));
    keyMap.push_back(make_pair("return",RETURN));
    keyMap.push_back(make_pair("short",SHORT));
    keyMap.push_back(make_pair("signed",SIGNED));
    keyMap.push_back(make_pair("sizeof",SIZEOF));
    keyMap.push_back(make_pair("static",STATIC));
    keyMap.push_back(make_pair("struct",STRUCT));
    keyMap.push_back(make_pair("switch",SWITCH));
    keyMap.push_back(make_pair("typedef",TYPEDEF));
    keyMap.push_back(make_pair("union",UNION));
    keyMap.push_back(make_pair("unsigned",UNSIGNED));
    keyMap.push_back(make_pair("void",VOID));
    keyMap.push_back(make_pair("volatile",VOLATILE));
    keyMap.push_back(make_pair("while",WHILE));

    keyMap.push_back(make_pair("describe",DESCRIBE));
    keyMap.push_back(make_pair("type",TYPE));
    keyMap.push_back(make_pair("string",STRING));
    keyMap.push_back(make_pair("digit",DIGIT));
}
void initOperMapping()
{
    operMap.clear();
    operMap.push_back(make_pair("!",NOT));
    operMap.push_back(make_pair("&",BYTE_AND));
    operMap.push_back(make_pair("~",COMPLEMENT));
    operMap.push_back(make_pair("^",BYTE_XOR));
    operMap.push_back(make_pair("*",MUL));
    operMap.push_back(make_pair("/",DIV));
    operMap.push_back(make_pair("%",MOD));
    operMap.push_back(make_pair("+",ADD));
    operMap.push_back(make_pair("-",SUB));
    operMap.push_back(make_pair("<",LES_THAN));
    operMap.push_back(make_pair(">",GRT_THAN));
    operMap.push_back(make_pair("=",ASG));
    operMap.push_back(make_pair("->",ARROW));
    operMap.push_back(make_pair("++",SELF_ADD));
    operMap.push_back(make_pair("--",SELF_SUB));
    operMap.push_back(make_pair("<<",LEFT_MOVE));
    operMap.push_back(make_pair(">>",RIGHT_MOVE));
    operMap.push_back(make_pair("<=",LES_EQUAL));
    operMap.push_back(make_pair(">=",GRT_EQUAL));
    operMap.push_back(make_pair("==",EQUAL));
    operMap.push_back(make_pair("!=",NOT_EQUAL));
    operMap.push_back(make_pair("&&",AND));
    operMap.push_back(make_pair("||",OR));
    operMap.push_back(make_pair("+=",COMPLETE_ADD));
    operMap.push_back(make_pair("-=",COMPLETE_SUB));
    operMap.push_back(make_pair("*=",COMPLETE_MUL));
    operMap.push_back(make_pair("/=",COMPLETE_DIV));
    operMap.push_back(make_pair("^=",COMPLETE_BYTE_XOR));
    operMap.push_back(make_pair("&=",COMPLETE_BYTE_AND));
    operMap.push_back(make_pair("~=",COMPLETE_COMPLEMENT));
    operMap.push_back(make_pair("%=",COMPLETE_MOD));
    operMap.push_back(make_pair("|",BYTE_OR));
}
void initLimitMapping()
{
    limitMap.clear();
    limitMap.push_back(make_pair("(",LEFT_BRA));
    limitMap.push_back(make_pair(")",RIGHT_BRA));
    limitMap.push_back(make_pair("[",LEFT_INDEX));
    limitMap.push_back(make_pair("]",RIGHT_INDEX));
    limitMap.push_back(make_pair("{",L_BOUNDER));
    limitMap.push_back(make_pair("}",R_BOUNDER));
    limitMap.push_back(make_pair(".",POINTER));
    limitMap.push_back(make_pair("#",JING));
    limitMap.push_back(make_pair("_",UNDER_LINE));
    limitMap.push_back(make_pair(",",COMMA));
    limitMap.push_back(make_pair(";",SEMI));
    limitMap.push_back(make_pair("'",SIN_QUE));
    limitMap.push_back(make_pair("\"",DOU_QUE));
}
void initNode()
{
    normalHead = new NormalNode();
    strcpy(normalHead->content,"");
    strcpy(normalHead->describe,"");
    normalHead->type = -1;
    normalHead->addr = -1;
    normalHead->line = -1;
    normalHead->next = NULL;

    errorHead = new ErrorNode();
    strcpy(errorHead->content,"");
    strcpy(errorHead->describe,"");
    errorHead->line = -1;
    errorHead->next = NULL;

    idenHead = new IdentiferNode();
    strcpy(idenHead->content,"");
    strcpy(idenHead->describe,"");
    idenHead->type = -1;
    idenHead->addr = -1;
    idenHead->line = -1;
    idenHead->next = NULL;
}

void createNewNode(char * content,char *descirbe,int type,int addr,int line)
{
    NormalNode * p = normalHead;
    NormalNode * temp = new NormalNode();

    while(p->next!=NULL)
    {
        p = p->next;
    }

    strcpy(temp->content,content);
    strcpy(temp->describe,descirbe);
    temp->type = type;
    temp->addr = addr;
    temp->line = line;
    temp->next = NULL;

    p->next = temp;
}
void createNewError(char * content,char *descirbe,int type,int line)
{
    ErrorNode * p = errorHead;
    ErrorNode * temp = new ErrorNode();

    strcpy(temp->content,content);
    strcpy(temp->describe,descirbe);
    temp->type = type;
    temp->line = line;
    temp->next = NULL;
    while(p->next!=NULL)
    {
        p = p->next;
    }
    p->next = temp;
}
//返回值是新的标志符的入口地址
int createNewIden(char * content,char *descirbe,int type,int addr,int line)
{
    IdentiferNode * p = idenHead;
    IdentiferNode * temp = new IdentiferNode();
    int flag = 0;
    int addr_temp = -2;
    while(p->next!=NULL)
    {
        if(strcmp(content,p->next->content) == 0)
        {
            flag = 1;
            addr_temp = p->next->addr;
        }
        p = p->next;
    }
    if(flag == 0)
    {
        addr_temp = ++static_iden_number;//用自增来模拟入口地址
    }
    strcpy(temp->content,content);
    strcpy(temp->describe,descirbe);
    temp->type = type;
    temp->addr = addr_temp;
    temp->line = line;
    temp->next = NULL;
    p->next = temp;
    return addr_temp;
}

void printNodeLink()
{
    NormalNode * p = normalHead;
    p = p->next;
    cout<<"************************************分析表******************************"<type == IDENTIFER)
        {
            cout<content<describe<<"\t"<type<<"\t"<addr<<"\t"<line<content<describe<<"\t"<type<<"\t"<<"\t"<line<next;
    }
    cout<next;
    cout<<"************************************错误表******************************"<content<describe<<"\t"<type<<"\t"<line<next;
    }
    cout<next;
    cout<<"************************************标志符表******************************"<content<describe<<"\t"<type<<"\t"<addr<<"\t"<line<next;
    }
    cout<='A' && ch<='Z') || (ch>='a' && ch<='z') || ch == '_')
        {
            while((ch>='A' && ch<='Z')||(ch>='a' && ch<='z')||(ch>='0' && ch<='9') || ch == '_')
            {
                array[i++] = ch;
                ch = fgetc(infile);
            }
            word = new char[i+1];
            memcpy(word,array,i);
            word[i] = '\0';
            int seekTemp = seekKey(word);
            if(seekTemp!=IDENTIFER)
            {
                createNewNode(word,KEY_DESC,seekTemp,-1,line);
            }
            else
            {
                int addr_tmp = createNewIden(word,IDENTIFER_DESC,seekTemp,-1,line);
                createNewNode(word,IDENTIFER_DESC,seekTemp,addr_tmp,line);
            }
            fseek(infile,-1L,SEEK_CUR);//向后回退一位
        }
        //以数字开头，处理数字
        else if(ch >='0' && ch<='9')
        {
            int flag = 0;
            int flag2 = 0;
            //处理整数
            while(ch >='0' && ch<='9')
            {
                array[i++] = ch;
                ch = fgetc(infile);
            }
            //处理float
            if(ch == '.')
            {
                flag2 = 1;
                array[i++] = ch;
                ch = fgetc(infile);
                if(ch>='0' && ch<='9')
                {
                    while(ch>='0' && ch<='9')
                    {
                        array[i++] = ch;
                        ch = fgetc(infile);
                    }
                }
                else
                {
                    flag = 1;
                }

                //处理Double
                if(ch == 'E' || ch == 'e')
                {
                    array[i++] = ch;
                    ch = fgetc(infile);
                    if(ch == '+' || ch == '-')
                    {
                        array[i++] = ch;
                        ch = fgetc(infile);
                    }
                    if(ch >='0' && ch<='9')
                    {
                        array[i++] = ch;
                        ch = fgetc(infile);
                    }
                    else
                    {
                        flag = 2;
                    }
                }

            }
            word = new char[i+1];
            memcpy(word,array,i);
            word[i] = '\0';
            if(flag == 1)
            {
                createNewError(word,FLOAT_ERROR,FLOAT_ERROR_NUM,line);
            }
            else if(flag == 2)
            {
                createNewError(word,DOUBLE_ERROR,DOUBLE_ERROR_NUM,line);
            }
            else
            {
                if(flag2 == 0)
                {
                    createNewNode(word,CONSTANT_DESC,INT_VAL,-1,line);
                }
                else
                {
                    createNewNode(word,CONSTANT_DESC,FLOAT_VAL,-1,line);
                }
            }
            fseek(infile,-1L,SEEK_CUR);//向后回退一位
        }
        //以"/"开头
        else if(ch == '/')
        {
            ch = fgetc(infile);
            //处理运算符"/="
            if(ch == '=')
            {
                createNewNode("/=",OPE_DESC,COMPLETE_DIV,-1,line);
            }
            //处理"/**/"型注释
            else if(ch == '*')
            {
                ch =  fgetc(infile);
                while(1)
                {
                    while(ch != '*')
                    {
                        if(ch == '\n')
                        {
                            line++;
                        }
                        ch = fgetc(infile);
                        if(ch == EOF)
                        {
                            createNewError(_NULL,NOTE_ERROR,NOTE_ERROR_NUM,line);
                            return;
                        }
                    }
                    ch = fgetc(infile);
                    if(ch == '/')
                    {
                        break;
                    }
                    if(ch == EOF)
                    {
                        createNewError(_NULL,NOTE_ERROR,NOTE_ERROR_NUM,line);
                        return;
                    }
                }
                createNewNode(_NULL,NOTE_DESC,NOTE1,-1,line);
            }
            //处理"//"型注释
            else if(ch == '/')
            {
                while(ch!='\n')
                {
                    ch = fgetc(infile);
                    if(ch == EOF)
                    {
                        createNewNode(_NULL,NOTE_DESC,NOTE2,-1,line);
                        return;
                    }
                }
                line++;
                createNewNode(_NULL,NOTE_DESC,NOTE2,-1,line);
                if(ch == EOF)
                {
                    return;
                }
            }
            //处理除号
            else
            {
                createNewNode("/",OPE_DESC,DIV,-1,line);
            }
        }
        //处理常量字符串
        else if(ch == '"')
        {
            createNewNode("\"",CLE_OPE_DESC,DOU_QUE,-1,line);
            ch = fgetc(infile);
            i = 0;
            while(ch!='"')
            {
                array[i++] = ch;
                if(ch == '\n')
                {
                    line++;
                }
                ch = fgetc(infile);
                if(ch == EOF)
                {
                    createNewError(_NULL,STRING_ERROR,STRING_ERROR_NUM,line);
                    return;
                }
            }
            word = new char[i+1];
            memcpy(word,array,i);
            word[i] = '\0';
            createNewNode(word,CONSTANT_DESC,STRING_VAL,-1,line);
            createNewNode("\"",CLE_OPE_DESC,DOU_QUE,-1,line);
        }
        //处理常量字符
        else if(ch == '\'')
        {
            createNewNode("\'",CLE_OPE_DESC,SIN_QUE,-1,line);
            ch = fgetc(infile);
            i = 0;
            while(ch!='\'')
            {
                array[i++] = ch;
                if(ch == '\n')
                {
                    line++;
                }
                ch = fgetc(infile);
                if(ch == EOF)
                {
                    createNewError(_NULL,CHARCONST_ERROR,CHARCONST_ERROR_NUM,line);
                    return;
                }
            }
            word = new char[i+1];
            memcpy(word,array,i);
            word[i] = '\0';
            createNewNode(word,CONSTANT_DESC,CHAR_VAL,-1,line);
            createNewNode("\'",CLE_OPE_DESC,SIN_QUE,-1,line);
        }
        else if(ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n')
        {
            if(ch == '\n')
            {
                line++;
            }
        }
        else
        {
            if(ch == EOF)
            {
                return;
            }
            //处理头文件和宏常量（预处理）
            else if(ch == '#')
            {
                while(ch!='\n' && ch!=EOF)
                {
                    array[i++] = ch;
                    ch = fgetc(infile);
                }
                word = new char[i+1];
                memcpy(word,array,i);
                word[i] = '\0';
                preProcess(word,line);

                fseek(infile,-1L,SEEK_CUR);//向后回退一位
            }
            //处理-开头的运算符
            else if(ch == '-')
            {
                array[i++] = ch;
                ch = fgetc(infile);
                if(ch >='0' && ch<='9')
                {
                    int flag = 0;
                    int flag2 = 0;
                    //处理整数
                    while(ch>='0' && ch<='9')
                    {
                        array[i++] = ch;
                        ch = fgetc(infile);
                    }
                    //处理float
                    if(ch == '.')
                    {
                        flag2 = 1;
                        array[i++] = ch;
                        ch = fgetc(infile);
                        if(ch>='0' && ch<='9')
                        {
                            while(ch>='0' && ch<='9')
                            {
                                array[i++] = ch;
                                ch = fgetc(infile);
                            }
                        }
                        else
                        {
                            flag = 1;
                        }
                        //处理Double
                        if(ch == 'E' || ch == 'e')
                        {
                            array[i++] = ch;
                            ch = fgetc(infile);
                            if(ch == '+' || ch == '-')
                            {
                                array[i++] = ch;
                                ch = fgetc(infile);
                            }
                            if(ch >='0' && ch<='9')
                            {
                                array[i++] = ch;
                                ch = fgetc(infile);
                            }
                            else
                            {
                                flag = 2;
                            }
                        }
                    }
                    word = new char[i+1];
                    memcpy(word,array,i);
                    word[i] = '\0';
                    if(flag == 1)
                    {
                        createNewError(word,FLOAT_ERROR,FLOAT_ERROR_NUM,line);
                    }
                    else if(flag == 2)
                    {
                        createNewError(word,DOUBLE_ERROR,DOUBLE_ERROR_NUM,line);
                    }
                    else
                    {
                        if(flag2 == 0)
                        {
                            createNewNode(word,CONSTANT_DESC,INT_VAL,-1,line);
                        }
                        else
                        {
                            createNewNode(word,CONSTANT_DESC,FLOAT_VAL,-1,line);
                        }
                    }
                    fseek(infile,-1L,SEEK_CUR);//向后回退一位
                }
                else if(ch == '>')
                {
                    createNewNode("->",OPE_DESC,ARROW,-1,line);
                }
                else if(ch == '-')
                {
                    createNewNode("--",OPE_DESC,SELF_SUB,-1,line);
                }
                else if(ch == '=')
                {
                    createNewNode("--",OPE_DESC,SELF_SUB,-1,line);
                }
                else
                {
                    createNewNode("-",OPE_DESC,SUB,-1,line);
                    fseek(infile,-1L,SEEK_CUR);
                }
            }
            //处理+开头的运算符
            else if(ch == '+')
            {
                ch = fgetc(infile);
                if(ch == '+')
                {
                    createNewNode("++",OPE_DESC,SELF_ADD,-1,line);
                }
                else if(ch == '=')
                {
                    createNewNode("+=",OPE_DESC,COMPLETE_ADD,-1,line);
                }
                else
                {
                    createNewNode("+",OPE_DESC,ADD,-1,line);
                    fseek(infile,-1L,SEEK_CUR);
                }
            }
            //处理*开头的运算符
            else if(ch == '*')
            {
                ch = fgetc(infile);
                if(ch == '=')
                {
                    createNewNode("*=",OPE_DESC,COMPLETE_MUL,-1,line);
                }
                else
                {
                    createNewNode("*",OPE_DESC,MUL,-1,line);
                    fseek(infile,-1L,SEEK_CUR);
                }
            }
            //处理按^开头的运算符
            else if(ch == '^')
            {
                ch = fgetc(infile);
                if(ch == '=')
                {
                    createNewNode("^=",OPE_DESC,COMPLETE_BYTE_XOR,-1,line);
                }
                else
                {
                    createNewNode("^",OPE_DESC,BYTE_XOR,-1,line);
                    fseek(infile,-1L,SEEK_CUR);
                }
            }
            //处理%开头的运算符
            else if(ch == '%')
            {
                ch = fgetc(infile);
                if(ch == '=')
                {
                    createNewNode("%=",OPE_DESC,COMPLETE_MOD,-1,line);
                }
                else
                {
                    createNewNode("%",OPE_DESC,MOD,-1,line);
                    fseek(infile,-1L,SEEK_CUR);
                }
            }
            //处理&开头的运算符
            else if(ch == '&')
            {
                ch = fgetc(infile);
                if(ch == '=')
                {
                    createNewNode("&=",OPE_DESC,COMPLETE_BYTE_AND,-1,line);
                }
                else if(ch == '&')
                {
                    createNewNode("&&",OPE_DESC,AND,-1,line);
                }
                else
                {
                    createNewNode("&",OPE_DESC,BYTE_AND,-1,line);
                    fseek(infile,-1L,SEEK_CUR);
                }
            }
            //处理~开头的运算符
            else if(ch == '~')
            {
                ch = fgetc(infile);
                if(ch == '=')
                {
                    createNewNode("~=",OPE_DESC,COMPLETE_COMPLEMENT,-1,line);
                }
                else
                {
                    createNewNode("~",OPE_DESC,COMPLEMENT,-1,line);
                    fseek(infile,-1L,SEEK_CUR);
                }
            }
            //处理!开头的运算符
            else if(ch == '!')
            {
                ch = fgetc(infile);
                if(ch == '=')
                {
                    createNewNode("!=",OPE_DESC,NOT_EQUAL,-1,line);
                }
                else
                {
                    createNewNode("!",OPE_DESC,NOT,-1,line);
                    fseek(infile,-1L,SEEK_CUR);
                }
            }
            //处理<开头的运算符
            else if(ch == '<')
            {
                ch = fgetc(infile);
                if(ch == '<')
                {
                    createNewNode("<<",OPE_DESC,LEFT_MOVE,-1,line);
                }
                else if(ch == '=')
                {
                    createNewNode("<=",OPE_DESC,LES_EQUAL,-1,line);
                }
                else
                {
                    createNewNode("<",OPE_DESC,LES_THAN,-1,line);
                    fseek(infile,-1L,SEEK_CUR);
                }
            }
            //处理>开头的运算符
            else if(ch == '>')
            {
                ch = fgetc(infile);
                if(ch == '>')
                {
                    createNewNode(">>",OPE_DESC,RIGHT_MOVE,-1,line);
                }
                else if(ch == '=')
                {
                    createNewNode(">=",OPE_DESC,GRT_EQUAL,-1,line);
                }
                else
                {
                    createNewNode(">",OPE_DESC,GRT_THAN,-1,line);
                    fseek(infile,-1L,SEEK_CUR);
                }
            }
            //处理|开头的运算符
            else if(ch == '|')
            {
                ch = fgetc(infile);
                if(ch == '|')
                {
                    createNewNode("||",OPE_DESC,OR,-1,line);
                }
                else
                {
                    createNewNode("|",OPE_DESC,BYTE_OR,-1,line);
                    fseek(infile,-1L,SEEK_CUR);
                }
            }
            else if(ch == '=')
            {
                ch = fgetc(infile);
                if(ch == '=')
                {
                    createNewNode("==",OPE_DESC,EQUAL,-1,line);
                }
                else
                {
                    createNewNode("=",OPE_DESC,ASG,-1,line);
                    fseek(infile,-1L,SEEK_CUR);
                }
            }
            else if(ch == '(')
            {
                leftSmall++;
                lineBra[0][leftSmall] = line;
                createNewNode("(",CLE_OPE_DESC,LEFT_BRA,-1,line);
            }
            else if(ch == ')')
            {
                rightSmall++;
                lineBra[1][rightSmall] = line;
                createNewNode(")",CLE_OPE_DESC,RIGHT_BRA,-1,line);
            }
            else if(ch == '[')
            {
                leftMiddle++;
                lineBra[2][leftMiddle] = line;
                createNewNode("[",CLE_OPE_DESC,LEFT_INDEX,-1,line);
            }
            else if(ch == ']')
            {
                rightMiddle++;
                lineBra[3][rightMiddle] = line;
                createNewNode("]",CLE_OPE_DESC,RIGHT_INDEX,-1,line);
            }
            else if(ch == '{')
            {
                leftBig++;
                lineBra[4][leftBig] = line;
                createNewNode("{",CLE_OPE_DESC,L_BOUNDER,-1,line);
            }
            else if(ch == '}')
            {
                rightBig++;
                lineBra[5][rightBig] = line;
                createNewNode("}",CLE_OPE_DESC,R_BOUNDER,-1,line);
            }
            else if(ch == '.')
            {
                createNewNode(".",CLE_OPE_DESC,POINTER,-1,line);
            }
            else if(ch == ',')
            {
                createNewNode(",",CLE_OPE_DESC,COMMA,-1,line);
            }
            else if(ch == ';')
            {
                createNewNode(";",CLE_OPE_DESC,SEMI,-1,line);
            }
            else
            {
                char temp[2];
                temp[0] = ch;
                temp[1] = '\0';
                createNewError(temp,CHAR_ERROR,CHAR_ERROR_NUM,line);
            }
        }
        ch = fgetc(infile);
    }
}
void BraMappingError()
{
    if(leftSmall != rightSmall)
    {
        int i = (leftSmall>rightSmall) ? (leftSmall-rightSmall) : (rightSmall - leftSmall);
        bool  flag = (leftSmall>rightSmall) ? true : false;
        if(flag)
        {
            while(i--)
            {
                createNewError(_NULL,LEFT_BRA_ERROR,LEFT_BRA_ERROR_NUM,lineBra[0][i+1]);
            }
        }
        else
        {
            while(i--)
            {
                createNewError(_NULL,RIGHT_BRA_ERROR,RIGHT_BRA_ERROR_NUM,lineBra[1][i+1]);
            }
        }
    }
    if(leftMiddle != rightMiddle)
    {
        int i = (leftMiddle>rightMiddle) ? (leftMiddle-rightMiddle) : (rightMiddle - leftMiddle);
        bool flag = (leftMiddle>rightMiddle) ? true : false;
        if(flag)
        {
            while(i--)
            {
                createNewError(_NULL,LEFT_INDEX_ERROR,LEFT_INDEX_ERROR_NUM,lineBra[2][i+1]);
            }
        }
        else
        {
            while(i--)
            {
                createNewError(_NULL,RIGHT_INDEX_ERROR,RIGHT_INDEX_ERROR_NUM,lineBra[3][i+1]);
            }
        }
    }
    if(leftBig != rightBig)
    {
        int i = (leftBig>rightBig) ? (leftBig-rightBig) : (rightBig - leftSmall);
        bool flag = (leftBig>rightBig) ? true : false;
        if(flag)
        {
            while(i--)
            {
                createNewError(_NULL,L_BOUNDER_ERROR,L_BOUNDER_ERROR_NUM,lineBra[4][i+1]);
            }
        }
        else
        {
            while(i--)
            {
                createNewError(_NULL,R_BOUNDER_ERROR,R_BOUNDER_ERROR_NUM,lineBra[5][i+1]);
            }
        }
    }
}

语法分析Cpp代码：

//SynAnalysis.cpp
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "LexAnalysis.h"
#include "SynAnalysis.h"

using namespace std;

#define Max_Proc 500
#define Max_Length 500

#define Max_NonTer 60
#define Max_Ter 60
#define Max_Length2 100

int procNum = 0;
//proc的维数都是从1开始的
int proc[Max_Proc][Max_Length];//产生式的数组，里边存储了终结符或者非终结符对应的编号
int first[Max_Proc][Max_Length];
int follow[Max_Proc][Max_Length];
int select[Max_Proc][Max_Length];
int M[Max_NonTer][Max_Ter][Max_Length2];

int connectFirst[Max_Length];//将某些First集结合起来的集合


int firstVisit[Max_Proc];//记录某非终结符的First集是否已经求过
int followVisit[Max_Proc];//记录某非终结符的Follow集是否已经求过

int empty[Max_Proc];//可推出空的非终结符的编号
int emptyRecu[Max_Proc];//在求可推出空的非终结符的编号集时使用的防治递归的集合
int followRecu[Max_Proc];//在求Follow集时使用的防治递归的集合

//extern的部分代表可能出现的终结符和其编号
extern vector > keyMap;
extern vector > operMap;
extern vector > limitMap;

extern NormalNode * normalHead;//首结点

fstream resultfile;

vector > nonTerMap;//非终结符映射表,不可重复的
vector > terMap;//终结符映射表,不可重复的
vector > specialMap;//文法中的特殊符号映射表，包括-> | $(空)


void initSpecialMapping()
{
    specialMap.clear();
    specialMap.push_back(make_pair("->",GRAMMAR_ARROW));
    specialMap.push_back(make_pair("|",GRAMMAR_OR));
    specialMap.push_back(make_pair("$",GRAMMAR_NULL));
    specialMap.push_back(make_pair("#",GRAMMAR_SPECIAL));

}
const char * searchMapping(int num)
{
    //标志符
    if(num == IDENTIFER)
    {
        return "id";
    }
    //处理文法中的特殊符号
    for(int i = 0; i=2;)
    {
        if(p[line][left] == GRAMMAR_OR || left == 2)
        {
            p[line + orNum][1] = head;
            p[line + orNum][2] = push;
            for(int i=left+1;i<=right;i++)
            {
                p[line+orNum][i-left+2] = p[line][i];
            }
            p[line+orNum][right-left+3] = -1;
            right = left = left-1;
            orNum--;
        }
        else
        {
            left--;
        }
    }
    line = lineTrue;
}
void initGrammer()
{
    FILE * infile;
    char ch;
    char array[30];
    char * word;
    int i;
    int codeNum;
    int line = 1;
    int count = 0;
    int orNum = 0;
    infile = fopen("wenfa.txt","r");
    if(!infile)
    {
        printf("文法打开失败！\n");
        return;
    }
    initSpecialMapping();
    nonTerMap.clear();
    terMap.clear();

    memset(proc,-1,sizeof(proc));
    memset(first,-1,sizeof(first));
    memset(follow,-1,sizeof(follow));
    memset(select,-1,sizeof(select));

    memset(connectFirst,-1,sizeof(connectFirst));

    memset(firstVisit,0,sizeof(firstVisit));//非终结符的first集还未求过
    memset(followVisit,0,sizeof(followVisit));//非终结符的follow集还未求过

    memset(empty,-1,sizeof(empty));
    memset(emptyRecu,-1,sizeof(emptyRecu));
    memset(followRecu,-1,sizeof(followRecu));

    memset(M,-1,sizeof(M));

    ch = fgetc(infile);
    i = 0;
    while(ch!=EOF)
    {
        i = 0;
        while(ch == ' ' || ch == '\t')
        {
            ch = fgetc(infile);
        }
        while(ch!=' ' && ch!= '\n' && ch!=EOF)
        {
            array[i++] = ch;
            ch = fgetc(infile);
        }
        while(ch == ' ' || ch == '\t')
        {
            ch = fgetc(infile);
        }
        word = new char[i+1];
        memcpy(word,array,i);
        word[i] = '\0';
        codeNum = 0;
        codeNum = seekCodeNum(word);
        if(codeNum!=0)
        {
            count++;
            if(codeNum == GRAMMAR_OR)
            {
                orNum++;
            }
            proc[line][count] = codeNum;

        }
        //原本需要回退一个字符，由于是冗余字符，不回退
        if(ch == '\n')
        {
            splitProc(proc,line,orNum);//将" | "文法进行拆分
            count = 0;
            orNum = 0;
            line++;
            ch = fgetc(infile);
        }
    }
    procNum = line - 1;
    printf("************************************C语言文法******************************\n\n");
    for(int i=1; itop = -1;
}
int Push(SeqStack *S,int x)   /*进栈*/
{
    if(S->top ==Stack_Size-1)
        return 0;
    S->top++;
    S->elem[S->top]=x;
    return 1;
}
int Pop(SeqStack *S)   /*出栈*/
{
    if(S->top==-1)
        return 0;
    else
    {
        S->top--;
        return 1;
    }
}
int GetTop(SeqStack *S,int *x)   /*取栈顶元素*/
{
    if(S->top==-1)
        return 0;
    else
    {
        *x=S->elem[S->top];
        return 1;
    }
}
void ShowStack1(SeqStack *S)   /*显示栈的字符，先输出栈底元素*/
{

    int i;
    for(i=S->top; i>=0; i--)
    {
        //printf("%s ",searchMapping(S->elem[i]));
        resultfile<elem[i])<<" ";
    }
}
void ShowStack2(SeqStack *S)   /*显示栈的字符，先输出栈顶元素*/
{

    int i;
    for(i=S->top; i>=0; i--)
    {
        //printf("%s ",searchMapping(S->elem[i]));
        resultfile<elem[i])<<" ";
    }
}
//分析源程序
void Analysis()
{
    //分析结果输出

    resultfile.open("preciateResult.txt",ios::out);

    SeqStack s1,s2;
    int c1,c2;
    int i = 0;
    int reserve[Stack_Size];//符号栈反向入栈
    NormalNode * p = normalHead;
    int s1Length = 0;
    memset(reserve,-1,sizeof(reserve));

    InitStack(&s1);  /*初始化符号栈和输入串*/
    InitStack(&s2);
    Push(&s1,GRAMMAR_SPECIAL);
    Push(&s1,proc[1][1]);
    Push(&s2,GRAMMAR_SPECIAL);

    p = p->next;
    while(p!=NULL)
    {

        if(p->type == AUTO || p->type == CONST || p->type == UNSIGNED || p->type == SIGNED
                || p->type ==STATIC || p->type == VOLATILE )
        {
            reserve[i++] =  DESCRIBE;
            //Push(&s2,DESCRIBE);
        }
        else if(p->type == INT_VAL)
        {
            reserve[i++] =  DIGIT;
            //Push(&s2,DIGIT);
        }
        else if(p->type == CHAR || p->type == DOUBLE || p->type == FLOAT || p->type == INT ||
                p->type == LONG || p->type == SHORT || p->type == VOID)
        {
            reserve[i++] =  TYPE;
            //Push(&s2,TYPE);
        }
        else if(p->type == STRING_VAL)
        {
            reserve[i++] =  STRING;
            //Push(&s2,STRING);
        }
        else if(p->type == DOU_QUE || p->type == SIN_QUE)
        {

        }
        else
        {
            reserve[i++] =  p->type;
            //Push(&s2,p->type);
        }
        p = p->next;
    }
    //求左边栈的长度
    for(s1Length = 0;; s1Length++)
    {
        if(reserve[s1Length] == -1)
        {
            break;
        }
    }
    //反向入栈
    for(i = s1Length; i>0; i--)
    {
        Push(&s2,reserve[i-1]);
    }

    for(i=0;; i++)   /*分析*/
    {
        //getch();
        int flag = 0;
        int h1;
        int h2;
        //printf("第%d步：\n",i+1);  /*输出该步的相应信息*/
        resultfile<<"第"<=2; k--)
                    {
                        Push(&s1,M[h1][h2][k]);
                    }
                }
            }
        }
        if(flag == 1)
        {
            //printf("匹配！\n");
            resultfile<<"匹配!"<

主文件：

main.cpp

//main.cpp
#include 
#include 
#include 
#include 
#include 
#include 
#include "LexAnalysis.h"
#include "SynAnalysis.h"

int main()
{
    //词法分析部分
    initKeyMapping();
    initOperMapping();
    initLimitMapping();
    initNode();
    scanner();
    BraMappingError();
    printNodeLink();

    printErrorLink();
    printIdentLink();

    //语法分析部分
    initGrammer();
    First();
    Follow();
    Select();
    MTable();
    Analysis();
    close();
	return 0;
}

测试程序（被分析的C代码）：

int main()
{
	int i = 7;
	int j = 9;
	int c[20] = 

{2,10,10,19,3,4,5,5,34,6,54,52,34,55,68,10,90,78,56,20};
	for (i=0;i<20;i++)
	{
		for(j=i+1;j<20;j--)
		{
			if(j == 19)
			{
				c[i] = j;
			}
		}
	}
	printf("Hello world");
	return 0;
}

分析结果：

************************************C语言文法******************************

<函数定义> -> <修饰词闭包> <类型> <变量> ( <参数声明> ) { <函数块> }
<修饰词闭包> -> <修饰词> <修饰词闭包>
<修饰词闭包> -> $
<修饰词> -> describe
<类型> -> type <取地址>
<取地址> -> <星号闭包>
<星号闭包> -> <星号> <星号闭包>
<星号闭包> -> $
<星号> -> *
<变量> -> <标志符> <数组下标>
<标志符> -> id
<数组下标> -> [ <因式> ]
<数组下标> -> $
<因式> -> ( <表达式> )
<因式> -> <变量>
<因式> -> <数字>
<数字> -> digit
<表达式> -> <因子> <项>
<因子> -> <因式> <因式递归>
<因式递归> -> * <因式> <因式递归>
<因式递归> -> / <因式> <因式递归>
<因式递归> -> $
<项> -> + <因子> <项>
<项> -> - <因子> <项>
<项> -> $
<参数声明> -> <声明> <声明闭包>
<参数声明> -> $
<声明> -> <修饰词闭包> <类型> <变量> <赋初值>
<赋初值> -> = <右值>
<赋初值> -> $
<右值> -> <表达式>
<右值> -> { <多个数据> }
<多个数据> -> <数字> <数字闭包>
<数字闭包> -> , <数字> <数字闭包>
<数字闭包> -> $
<声明闭包> -> , <声明> <声明闭包>
<声明闭包> -> $
<函数块> -> <声明语句闭包> <函数块闭包>
<声明语句闭包> -> <声明语句> <声明语句闭包>
<声明语句闭包> -> $
<声明语句> -> <声明> ;
<函数块闭包> -> <赋值函数> <函数块闭包>
<函数块闭包> ->  <函数块闭包>
<函数块闭包> -> <条件语句> <函数块闭包>
<函数块闭包> -> <函数返回> <函数块闭包>
<函数块闭包> -> $
<赋值函数> -> <变量> <赋值或函数调用>
<赋值或函数调用> -> = <右值> ;
<赋值或函数调用> -> ( <参数列表> ) ;
<参数列表> -> <参数> <参数闭包>
<参数闭包> -> , <参数> <参数闭包>
<参数闭包> -> $
<参数> -> <标志符>
<参数> -> <数字>
<参数> -> <字符串>
<字符串> -> string
 -> for ( <赋值函数> <逻辑表达式> ; <后缀表达式> ) { <函数块> }
<逻辑表达式> -> <表达式> <逻辑运算符> <表达式>
<逻辑运算符> -> <
<逻辑运算符> -> >
<逻辑运算符> -> ==
<逻辑运算符> -> !=
<后缀表达式> -> <变量> <后缀运算符>
<后缀运算符> -> ++
<后缀运算符> -> --
<条件语句> -> if ( <逻辑表达式> ) { <函数块> } <否则语句>
<否则语句> -> else { <函数块> }
<否则语句> -> $
<函数返回> -> return <因式> ;

************************************文法终结符******************************

( ) { } describe type * id [ ] digit / + - = , ; string for < > == != ++ -- if e
lse return

************************************文法非终结符******************************

<函数定义> <修饰词闭包> <类型> <变量> <参数声明> <函数块> <修饰词> <取地址> <星
号闭包> <星号> <标志符> <数组下标> <因式> <表达式> <数字> <因子> <项> <因式递归>
 <声明> <声明闭包> <赋初值> <右值> <多个数据> <数字闭包> <声明语句闭包> <函数块
闭包> <声明语句> <赋值函数>  <条件语句> <函数返回> <赋值或函数调用> <参
数列表> <参数> <参数闭包> <字符串> <逻辑表达式> <后缀表达式> <逻辑运算符> <后缀
运算符> <否则语句>


************************************First集******************************

First[<函数定义>] = describe type
First[<修饰词闭包>] = describe $
First[<类型>] = type
First[<变量>] = id
First[<参数声明>] = describe type $
First[<函数块>] = describe type id for if return $
First[<修饰词>] = describe
First[<取地址>] = * $
First[<星号闭包>] = * $
First[<星号>] = *
First[<标志符>] = id
First[<数组下标>] = [ $
First[<因式>] = ( id digit
First[<表达式>] = ( id digit
First[<数字>] = digit
First[<因子>] = ( id digit
First[<项>] = + - $
First[<因式递归>] = * / $
First[<声明>] = describe type
First[<声明闭包>] = , $
First[<赋初值>] = = $
First[<右值>] = ( id digit {
First[<多个数据>] = digit
First[<数字闭包>] = , $
First[<声明语句闭包>] = describe type $
First[<函数块闭包>] = id for if return $
First[<声明语句>] = describe type
First[<赋值函数>] = id
First[] = for
First[<条件语句>] = if
First[<函数返回>] = return
First[<赋值或函数调用>] = = (
First[<参数列表>] = id digit string
First[<参数>] = id digit string
First[<参数闭包>] = , $
First[<字符串>] = string
First[<逻辑表达式>] = ( id digit
First[<后缀表达式>] = id
First[<逻辑运算符>] = < > == !=
First[<后缀运算符>] = ++ --
First[<否则语句>] = else $

************************************Follow集******************************

Follow[<函数定义>] = #
Follow[<修饰词闭包>] = type
Follow[<类型>] = id
Follow[<变量>] = ( ] ) , ; < > == != + - * / = ++ --
Follow[<参数声明>] = )
Follow[<函数块>] = }
Follow[<修饰词>] = type describe
Follow[<取地址>] = id
Follow[<星号闭包>] = id
Follow[<星号>] = id *
Follow[<标志符>] = ( ] ) , ; < > == != + - * / = ++ -- [
Follow[<数组下标>] = ( ] ) , ; < > == != + - * / = ++ --
Follow[<因式>] = ] ) , ; < > == != + - * /
Follow[<表达式>] = ) , ; < > == !=
Follow[<数字>] = ] ) , ; < > == != + - * / }
Follow[<因子>] = ) , ; < > == != + -
Follow[<项>] = ) , ; < > == !=
Follow[<因式递归>] = ) , ; < > == != + -
Follow[<声明>] = ) , ;
Follow[<声明闭包>] = )
Follow[<赋初值>] = ) , ;
Follow[<右值>] = ) , ;
Follow[<多个数据>] = }
Follow[<数字闭包>] = }
Follow[<声明语句闭包>] = } id for if return
Follow[<函数块闭包>] = }
Follow[<声明语句>] = } id for if return describe type
Follow[<赋值函数>] = } id for if return ( digit
Follow[] = } id for if return
Follow[<条件语句>] = } id for if return
Follow[<函数返回>] = } id for if return
Follow[<赋值或函数调用>] = } id for if return ( digit
Follow[<参数列表>] = )
Follow[<参数>] = ) ,
Follow[<参数闭包>] = )
Follow[<字符串>] = ) ,
Follow[<逻辑表达式>] = ; )
Follow[<后缀表达式>] = )
Follow[<逻辑运算符>] = ( id digit
Follow[<后缀运算符>] = )
Follow[<否则语句>] = } id for if return

************************************Select集******************************

Select[1] = describe type
Select[2] = describe
Select[3] = type
Select[4] = describe
Select[5] = type
Select[6] = * id
Select[7] = *
Select[8] = id
Select[9] = *
Select[10] = id
Select[11] = id
Select[12] = [
Select[13] = ( ] ) , ; < > == != + - * / = ++ --
Select[14] = (
Select[15] = id
Select[16] = digit
Select[17] = digit
Select[18] = ( id digit
Select[19] = ( id digit
Select[20] = *
Select[21] = /
Select[22] = ) , ; < > == != + -
Select[23] = +
Select[24] = -
Select[25] = ) , ; < > == !=
Select[26] = describe type
Select[27] = )
Select[28] = describe type
Select[29] = =
Select[30] = ) , ;
Select[31] = ( id digit
Select[32] = {
Select[33] = digit
Select[34] = ,
Select[35] = }
Select[36] = ,
Select[37] = )
Select[38] = describe type id for if return }
Select[39] = describe type
Select[40] = } id for if return
Select[41] = describe type
Select[42] = id
Select[43] = for
Select[44] = if
Select[45] = return
Select[46] = }
Select[47] = id
Select[48] = =
Select[49] = (
Select[50] = id digit string
Select[51] = ,
Select[52] = )
Select[53] = id
Select[54] = digit
Select[55] = string
Select[56] = string
Select[57] = for
Select[58] = ( id digit
Select[59] = <
Select[60] = >
Select[61] = ==
Select[62] = !=
Select[63] = id
Select[64] = ++
Select[65] = --
Select[66] = if
Select[67] = else
Select[68] = } id for if return
Select[69] = return

Process returned 0 (0x0)   execution time : 4.317 s
Press any key to continue.

输出文件内容：

preciateTable.txt（预测分析表）：

*********************************预测分析表******************************
M[<函数定义>][(] = 
M[<函数定义>][)] = 
M[<函数定义>][{] = 
M[<函数定义>][}] = 
M[<函数定义>][describe] = <函数定义>-><修饰词闭包><类型><变量>(<参数声明>){<函数块>}
M[<函数定义>][type] = <函数定义>-><修饰词闭包><类型><变量>(<参数声明>){<函数块>}
M[<函数定义>][*] = 
M[<函数定义>][id] = 
M[<函数定义>][[] = 
M[<函数定义>][]] = 
M[<函数定义>][digit] = 
M[<函数定义>][/] = 
M[<函数定义>][+] = 
M[<函数定义>][-] = 
M[<函数定义>][=] = 
M[<函数定义>][,] = 
M[<函数定义>][;] = 
M[<函数定义>][string] = 
M[<函数定义>][for] = 
M[<函数定义>][<] = 
M[<函数定义>][>] = 
M[<函数定义>][==] = 
M[<函数定义>][!=] = 
M[<函数定义>][++] = 
M[<函数定义>][--] = 
M[<函数定义>][if] = 
M[<函数定义>][else] = 
M[<函数定义>][return] = 


M[<修饰词闭包>][(] = 
M[<修饰词闭包>][)] = 
M[<修饰词闭包>][{] = 
M[<修饰词闭包>][}] = 
M[<修饰词闭包>][describe] = <修饰词闭包>-><修饰词><修饰词闭包>
M[<修饰词闭包>][type] = <修饰词闭包>->$
M[<修饰词闭包>][*] = 
M[<修饰词闭包>][id] = 
M[<修饰词闭包>][[] = 
M[<修饰词闭包>][]] = 
M[<修饰词闭包>][digit] = 
M[<修饰词闭包>][/] = 
M[<修饰词闭包>][+] = 
M[<修饰词闭包>][-] = 
M[<修饰词闭包>][=] = 
M[<修饰词闭包>][,] = 
M[<修饰词闭包>][;] = 
M[<修饰词闭包>][string] = 
M[<修饰词闭包>][for] = 
M[<修饰词闭包>][<] = 
M[<修饰词闭包>][>] = 
M[<修饰词闭包>][==] = 
M[<修饰词闭包>][!=] = 
M[<修饰词闭包>][++] = 
M[<修饰词闭包>][--] = 
M[<修饰词闭包>][if] = 
M[<修饰词闭包>][else] = 
M[<修饰词闭包>][return] = 


M[<类型>][(] = 
M[<类型>][)] = 
M[<类型>][{] = 
M[<类型>][}] = 
M[<类型>][describe] = 
M[<类型>][type] = <类型>->type<取地址>
M[<类型>][*] = 
M[<类型>][id] = 
M[<类型>][[] = 
M[<类型>][]] = 
M[<类型>][digit] = 
M[<类型>][/] = 
M[<类型>][+] = 
M[<类型>][-] = 
M[<类型>][=] = 
M[<类型>][,] = 
M[<类型>][;] = 
M[<类型>][string] = 
M[<类型>][for] = 
M[<类型>][<] = 
M[<类型>][>] = 
M[<类型>][==] = 
M[<类型>][!=] = 
M[<类型>][++] = 
M[<类型>][--] = 
M[<类型>][if] = 
M[<类型>][else] = 
M[<类型>][return] = 


M[<变量>][(] = 
M[<变量>][)] = 
M[<变量>][{] = 
M[<变量>][}] = 
M[<变量>][describe] = 
M[<变量>][type] = 
M[<变量>][*] = 
M[<变量>][id] = <变量>-><标志符><数组下标>
M[<变量>][[] = 
M[<变量>][]] = 
M[<变量>][digit] = 
M[<变量>][/] = 
M[<变量>][+] = 
M[<变量>][-] = 
M[<变量>][=] = 
M[<变量>][,] = 
M[<变量>][;] = 
M[<变量>][string] = 
M[<变量>][for] = 
M[<变量>][<] = 
M[<变量>][>] = 
M[<变量>][==] = 
M[<变量>][!=] = 
M[<变量>][++] = 
M[<变量>][--] = 
M[<变量>][if] = 
M[<变量>][else] = 
M[<变量>][return] = 


M[<参数声明>][(] = 
M[<参数声明>][)] = <参数声明>->$
M[<参数声明>][{] = 
M[<参数声明>][}] = 
M[<参数声明>][describe] = <参数声明>-><声明><声明闭包>
M[<参数声明>][type] = <参数声明>-><声明><声明闭包>
M[<参数声明>][*] = 
M[<参数声明>][id] = 
M[<参数声明>][[] = 
M[<参数声明>][]] = 
M[<参数声明>][digit] = 
M[<参数声明>][/] = 
M[<参数声明>][+] = 
M[<参数声明>][-] = 
M[<参数声明>][=] = 
M[<参数声明>][,] = 
M[<参数声明>][;] = 
M[<参数声明>][string] = 
M[<参数声明>][for] = 
M[<参数声明>][<] = 
M[<参数声明>][>] = 
M[<参数声明>][==] = 
M[<参数声明>][!=] = 
M[<参数声明>][++] = 
M[<参数声明>][--] = 
M[<参数声明>][if] = 
M[<参数声明>][else] = 
M[<参数声明>][return] = 


M[<函数块>][(] = 
M[<函数块>][)] = 
M[<函数块>][{] = 
M[<函数块>][}] = <函数块>-><声明语句闭包><函数块闭包>
M[<函数块>][describe] = <函数块>-><声明语句闭包><函数块闭包>
M[<函数块>][type] = <函数块>-><声明语句闭包><函数块闭包>
M[<函数块>][*] = 
M[<函数块>][id] = <函数块>-><声明语句闭包><函数块闭包>
M[<函数块>][[] = 
M[<函数块>][]] = 
M[<函数块>][digit] = 
M[<函数块>][/] = 
M[<函数块>][+] = 
M[<函数块>][-] = 
M[<函数块>][=] = 
M[<函数块>][,] = 
M[<函数块>][;] = 
M[<函数块>][string] = 
M[<函数块>][for] = <函数块>-><声明语句闭包><函数块闭包>
M[<函数块>][<] = 
M[<函数块>][>] = 
M[<函数块>][==] = 
M[<函数块>][!=] = 
M[<函数块>][++] = 
M[<函数块>][--] = 
M[<函数块>][if] = <函数块>-><声明语句闭包><函数块闭包>
M[<函数块>][else] = 
M[<函数块>][return] = <函数块>-><声明语句闭包><函数块闭包>


M[<修饰词>][(] = 
M[<修饰词>][)] = 
M[<修饰词>][{] = 
M[<修饰词>][}] = 
M[<修饰词>][describe] = <修饰词>->describe
M[<修饰词>][type] = 
M[<修饰词>][*] = 
M[<修饰词>][id] = 
M[<修饰词>][[] = 
M[<修饰词>][]] = 
M[<修饰词>][digit] = 
M[<修饰词>][/] = 
M[<修饰词>][+] = 
M[<修饰词>][-] = 
M[<修饰词>][=] = 
M[<修饰词>][,] = 
M[<修饰词>][;] = 
M[<修饰词>][string] = 
M[<修饰词>][for] = 
M[<修饰词>][<] = 
M[<修饰词>][>] = 
M[<修饰词>][==] = 
M[<修饰词>][!=] = 
M[<修饰词>][++] = 
M[<修饰词>][--] = 
M[<修饰词>][if] = 
M[<修饰词>][else] = 
M[<修饰词>][return] = 


M[<取地址>][(] = 
M[<取地址>][)] = 
M[<取地址>][{] = 
M[<取地址>][}] = 
M[<取地址>][describe] = 
M[<取地址>][type] = 
M[<取地址>][*] = <取地址>-><星号闭包>
M[<取地址>][id] = <取地址>-><星号闭包>
M[<取地址>][[] = 
M[<取地址>][]] = 
M[<取地址>][digit] = 
M[<取地址>][/] = 
M[<取地址>][+] = 
M[<取地址>][-] = 
M[<取地址>][=] = 
M[<取地址>][,] = 
M[<取地址>][;] = 
M[<取地址>][string] = 
M[<取地址>][for] = 
M[<取地址>][<] = 
M[<取地址>][>] = 
M[<取地址>][==] = 
M[<取地址>][!=] = 
M[<取地址>][++] = 
M[<取地址>][--] = 
M[<取地址>][if] = 
M[<取地址>][else] = 
M[<取地址>][return] = 


M[<星号闭包>][(] = 
M[<星号闭包>][)] = 
M[<星号闭包>][{] = 
M[<星号闭包>][}] = 
M[<星号闭包>][describe] = 
M[<星号闭包>][type] = 
M[<星号闭包>][*] = <星号闭包>-><星号><星号闭包>
M[<星号闭包>][id] = <星号闭包>->$
M[<星号闭包>][[] = 
M[<星号闭包>][]] = 
M[<星号闭包>][digit] = 
M[<星号闭包>][/] = 
M[<星号闭包>][+] = 
M[<星号闭包>][-] = 
M[<星号闭包>][=] = 
M[<星号闭包>][,] = 
M[<星号闭包>][;] = 
M[<星号闭包>][string] = 
M[<星号闭包>][for] = 
M[<星号闭包>][<] = 
M[<星号闭包>][>] = 
M[<星号闭包>][==] = 
M[<星号闭包>][!=] = 
M[<星号闭包>][++] = 
M[<星号闭包>][--] = 
M[<星号闭包>][if] = 
M[<星号闭包>][else] = 
M[<星号闭包>][return] = 


M[<星号>][(] = 
M[<星号>][)] = 
M[<星号>][{] = 
M[<星号>][}] = 
M[<星号>][describe] = 
M[<星号>][type] = 
M[<星号>][*] = <星号>->*
M[<星号>][id] = 
M[<星号>][[] = 
M[<星号>][]] = 
M[<星号>][digit] = 
M[<星号>][/] = 
M[<星号>][+] = 
M[<星号>][-] = 
M[<星号>][=] = 
M[<星号>][,] = 
M[<星号>][;] = 
M[<星号>][string] = 
M[<星号>][for] = 
M[<星号>][<] = 
M[<星号>][>] = 
M[<星号>][==] = 
M[<星号>][!=] = 
M[<星号>][++] = 
M[<星号>][--] = 
M[<星号>][if] = 
M[<星号>][else] = 
M[<星号>][return] = 


M[<标志符>][(] = 
M[<标志符>][)] = 
M[<标志符>][{] = 
M[<标志符>][}] = 
M[<标志符>][describe] = 
M[<标志符>][type] = 
M[<标志符>][*] = 
M[<标志符>][id] = <标志符>->id
M[<标志符>][[] = 
M[<标志符>][]] = 
M[<标志符>][digit] = 
M[<标志符>][/] = 
M[<标志符>][+] = 
M[<标志符>][-] = 
M[<标志符>][=] = 
M[<标志符>][,] = 
M[<标志符>][;] = 
M[<标志符>][string] = 
M[<标志符>][for] = 
M[<标志符>][<] = 
M[<标志符>][>] = 
M[<标志符>][==] = 
M[<标志符>][!=] = 
M[<标志符>][++] = 
M[<标志符>][--] = 
M[<标志符>][if] = 
M[<标志符>][else] = 
M[<标志符>][return] = 


M[<数组下标>][(] = <数组下标>->$
M[<数组下标>][)] = <数组下标>->$
M[<数组下标>][{] = 
M[<数组下标>][}] = 
M[<数组下标>][describe] = 
M[<数组下标>][type] = 
M[<数组下标>][*] = <数组下标>->$
M[<数组下标>][id] = 
M[<数组下标>][[] = <数组下标>->[<因式>]
M[<数组下标>][]] = <数组下标>->$
M[<数组下标>][digit] = 
M[<数组下标>][/] = <数组下标>->$
M[<数组下标>][+] = <数组下标>->$
M[<数组下标>][-] = <数组下标>->$
M[<数组下标>][=] = <数组下标>->$
M[<数组下标>][,] = <数组下标>->$
M[<数组下标>][;] = <数组下标>->$
M[<数组下标>][string] = 
M[<数组下标>][for] = 
M[<数组下标>][<] = <数组下标>->$
M[<数组下标>][>] = <数组下标>->$
M[<数组下标>][==] = <数组下标>->$
M[<数组下标>][!=] = <数组下标>->$
M[<数组下标>][++] = <数组下标>->$
M[<数组下标>][--] = <数组下标>->$
M[<数组下标>][if] = 
M[<数组下标>][else] = 
M[<数组下标>][return] = 


M[<因式>][(] = <因式>->(<表达式>)
M[<因式>][)] = 
M[<因式>][{] = 
M[<因式>][}] = 
M[<因式>][describe] = 
M[<因式>][type] = 
M[<因式>][*] = 
M[<因式>][id] = <因式>-><变量>
M[<因式>][[] = 
M[<因式>][]] = 
M[<因式>][digit] = <因式>-><数字>
M[<因式>][/] = 
M[<因式>][+] = 
M[<因式>][-] = 
M[<因式>][=] = 
M[<因式>][,] = 
M[<因式>][;] = 
M[<因式>][string] = 
M[<因式>][for] = 
M[<因式>][<] = 
M[<因式>][>] = 
M[<因式>][==] = 
M[<因式>][!=] = 
M[<因式>][++] = 
M[<因式>][--] = 
M[<因式>][if] = 
M[<因式>][else] = 
M[<因式>][return] = 


M[<表达式>][(] = <表达式>-><因子><项>
M[<表达式>][)] = 
M[<表达式>][{] = 
M[<表达式>][}] = 
M[<表达式>][describe] = 
M[<表达式>][type] = 
M[<表达式>][*] = 
M[<表达式>][id] = <表达式>-><因子><项>
M[<表达式>][[] = 
M[<表达式>][]] = 
M[<表达式>][digit] = <表达式>-><因子><项>
M[<表达式>][/] = 
M[<表达式>][+] = 
M[<表达式>][-] = 
M[<表达式>][=] = 
M[<表达式>][,] = 
M[<表达式>][;] = 
M[<表达式>][string] = 
M[<表达式>][for] = 
M[<表达式>][<] = 
M[<表达式>][>] = 
M[<表达式>][==] = 
M[<表达式>][!=] = 
M[<表达式>][++] = 
M[<表达式>][--] = 
M[<表达式>][if] = 
M[<表达式>][else] = 
M[<表达式>][return] = 


M[<数字>][(] = 
M[<数字>][)] = 
M[<数字>][{] = 
M[<数字>][}] = 
M[<数字>][describe] = 
M[<数字>][type] = 
M[<数字>][*] = 
M[<数字>][id] = 
M[<数字>][[] = 
M[<数字>][]] = 
M[<数字>][digit] = <数字>->digit
M[<数字>][/] = 
M[<数字>][+] = 
M[<数字>][-] = 
M[<数字>][=] = 
M[<数字>][,] = 
M[<数字>][;] = 
M[<数字>][string] = 
M[<数字>][for] = 
M[<数字>][<] = 
M[<数字>][>] = 
M[<数字>][==] = 
M[<数字>][!=] = 
M[<数字>][++] = 
M[<数字>][--] = 
M[<数字>][if] = 
M[<数字>][else] = 
M[<数字>][return] = 


M[<因子>][(] = <因子>-><因式><因式递归>
M[<因子>][)] = 
M[<因子>][{] = 
M[<因子>][}] = 
M[<因子>][describe] = 
M[<因子>][type] = 
M[<因子>][*] = 
M[<因子>][id] = <因子>-><因式><因式递归>
M[<因子>][[] = 
M[<因子>][]] = 
M[<因子>][digit] = <因子>-><因式><因式递归>
M[<因子>][/] = 
M[<因子>][+] = 
M[<因子>][-] = 
M[<因子>][=] = 
M[<因子>][,] = 
M[<因子>][;] = 
M[<因子>][string] = 
M[<因子>][for] = 
M[<因子>][<] = 
M[<因子>][>] = 
M[<因子>][==] = 
M[<因子>][!=] = 
M[<因子>][++] = 
M[<因子>][--] = 
M[<因子>][if] = 
M[<因子>][else] = 
M[<因子>][return] = 


M[<项>][(] = 
M[<项>][)] = <项>->$
M[<项>][{] = 
M[<项>][}] = 
M[<项>][describe] = 
M[<项>][type] = 
M[<项>][*] = 
M[<项>][id] = 
M[<项>][[] = 
M[<项>][]] = 
M[<项>][digit] = 
M[<项>][/] = 
M[<项>][+] = <项>->+<因子><项>
M[<项>][-] = <项>->-<因子><项>
M[<项>][=] = 
M[<项>][,] = <项>->$
M[<项>][;] = <项>->$
M[<项>][string] = 
M[<项>][for] = 
M[<项>][<] = <项>->$
M[<项>][>] = <项>->$
M[<项>][==] = <项>->$
M[<项>][!=] = <项>->$
M[<项>][++] = 
M[<项>][--] = 
M[<项>][if] = 
M[<项>][else] = 
M[<项>][return] = 


M[<因式递归>][(] = 
M[<因式递归>][)] = <因式递归>->$
M[<因式递归>][{] = 
M[<因式递归>][}] = 
M[<因式递归>][describe] = 
M[<因式递归>][type] = 
M[<因式递归>][*] = <因式递归>->*<因式><因式递归>
M[<因式递归>][id] = 
M[<因式递归>][[] = 
M[<因式递归>][]] = 
M[<因式递归>][digit] = 
M[<因式递归>][/] = <因式递归>->/<因式><因式递归>
M[<因式递归>][+] = <因式递归>->$
M[<因式递归>][-] = <因式递归>->$
M[<因式递归>][=] = 
M[<因式递归>][,] = <因式递归>->$
M[<因式递归>][;] = <因式递归>->$
M[<因式递归>][string] = 
M[<因式递归>][for] = 
M[<因式递归>][<] = <因式递归>->$
M[<因式递归>][>] = <因式递归>->$
M[<因式递归>][==] = <因式递归>->$
M[<因式递归>][!=] = <因式递归>->$
M[<因式递归>][++] = 
M[<因式递归>][--] = 
M[<因式递归>][if] = 
M[<因式递归>][else] = 
M[<因式递归>][return] = 


M[<声明>][(] = 
M[<声明>][)] = 
M[<声明>][{] = 
M[<声明>][}] = 
M[<声明>][describe] = <声明>-><修饰词闭包><类型><变量><赋初值>
M[<声明>][type] = <声明>-><修饰词闭包><类型><变量><赋初值>
M[<声明>][*] = 
M[<声明>][id] = 
M[<声明>][[] = 
M[<声明>][]] = 
M[<声明>][digit] = 
M[<声明>][/] = 
M[<声明>][+] = 
M[<声明>][-] = 
M[<声明>][=] = 
M[<声明>][,] = 
M[<声明>][;] = 
M[<声明>][string] = 
M[<声明>][for] = 
M[<声明>][<] = 
M[<声明>][>] = 
M[<声明>][==] = 
M[<声明>][!=] = 
M[<声明>][++] = 
M[<声明>][--] = 
M[<声明>][if] = 
M[<声明>][else] = 
M[<声明>][return] = 


M[<声明闭包>][(] = 
M[<声明闭包>][)] = <声明闭包>->$
M[<声明闭包>][{] = 
M[<声明闭包>][}] = 
M[<声明闭包>][describe] = 
M[<声明闭包>][type] = 
M[<声明闭包>][*] = 
M[<声明闭包>][id] = 
M[<声明闭包>][[] = 
M[<声明闭包>][]] = 
M[<声明闭包>][digit] = 
M[<声明闭包>][/] = 
M[<声明闭包>][+] = 
M[<声明闭包>][-] = 
M[<声明闭包>][=] = 
M[<声明闭包>][,] = <声明闭包>->,<声明><声明闭包>
M[<声明闭包>][;] = 
M[<声明闭包>][string] = 
M[<声明闭包>][for] = 
M[<声明闭包>][<] = 
M[<声明闭包>][>] = 
M[<声明闭包>][==] = 
M[<声明闭包>][!=] = 
M[<声明闭包>][++] = 
M[<声明闭包>][--] = 
M[<声明闭包>][if] = 
M[<声明闭包>][else] = 
M[<声明闭包>][return] = 


M[<赋初值>][(] = 
M[<赋初值>][)] = <赋初值>->$
M[<赋初值>][{] = 
M[<赋初值>][}] = 
M[<赋初值>][describe] = 
M[<赋初值>][type] = 
M[<赋初值>][*] = 
M[<赋初值>][id] = 
M[<赋初值>][[] = 
M[<赋初值>][]] = 
M[<赋初值>][digit] = 
M[<赋初值>][/] = 
M[<赋初值>][+] = 
M[<赋初值>][-] = 
M[<赋初值>][=] = <赋初值>->=<右值>
M[<赋初值>][,] = <赋初值>->$
M[<赋初值>][;] = <赋初值>->$
M[<赋初值>][string] = 
M[<赋初值>][for] = 
M[<赋初值>][<] = 
M[<赋初值>][>] = 
M[<赋初值>][==] = 
M[<赋初值>][!=] = 
M[<赋初值>][++] = 
M[<赋初值>][--] = 
M[<赋初值>][if] = 
M[<赋初值>][else] = 
M[<赋初值>][return] = 


M[<右值>][(] = <右值>-><表达式>
M[<右值>][)] = 
M[<右值>][{] = <右值>->{<多个数据>}
M[<右值>][}] = 
M[<右值>][describe] = 
M[<右值>][type] = 
M[<右值>][*] = 
M[<右值>][id] = <右值>-><表达式>
M[<右值>][[] = 
M[<右值>][]] = 
M[<右值>][digit] = <右值>-><表达式>
M[<右值>][/] = 
M[<右值>][+] = 
M[<右值>][-] = 
M[<右值>][=] = 
M[<右值>][,] = 
M[<右值>][;] = 
M[<右值>][string] = 
M[<右值>][for] = 
M[<右值>][<] = 
M[<右值>][>] = 
M[<右值>][==] = 
M[<右值>][!=] = 
M[<右值>][++] = 
M[<右值>][--] = 
M[<右值>][if] = 
M[<右值>][else] = 
M[<右值>][return] = 


M[<多个数据>][(] = 
M[<多个数据>][)] = 
M[<多个数据>][{] = 
M[<多个数据>][}] = 
M[<多个数据>][describe] = 
M[<多个数据>][type] = 
M[<多个数据>][*] = 
M[<多个数据>][id] = 
M[<多个数据>][[] = 
M[<多个数据>][]] = 
M[<多个数据>][digit] = <多个数据>-><数字><数字闭包>
M[<多个数据>][/] = 
M[<多个数据>][+] = 
M[<多个数据>][-] = 
M[<多个数据>][=] = 
M[<多个数据>][,] = 
M[<多个数据>][;] = 
M[<多个数据>][string] = 
M[<多个数据>][for] = 
M[<多个数据>][<] = 
M[<多个数据>][>] = 
M[<多个数据>][==] = 
M[<多个数据>][!=] = 
M[<多个数据>][++] = 
M[<多个数据>][--] = 
M[<多个数据>][if] = 
M[<多个数据>][else] = 
M[<多个数据>][return] = 


M[<数字闭包>][(] = 
M[<数字闭包>][)] = 
M[<数字闭包>][{] = 
M[<数字闭包>][}] = <数字闭包>->$
M[<数字闭包>][describe] = 
M[<数字闭包>][type] = 
M[<数字闭包>][*] = 
M[<数字闭包>][id] = 
M[<数字闭包>][[] = 
M[<数字闭包>][]] = 
M[<数字闭包>][digit] = 
M[<数字闭包>][/] = 
M[<数字闭包>][+] = 
M[<数字闭包>][-] = 
M[<数字闭包>][=] = 
M[<数字闭包>][,] = <数字闭包>->,<数字><数字闭包>
M[<数字闭包>][;] = 
M[<数字闭包>][string] = 
M[<数字闭包>][for] = 
M[<数字闭包>][<] = 
M[<数字闭包>][>] = 
M[<数字闭包>][==] = 
M[<数字闭包>][!=] = 
M[<数字闭包>][++] = 
M[<数字闭包>][--] = 
M[<数字闭包>][if] = 
M[<数字闭包>][else] = 
M[<数字闭包>][return] = 


M[<声明语句闭包>][(] = 
M[<声明语句闭包>][)] = 
M[<声明语句闭包>][{] = 
M[<声明语句闭包>][}] = <声明语句闭包>->$
M[<声明语句闭包>][describe] = <声明语句闭包>-><声明语句><声明语句闭包>
M[<声明语句闭包>][type] = <声明语句闭包>-><声明语句><声明语句闭包>
M[<声明语句闭包>][*] = 
M[<声明语句闭包>][id] = <声明语句闭包>->$
M[<声明语句闭包>][[] = 
M[<声明语句闭包>][]] = 
M[<声明语句闭包>][digit] = 
M[<声明语句闭包>][/] = 
M[<声明语句闭包>][+] = 
M[<声明语句闭包>][-] = 
M[<声明语句闭包>][=] = 
M[<声明语句闭包>][,] = 
M[<声明语句闭包>][;] = 
M[<声明语句闭包>][string] = 
M[<声明语句闭包>][for] = <声明语句闭包>->$
M[<声明语句闭包>][<] = 
M[<声明语句闭包>][>] = 
M[<声明语句闭包>][==] = 
M[<声明语句闭包>][!=] = 
M[<声明语句闭包>][++] = 
M[<声明语句闭包>][--] = 
M[<声明语句闭包>][if] = <声明语句闭包>->$
M[<声明语句闭包>][else] = 
M[<声明语句闭包>][return] = <声明语句闭包>->$


M[<函数块闭包>][(] = 
M[<函数块闭包>][)] = 
M[<函数块闭包>][{] = 
M[<函数块闭包>][}] = <函数块闭包>->$
M[<函数块闭包>][describe] = 
M[<函数块闭包>][type] = 
M[<函数块闭包>][*] = 
M[<函数块闭包>][id] = <函数块闭包>-><赋值函数><函数块闭包>
M[<函数块闭包>][[] = 
M[<函数块闭包>][]] = 
M[<函数块闭包>][digit] = 
M[<函数块闭包>][/] = 
M[<函数块闭包>][+] = 
M[<函数块闭包>][-] = 
M[<函数块闭包>][=] = 
M[<函数块闭包>][,] = 
M[<函数块闭包>][;] = 
M[<函数块闭包>][string] = 
M[<函数块闭包>][for] = <函数块闭包>-><函数块闭包>
M[<函数块闭包>][<] = 
M[<函数块闭包>][>] = 
M[<函数块闭包>][==] = 
M[<函数块闭包>][!=] = 
M[<函数块闭包>][++] = 
M[<函数块闭包>][--] = 
M[<函数块闭包>][if] = <函数块闭包>-><条件语句><函数块闭包>
M[<函数块闭包>][else] = 
M[<函数块闭包>][return] = <函数块闭包>-><函数返回><函数块闭包>


M[<声明语句>][(] = 
M[<声明语句>][)] = 
M[<声明语句>][{] = 
M[<声明语句>][}] = 
M[<声明语句>][describe] = <声明语句>-><声明>;
M[<声明语句>][type] = <声明语句>-><声明>;
M[<声明语句>][*] = 
M[<声明语句>][id] = 
M[<声明语句>][[] = 
M[<声明语句>][]] = 
M[<声明语句>][digit] = 
M[<声明语句>][/] = 
M[<声明语句>][+] = 
M[<声明语句>][-] = 
M[<声明语句>][=] = 
M[<声明语句>][,] = 
M[<声明语句>][;] = 
M[<声明语句>][string] = 
M[<声明语句>][for] = 
M[<声明语句>][<] = 
M[<声明语句>][>] = 
M[<声明语句>][==] = 
M[<声明语句>][!=] = 
M[<声明语句>][++] = 
M[<声明语句>][--] = 
M[<声明语句>][if] = 
M[<声明语句>][else] = 
M[<声明语句>][return] = 


M[<赋值函数>][(] = 
M[<赋值函数>][)] = 
M[<赋值函数>][{] = 
M[<赋值函数>][}] = 
M[<赋值函数>][describe] = 
M[<赋值函数>][type] = 
M[<赋值函数>][*] = 
M[<赋值函数>][id] = <赋值函数>-><变量><赋值或函数调用>
M[<赋值函数>][[] = 
M[<赋值函数>][]] = 
M[<赋值函数>][digit] = 
M[<赋值函数>][/] = 
M[<赋值函数>][+] = 
M[<赋值函数>][-] = 
M[<赋值函数>][=] = 
M[<赋值函数>][,] = 
M[<赋值函数>][;] = 
M[<赋值函数>][string] = 
M[<赋值函数>][for] = 
M[<赋值函数>][<] = 
M[<赋值函数>][>] = 
M[<赋值函数>][==] = 
M[<赋值函数>][!=] = 
M[<赋值函数>][++] = 
M[<赋值函数>][--] = 
M[<赋值函数>][if] = 
M[<赋值函数>][else] = 
M[<赋值函数>][return] = 


M[][(] = 
M[][)] = 
M[][{] = 
M[][}] = 
M[][describe] = 
M[][type] = 
M[][*] = 
M[][id] = 
M[][[] = 
M[][]] = 
M[][digit] = 
M[][/] = 
M[][+] = 
M[][-] = 
M[][=] = 
M[][,] = 
M[][;] = 
M[][string] = 
M[][for] = ->for(<赋值函数><逻辑表达式>;<后缀表达式>){<函数块>}
M[][<] = 
M[][>] = 
M[][==] = 
M[][!=] = 
M[][++] = 
M[][--] = 
M[][if] = 
M[][else] = 
M[][return] = 


M[<条件语句>][(] = 
M[<条件语句>][)] = 
M[<条件语句>][{] = 
M[<条件语句>][}] = 
M[<条件语句>][describe] = 
M[<条件语句>][type] = 
M[<条件语句>][*] = 
M[<条件语句>][id] = 
M[<条件语句>][[] = 
M[<条件语句>][]] = 
M[<条件语句>][digit] = 
M[<条件语句>][/] = 
M[<条件语句>][+] = 
M[<条件语句>][-] = 
M[<条件语句>][=] = 
M[<条件语句>][,] = 
M[<条件语句>][;] = 
M[<条件语句>][string] = 
M[<条件语句>][for] = 
M[<条件语句>][<] = 
M[<条件语句>][>] = 
M[<条件语句>][==] = 
M[<条件语句>][!=] = 
M[<条件语句>][++] = 
M[<条件语句>][--] = 
M[<条件语句>][if] = <条件语句>->if(<逻辑表达式>){<函数块>}<否则语句>
M[<条件语句>][else] = 
M[<条件语句>][return] = 


M[<函数返回>][(] = 
M[<函数返回>][)] = 
M[<函数返回>][{] = 
M[<函数返回>][}] = 
M[<函数返回>][describe] = 
M[<函数返回>][type] = 
M[<函数返回>][*] = 
M[<函数返回>][id] = 
M[<函数返回>][[] = 
M[<函数返回>][]] = 
M[<函数返回>][digit] = 
M[<函数返回>][/] = 
M[<函数返回>][+] = 
M[<函数返回>][-] = 
M[<函数返回>][=] = 
M[<函数返回>][,] = 
M[<函数返回>][;] = 
M[<函数返回>][string] = 
M[<函数返回>][for] = 
M[<函数返回>][<] = 
M[<函数返回>][>] = 
M[<函数返回>][==] = 
M[<函数返回>][!=] = 
M[<函数返回>][++] = 
M[<函数返回>][--] = 
M[<函数返回>][if] = 
M[<函数返回>][else] = 
M[<函数返回>][return] = <函数返回>->return<因式>;


M[<赋值或函数调用>][(] = <赋值或函数调用>->(<参数列表>);
M[<赋值或函数调用>][)] = 
M[<赋值或函数调用>][{] = 
M[<赋值或函数调用>][}] = 
M[<赋值或函数调用>][describe] = 
M[<赋值或函数调用>][type] = 
M[<赋值或函数调用>][*] = 
M[<赋值或函数调用>][id] = 
M[<赋值或函数调用>][[] = 
M[<赋值或函数调用>][]] = 
M[<赋值或函数调用>][digit] = 
M[<赋值或函数调用>][/] = 
M[<赋值或函数调用>][+] = 
M[<赋值或函数调用>][-] = 
M[<赋值或函数调用>][=] = <赋值或函数调用>->=<右值>;
M[<赋值或函数调用>][,] = 
M[<赋值或函数调用>][;] = 
M[<赋值或函数调用>][string] = 
M[<赋值或函数调用>][for] = 
M[<赋值或函数调用>][<] = 
M[<赋值或函数调用>][>] = 
M[<赋值或函数调用>][==] = 
M[<赋值或函数调用>][!=] = 
M[<赋值或函数调用>][++] = 
M[<赋值或函数调用>][--] = 
M[<赋值或函数调用>][if] = 
M[<赋值或函数调用>][else] = 
M[<赋值或函数调用>][return] = 


M[<参数列表>][(] = 
M[<参数列表>][)] = 
M[<参数列表>][{] = 
M[<参数列表>][}] = 
M[<参数列表>][describe] = 
M[<参数列表>][type] = 
M[<参数列表>][*] = 
M[<参数列表>][id] = <参数列表>-><参数><参数闭包>
M[<参数列表>][[] = 
M[<参数列表>][]] = 
M[<参数列表>][digit] = <参数列表>-><参数><参数闭包>
M[<参数列表>][/] = 
M[<参数列表>][+] = 
M[<参数列表>][-] = 
M[<参数列表>][=] = 
M[<参数列表>][,] = 
M[<参数列表>][;] = 
M[<参数列表>][string] = <参数列表>-><参数><参数闭包>
M[<参数列表>][for] = 
M[<参数列表>][<] = 
M[<参数列表>][>] = 
M[<参数列表>][==] = 
M[<参数列表>][!=] = 
M[<参数列表>][++] = 
M[<参数列表>][--] = 
M[<参数列表>][if] = 
M[<参数列表>][else] = 
M[<参数列表>][return] = 


M[<参数>][(] = 
M[<参数>][)] = 
M[<参数>][{] = 
M[<参数>][}] = 
M[<参数>][describe] = 
M[<参数>][type] = 
M[<参数>][*] = 
M[<参数>][id] = <参数>-><标志符>
M[<参数>][[] = 
M[<参数>][]] = 
M[<参数>][digit] = <参数>-><数字>
M[<参数>][/] = 
M[<参数>][+] = 
M[<参数>][-] = 
M[<参数>][=] = 
M[<参数>][,] = 
M[<参数>][;] = 
M[<参数>][string] = <参数>-><字符串>
M[<参数>][for] = 
M[<参数>][<] = 
M[<参数>][>] = 
M[<参数>][==] = 
M[<参数>][!=] = 
M[<参数>][++] = 
M[<参数>][--] = 
M[<参数>][if] = 
M[<参数>][else] = 
M[<参数>][return] = 


M[<参数闭包>][(] = 
M[<参数闭包>][)] = <参数闭包>->$
M[<参数闭包>][{] = 
M[<参数闭包>][}] = 
M[<参数闭包>][describe] = 
M[<参数闭包>][type] = 
M[<参数闭包>][*] = 
M[<参数闭包>][id] = 
M[<参数闭包>][[] = 
M[<参数闭包>][]] = 
M[<参数闭包>][digit] = 
M[<参数闭包>][/] = 
M[<参数闭包>][+] = 
M[<参数闭包>][-] = 
M[<参数闭包>][=] = 
M[<参数闭包>][,] = <参数闭包>->,<参数><参数闭包>
M[<参数闭包>][;] = 
M[<参数闭包>][string] = 
M[<参数闭包>][for] = 
M[<参数闭包>][<] = 
M[<参数闭包>][>] = 
M[<参数闭包>][==] = 
M[<参数闭包>][!=] = 
M[<参数闭包>][++] = 
M[<参数闭包>][--] = 
M[<参数闭包>][if] = 
M[<参数闭包>][else] = 
M[<参数闭包>][return] = 


M[<字符串>][(] = 
M[<字符串>][)] = 
M[<字符串>][{] = 
M[<字符串>][}] = 
M[<字符串>][describe] = 
M[<字符串>][type] = 
M[<字符串>][*] = 
M[<字符串>][id] = 
M[<字符串>][[] = 
M[<字符串>][]] = 
M[<字符串>][digit] = 
M[<字符串>][/] = 
M[<字符串>][+] = 
M[<字符串>][-] = 
M[<字符串>][=] = 
M[<字符串>][,] = 
M[<字符串>][;] = 
M[<字符串>][string] = <字符串>->string
M[<字符串>][for] = 
M[<字符串>][<] = 
M[<字符串>][>] = 
M[<字符串>][==] = 
M[<字符串>][!=] = 
M[<字符串>][++] = 
M[<字符串>][--] = 
M[<字符串>][if] = 
M[<字符串>][else] = 
M[<字符串>][return] = 


M[<逻辑表达式>][(] = <逻辑表达式>-><表达式><逻辑运算符><表达式>
M[<逻辑表达式>][)] = 
M[<逻辑表达式>][{] = 
M[<逻辑表达式>][}] = 
M[<逻辑表达式>][describe] = 
M[<逻辑表达式>][type] = 
M[<逻辑表达式>][*] = 
M[<逻辑表达式>][id] = <逻辑表达式>-><表达式><逻辑运算符><表达式>
M[<逻辑表达式>][[] = 
M[<逻辑表达式>][]] = 
M[<逻辑表达式>][digit] = <逻辑表达式>-><表达式><逻辑运算符><表达式>
M[<逻辑表达式>][/] = 
M[<逻辑表达式>][+] = 
M[<逻辑表达式>][-] = 
M[<逻辑表达式>][=] = 
M[<逻辑表达式>][,] = 
M[<逻辑表达式>][;] = 
M[<逻辑表达式>][string] = 
M[<逻辑表达式>][for] = 
M[<逻辑表达式>][<] = 
M[<逻辑表达式>][>] = 
M[<逻辑表达式>][==] = 
M[<逻辑表达式>][!=] = 
M[<逻辑表达式>][++] = 
M[<逻辑表达式>][--] = 
M[<逻辑表达式>][if] = 
M[<逻辑表达式>][else] = 
M[<逻辑表达式>][return] = 


M[<后缀表达式>][(] = 
M[<后缀表达式>][)] = 
M[<后缀表达式>][{] = 
M[<后缀表达式>][}] = 
M[<后缀表达式>][describe] = 
M[<后缀表达式>][type] = 
M[<后缀表达式>][*] = 
M[<后缀表达式>][id] = <后缀表达式>-><变量><后缀运算符>
M[<后缀表达式>][[] = 
M[<后缀表达式>][]] = 
M[<后缀表达式>][digit] = 
M[<后缀表达式>][/] = 
M[<后缀表达式>][+] = 
M[<后缀表达式>][-] = 
M[<后缀表达式>][=] = 
M[<后缀表达式>][,] = 
M[<后缀表达式>][;] = 
M[<后缀表达式>][string] = 
M[<后缀表达式>][for] = 
M[<后缀表达式>][<] = 
M[<后缀表达式>][>] = 
M[<后缀表达式>][==] = 
M[<后缀表达式>][!=] = 
M[<后缀表达式>][++] = 
M[<后缀表达式>][--] = 
M[<后缀表达式>][if] = 
M[<后缀表达式>][else] = 
M[<后缀表达式>][return] = 


M[<逻辑运算符>][(] = 
M[<逻辑运算符>][)] = 
M[<逻辑运算符>][{] = 
M[<逻辑运算符>][}] = 
M[<逻辑运算符>][describe] = 
M[<逻辑运算符>][type] = 
M[<逻辑运算符>][*] = 
M[<逻辑运算符>][id] = 
M[<逻辑运算符>][[] = 
M[<逻辑运算符>][]] = 
M[<逻辑运算符>][digit] = 
M[<逻辑运算符>][/] = 
M[<逻辑运算符>][+] = 
M[<逻辑运算符>][-] = 
M[<逻辑运算符>][=] = 
M[<逻辑运算符>][,] = 
M[<逻辑运算符>][;] = 
M[<逻辑运算符>][string] = 
M[<逻辑运算符>][for] = 
M[<逻辑运算符>][<] = <逻辑运算符>-><
M[<逻辑运算符>][>] = <逻辑运算符>->>
M[<逻辑运算符>][==] = <逻辑运算符>->==
M[<逻辑运算符>][!=] = <逻辑运算符>->!=
M[<逻辑运算符>][++] = 
M[<逻辑运算符>][--] = 
M[<逻辑运算符>][if] = 
M[<逻辑运算符>][else] = 
M[<逻辑运算符>][return] = 


M[<后缀运算符>][(] = 
M[<后缀运算符>][)] = 
M[<后缀运算符>][{] = 
M[<后缀运算符>][}] = 
M[<后缀运算符>][describe] = 
M[<后缀运算符>][type] = 
M[<后缀运算符>][*] = 
M[<后缀运算符>][id] = 
M[<后缀运算符>][[] = 
M[<后缀运算符>][]] = 
M[<后缀运算符>][digit] = 
M[<后缀运算符>][/] = 
M[<后缀运算符>][+] = 
M[<后缀运算符>][-] = 
M[<后缀运算符>][=] = 
M[<后缀运算符>][,] = 
M[<后缀运算符>][;] = 
M[<后缀运算符>][string] = 
M[<后缀运算符>][for] = 
M[<后缀运算符>][<] = 
M[<后缀运算符>][>] = 
M[<后缀运算符>][==] = 
M[<后缀运算符>][!=] = 
M[<后缀运算符>][++] = <后缀运算符>->++
M[<后缀运算符>][--] = <后缀运算符>->--
M[<后缀运算符>][if] = 
M[<后缀运算符>][else] = 
M[<后缀运算符>][return] = 


M[<否则语句>][(] = 
M[<否则语句>][)] = 
M[<否则语句>][{] = 
M[<否则语句>][}] = <否则语句>->$
M[<否则语句>][describe] = 
M[<否则语句>][type] = 
M[<否则语句>][*] = 
M[<否则语句>][id] = <否则语句>->$
M[<否则语句>][[] = 
M[<否则语句>][]] = 
M[<否则语句>][digit] = 
M[<否则语句>][/] = 
M[<否则语句>][+] = 
M[<否则语句>][-] = 
M[<否则语句>][=] = 
M[<否则语句>][,] = 
M[<否则语句>][;] = 
M[<否则语句>][string] = 
M[<否则语句>][for] = <否则语句>->$
M[<否则语句>][<] = 
M[<否则语句>][>] = 
M[<否则语句>][==] = 
M[<否则语句>][!=] = 
M[<否则语句>][++] = 
M[<否则语句>][--] = 
M[<否则语句>][if] = <否则语句>->$
M[<否则语句>][else] = <否则语句>->else{<函数块>}
M[<否则语句>][return] = <否则语句>->$

语法分析表：

preciateResult.txt：

第1步
符号栈:<函数定义> # 
输入栈:type id ( ) { type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<函数定义>-><修饰词闭包><类型><变量>(<参数声明>){<函数块>}

第2步
符号栈:<修饰词闭包> <类型> <变量> ( <参数声明> ) { <函数块> } # 
输入栈:type id ( ) { type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<修饰词闭包>->$

第3步
符号栈:<类型> <变量> ( <参数声明> ) { <函数块> } # 
输入栈:type id ( ) { type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<类型>->type<取地址>

第4步
符号栈:type <取地址> <变量> ( <参数声明> ) { <函数块> } # 
输入栈:type id ( ) { type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第5步
符号栈:<取地址> <变量> ( <参数声明> ) { <函数块> } # 
输入栈:id ( ) { type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<取地址>-><星号闭包>

第6步
符号栈:<星号闭包> <变量> ( <参数声明> ) { <函数块> } # 
输入栈:id ( ) { type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<星号闭包>->$

第7步
符号栈:<变量> ( <参数声明> ) { <函数块> } # 
输入栈:id ( ) { type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第8步
符号栈:<标志符> <数组下标> ( <参数声明> ) { <函数块> } # 
输入栈:id ( ) { type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第9步
符号栈:id <数组下标> ( <参数声明> ) { <函数块> } # 
输入栈:id ( ) { type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第10步
符号栈:<数组下标> ( <参数声明> ) { <函数块> } # 
输入栈:( ) { type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第11步
符号栈:( <参数声明> ) { <函数块> } # 
输入栈:( ) { type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第12步
符号栈:<参数声明> ) { <函数块> } # 
输入栈:) { type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<参数声明>->$

第13步
符号栈:) { <函数块> } # 
输入栈:) { type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第14步
符号栈:{ <函数块> } # 
输入栈:{ type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第15步
符号栈:<函数块> } # 
输入栈:type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<函数块>-><声明语句闭包><函数块闭包>

第16步
符号栈:<声明语句闭包> <函数块闭包> } # 
输入栈:type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<声明语句闭包>-><声明语句><声明语句闭包>

第17步
符号栈:<声明语句> <声明语句闭包> <函数块闭包> } # 
输入栈:type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<声明语句>-><声明>;

第18步
符号栈:<声明> ; <声明语句闭包> <函数块闭包> } # 
输入栈:type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<声明>-><修饰词闭包><类型><变量><赋初值>

第19步
符号栈:<修饰词闭包> <类型> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<修饰词闭包>->$

第20步
符号栈:<类型> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<类型>->type<取地址>

第21步
符号栈:type <取地址> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:type id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第22步
符号栈:<取地址> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<取地址>-><星号闭包>

第23步
符号栈:<星号闭包> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<星号闭包>->$

第24步
符号栈:<变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第25步
符号栈:<标志符> <数组下标> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第26步
符号栈:id <数组下标> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id = digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第27步
符号栈:<数组下标> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:= digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第28步
符号栈:<赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:= digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<赋初值>->=<右值>

第29步
符号栈:= <右值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:= digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第30步
符号栈:<右值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<右值>-><表达式>

第31步
符号栈:<表达式> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<表达式>-><因子><项>

第32步
符号栈:<因子> <项> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因子>-><因式><因式递归>

第33步
符号栈:<因式> <因式递归> <项> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><数字>

第34步
符号栈:<数字> <因式递归> <项> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第35步
符号栈:digit <因式递归> <项> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第36步
符号栈:<因式递归> <项> ; <声明语句闭包> <函数块闭包> } # 
输入栈:; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式递归>->$

第37步
符号栈:<项> ; <声明语句闭包> <函数块闭包> } # 
输入栈:; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<项>->$

第38步
符号栈:; <声明语句闭包> <函数块闭包> } # 
输入栈:; type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第39步
符号栈:<声明语句闭包> <函数块闭包> } # 
输入栈:type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<声明语句闭包>-><声明语句><声明语句闭包>

第40步
符号栈:<声明语句> <声明语句闭包> <函数块闭包> } # 
输入栈:type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<声明语句>-><声明>;

第41步
符号栈:<声明> ; <声明语句闭包> <函数块闭包> } # 
输入栈:type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<声明>-><修饰词闭包><类型><变量><赋初值>

第42步
符号栈:<修饰词闭包> <类型> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<修饰词闭包>->$

第43步
符号栈:<类型> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<类型>->type<取地址>

第44步
符号栈:type <取地址> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:type id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第45步
符号栈:<取地址> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<取地址>-><星号闭包>

第46步
符号栈:<星号闭包> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<星号闭包>->$

第47步
符号栈:<变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第48步
符号栈:<标志符> <数组下标> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第49步
符号栈:id <数组下标> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id = digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第50步
符号栈:<数组下标> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:= digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第51步
符号栈:<赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:= digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<赋初值>->=<右值>

第52步
符号栈:= <右值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:= digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第53步
符号栈:<右值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<右值>-><表达式>

第54步
符号栈:<表达式> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<表达式>-><因子><项>

第55步
符号栈:<因子> <项> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因子>-><因式><因式递归>

第56步
符号栈:<因式> <因式递归> <项> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><数字>

第57步
符号栈:<数字> <因式递归> <项> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第58步
符号栈:digit <因式递归> <项> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第59步
符号栈:<因式递归> <项> ; <声明语句闭包> <函数块闭包> } # 
输入栈:; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式递归>->$

第60步
符号栈:<项> ; <声明语句闭包> <函数块闭包> } # 
输入栈:; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<项>->$

第61步
符号栈:; <声明语句闭包> <函数块闭包> } # 
输入栈:; type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第62步
符号栈:<声明语句闭包> <函数块闭包> } # 
输入栈:type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<声明语句闭包>-><声明语句><声明语句闭包>

第63步
符号栈:<声明语句> <声明语句闭包> <函数块闭包> } # 
输入栈:type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<声明语句>-><声明>;

第64步
符号栈:<声明> ; <声明语句闭包> <函数块闭包> } # 
输入栈:type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<声明>-><修饰词闭包><类型><变量><赋初值>

第65步
符号栈:<修饰词闭包> <类型> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<修饰词闭包>->$

第66步
符号栈:<类型> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<类型>->type<取地址>

第67步
符号栈:type <取地址> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:type id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第68步
符号栈:<取地址> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<取地址>-><星号闭包>

第69步
符号栈:<星号闭包> <变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<星号闭包>->$

第70步
符号栈:<变量> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第71步
符号栈:<标志符> <数组下标> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第72步
符号栈:id <数组下标> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:id [ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第73步
符号栈:<数组下标> <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:[ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->[<因式>]

第74步
符号栈:[ <因式> ] <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:[ digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第75步
符号栈:<因式> ] <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><数字>

第76步
符号栈:<数字> ] <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第77步
符号栈:digit ] <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit ] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第78步
符号栈:] <赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:] = { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第79步
符号栈:<赋初值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:= { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<赋初值>->=<右值>

第80步
符号栈:= <右值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:= { digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第81步
符号栈:<右值> ; <声明语句闭包> <函数块闭包> } # 
输入栈:{ digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<右值>->{<多个数据>}

第82步
符号栈:{ <多个数据> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:{ digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第83步
符号栈:<多个数据> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<多个数据>-><数字><数字闭包>

第84步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第85步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第86步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第87步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第88步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第89步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第90步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第91步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第92步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第93步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第94步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第95步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第96步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第97步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第98步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第99步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第100步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第101步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第102步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第103步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第104步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第105步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第106步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第107步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第108步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第109步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第110步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第111步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第112步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第113步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第114步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第115步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第116步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第117步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第118步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第119步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第120步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第121步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第122步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第123步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第124步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第125步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第126步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第127步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第128步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第129步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第130步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第131步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第132步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第133步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第134步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第135步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第136步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第137步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第138步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第139步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第140步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第141步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第142步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第143步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第144步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第145步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第146步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第147步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第148步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第149步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第150步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第151步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第152步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第153步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第154步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第155步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第156步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第157步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit , digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第158步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->,<数字><数字闭包>

第159步
符号栈:, <数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:, digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第160步
符号栈:<数字> <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第161步
符号栈:digit <数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:digit } ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第162步
符号栈:<数字闭包> } ; <声明语句闭包> <函数块闭包> } # 
输入栈:} ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字闭包>->$

第163步
符号栈:} ; <声明语句闭包> <函数块闭包> } # 
输入栈:} ; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第164步
符号栈:; <声明语句闭包> <函数块闭包> } # 
输入栈:; for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第165步
符号栈:<声明语句闭包> <函数块闭包> } # 
输入栈:for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<声明语句闭包>->$

第166步
符号栈:<函数块闭包> } # 
输入栈:for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<函数块闭包>-><函数块闭包>

第167步
符号栈: <函数块闭包> } # 
输入栈:for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：->for(<赋值函数><逻辑表达式>;<后缀表达式>){<函数块>}

第168步
符号栈:for ( <赋值函数> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:for ( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第169步
符号栈:( <赋值函数> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:( id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第170步
符号栈:<赋值函数> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<赋值函数>-><变量><赋值或函数调用>

第171步
符号栈:<变量> <赋值或函数调用> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第172步
符号栈:<标志符> <数组下标> <赋值或函数调用> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第173步
符号栈:id <数组下标> <赋值或函数调用> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:id = digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第174步
符号栈:<数组下标> <赋值或函数调用> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:= digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第175步
符号栈:<赋值或函数调用> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:= digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<赋值或函数调用>->=<右值>;

第176步
符号栈:= <右值> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:= digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第177步
符号栈:<右值> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<右值>-><表达式>

第178步
符号栈:<表达式> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<表达式>-><因子><项>

第179步
符号栈:<因子> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因子>-><因式><因式递归>

第180步
符号栈:<因式> <因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><数字>

第181步
符号栈:<数字> <因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第182步
符号栈:digit <因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:digit ; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第183步
符号栈:<因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式递归>->$

第184步
符号栈:<项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<项>->$

第185步
符号栈:; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:; id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第186步
符号栈:<逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<逻辑表达式>-><表达式><逻辑运算符><表达式>

第187步
符号栈:<表达式> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<表达式>-><因子><项>

第188步
符号栈:<因子> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因子>-><因式><因式递归>

第189步
符号栈:<因式> <因式递归> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><变量>

第190步
符号栈:<变量> <因式递归> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第191步
符号栈:<标志符> <数组下标> <因式递归> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第192步
符号栈:id <数组下标> <因式递归> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:id < digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第193步
符号栈:<数组下标> <因式递归> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:< digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第194步
符号栈:<因式递归> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:< digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式递归>->$

第195步
符号栈:<项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:< digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<项>->$

第196步
符号栈:<逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:< digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<逻辑运算符>-><

第197步
符号栈:< <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:< digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第198步
符号栈:<表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<表达式>-><因子><项>

第199步
符号栈:<因子> <项> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因子>-><因式><因式递归>

第200步
符号栈:<因式> <因式递归> <项> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><数字>

第201步
符号栈:<数字> <因式递归> <项> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第202步
符号栈:digit <因式递归> <项> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:digit ; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第203步
符号栈:<因式递归> <项> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式递归>->$

第204步
符号栈:<项> ; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<项>->$

第205步
符号栈:; <后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:; id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第206步
符号栈:<后缀表达式> ) { <函数块> } <函数块闭包> } # 
输入栈:id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<后缀表达式>-><变量><后缀运算符>

第207步
符号栈:<变量> <后缀运算符> ) { <函数块> } <函数块闭包> } # 
输入栈:id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第208步
符号栈:<标志符> <数组下标> <后缀运算符> ) { <函数块> } <函数块闭包> } # 
输入栈:id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第209步
符号栈:id <数组下标> <后缀运算符> ) { <函数块> } <函数块闭包> } # 
输入栈:id ++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第210步
符号栈:<数组下标> <后缀运算符> ) { <函数块> } <函数块闭包> } # 
输入栈:++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第211步
符号栈:<后缀运算符> ) { <函数块> } <函数块闭包> } # 
输入栈:++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<后缀运算符>->++

第212步
符号栈:++ ) { <函数块> } <函数块闭包> } # 
输入栈:++ ) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第213步
符号栈:) { <函数块> } <函数块闭包> } # 
输入栈:) { for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第214步
符号栈:{ <函数块> } <函数块闭包> } # 
输入栈:{ for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第215步
符号栈:<函数块> } <函数块闭包> } # 
输入栈:for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<函数块>-><声明语句闭包><函数块闭包>

第216步
符号栈:<声明语句闭包> <函数块闭包> } <函数块闭包> } # 
输入栈:for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<声明语句闭包>->$

第217步
符号栈:<函数块闭包> } <函数块闭包> } # 
输入栈:for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<函数块闭包>-><函数块闭包>

第218步
符号栈: <函数块闭包> } <函数块闭包> } # 
输入栈:for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：->for(<赋值函数><逻辑表达式>;<后缀表达式>){<函数块>}

第219步
符号栈:for ( <赋值函数> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第220步
符号栈:( <赋值函数> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第221步
符号栈:<赋值函数> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<赋值函数>-><变量><赋值或函数调用>

第222步
符号栈:<变量> <赋值或函数调用> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第223步
符号栈:<标志符> <数组下标> <赋值或函数调用> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第224步
符号栈:id <数组下标> <赋值或函数调用> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第225步
符号栈:<数组下标> <赋值或函数调用> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:= id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第226步
符号栈:<赋值或函数调用> <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:= id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<赋值或函数调用>->=<右值>;

第227步
符号栈:= <右值> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:= id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第228步
符号栈:<右值> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<右值>-><表达式>

第229步
符号栈:<表达式> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<表达式>-><因子><项>

第230步
符号栈:<因子> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因子>-><因式><因式递归>

第231步
符号栈:<因式> <因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><变量>

第232步
符号栈:<变量> <因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第233步
符号栈:<标志符> <数组下标> <因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第234步
符号栈:id <数组下标> <因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第235步
符号栈:<数组下标> <因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:+ digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第236步
符号栈:<因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:+ digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式递归>->$

第237步
符号栈:<项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:+ digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<项>->+<因子><项>

第238步
符号栈:+ <因子> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:+ digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第239步
符号栈:<因子> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因子>-><因式><因式递归>

第240步
符号栈:<因式> <因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><数字>

第241步
符号栈:<数字> <因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第242步
符号栈:digit <因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第243步
符号栈:<因式递归> <项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式递归>->$

第244步
符号栈:<项> ; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<项>->$

第245步
符号栈:; <逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第246步
符号栈:<逻辑表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<逻辑表达式>-><表达式><逻辑运算符><表达式>

第247步
符号栈:<表达式> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<表达式>-><因子><项>

第248步
符号栈:<因子> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因子>-><因式><因式递归>

第249步
符号栈:<因式> <因式递归> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><变量>

第250步
符号栈:<变量> <因式递归> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第251步
符号栈:<标志符> <数组下标> <因式递归> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第252步
符号栈:id <数组下标> <因式递归> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第253步
符号栈:<数组下标> <因式递归> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:< digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第254步
符号栈:<因式递归> <项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:< digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式递归>->$

第255步
符号栈:<项> <逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:< digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<项>->$

第256步
符号栈:<逻辑运算符> <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:< digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<逻辑运算符>-><

第257步
符号栈:< <表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:< digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第258步
符号栈:<表达式> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<表达式>-><因子><项>

第259步
符号栈:<因子> <项> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因子>-><因式><因式递归>

第260步
符号栈:<因式> <因式递归> <项> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><数字>

第261步
符号栈:<数字> <因式递归> <项> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第262步
符号栈:digit <因式递归> <项> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第263步
符号栈:<因式递归> <项> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式递归>->$

第264步
符号栈:<项> ; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<项>->$

第265步
符号栈:; <后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第266步
符号栈:<后缀表达式> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<后缀表达式>-><变量><后缀运算符>

第267步
符号栈:<变量> <后缀运算符> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第268步
符号栈:<标志符> <数组下标> <后缀运算符> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第269步
符号栈:id <数组下标> <后缀运算符> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第270步
符号栈:<数组下标> <后缀运算符> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:-- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第271步
符号栈:<后缀运算符> ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:-- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<后缀运算符>->--

第272步
符号栈:-- ) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:-- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第273步
符号栈:) { <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第274步
符号栈:{ <函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:{ if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第275步
符号栈:<函数块> } <函数块闭包> } <函数块闭包> } # 
输入栈:if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<函数块>-><声明语句闭包><函数块闭包>

第276步
符号栈:<声明语句闭包> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<声明语句闭包>->$

第277步
符号栈:<函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<函数块闭包>-><条件语句><函数块闭包>

第278步
符号栈:<条件语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<条件语句>->if(<逻辑表达式>){<函数块>}<否则语句>

第279步
符号栈:if ( <逻辑表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第280步
符号栈:( <逻辑表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第281步
符号栈:<逻辑表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<逻辑表达式>-><表达式><逻辑运算符><表达式>

第282步
符号栈:<表达式> <逻辑运算符> <表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<表达式>-><因子><项>

第283步
符号栈:<因子> <项> <逻辑运算符> <表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因子>-><因式><因式递归>

第284步
符号栈:<因式> <因式递归> <项> <逻辑运算符> <表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><变量>

第285步
符号栈:<变量> <因式递归> <项> <逻辑运算符> <表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第286步
符号栈:<标志符> <数组下标> <因式递归> <项> <逻辑运算符> <表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第287步
符号栈:id <数组下标> <因式递归> <项> <逻辑运算符> <表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第288步
符号栈:<数组下标> <因式递归> <项> <逻辑运算符> <表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:== digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第289步
符号栈:<因式递归> <项> <逻辑运算符> <表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:== digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式递归>->$

第290步
符号栈:<项> <逻辑运算符> <表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:== digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<项>->$

第291步
符号栈:<逻辑运算符> <表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:== digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<逻辑运算符>->==

第292步
符号栈:== <表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:== digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第293步
符号栈:<表达式> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<表达式>-><因子><项>

第294步
符号栈:<因子> <项> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因子>-><因式><因式递归>

第295步
符号栈:<因式> <因式递归> <项> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><数字>

第296步
符号栈:<数字> <因式递归> <项> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数字>->digit

第297步
符号栈:digit <因式递归> <项> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第298步
符号栈:<因式递归> <项> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式递归>->$

第299步
符号栈:<项> ) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<项>->$

第300步
符号栈:) { <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:) { id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第301步
符号栈:{ <函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:{ id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第302步
符号栈:<函数块> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<函数块>-><声明语句闭包><函数块闭包>

第303步
符号栈:<声明语句闭包> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<声明语句闭包>->$

第304步
符号栈:<函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<函数块闭包>-><赋值函数><函数块闭包>

第305步
符号栈:<赋值函数> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<赋值函数>-><变量><赋值或函数调用>

第306步
符号栈:<变量> <赋值或函数调用> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第307步
符号栈:<标志符> <数组下标> <赋值或函数调用> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第308步
符号栈:id <数组下标> <赋值或函数调用> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id [ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第309步
符号栈:<数组下标> <赋值或函数调用> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:[ id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->[<因式>]

第310步
符号栈:[ <因式> ] <赋值或函数调用> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:[ id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第311步
符号栈:<因式> ] <赋值或函数调用> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><变量>

第312步
符号栈:<变量> ] <赋值或函数调用> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第313步
符号栈:<标志符> <数组下标> ] <赋值或函数调用> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id ] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第314步
符号栈:id <数组下标> ] <赋值或函数调用> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id ] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第315步
符号栈:<数组下标> ] <赋值或函数调用> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:] = id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第316步
符号栈:] <赋值或函数调用> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:] = id ; } } } id ( string ) ; return digit ; } # 
匹配!
第317步
符号栈:<赋值或函数调用> <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:= id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<赋值或函数调用>->=<右值>;

第318步
符号栈:= <右值> ; <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:= id ; } } } id ( string ) ; return digit ; } # 
匹配!
第319步
符号栈:<右值> ; <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<右值>-><表达式>

第320步
符号栈:<表达式> ; <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<表达式>-><因子><项>

第321步
符号栈:<因子> <项> ; <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因子>-><因式><因式递归>

第322步
符号栈:<因式> <因式递归> <项> ; <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式>-><变量>

第323步
符号栈:<变量> <因式递归> <项> ; <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第324步
符号栈:<标志符> <数组下标> <因式递归> <项> ; <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id ; } } } id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第325步
符号栈:id <数组下标> <因式递归> <项> ; <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:id ; } } } id ( string ) ; return digit ; } # 
匹配!
第326步
符号栈:<数组下标> <因式递归> <项> ; <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:; } } } id ( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第327步
符号栈:<因式递归> <项> ; <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:; } } } id ( string ) ; return digit ; } # 
所用推出式：<因式递归>->$

第328步
符号栈:<项> ; <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:; } } } id ( string ) ; return digit ; } # 
所用推出式：<项>->$

第329步
符号栈:; <函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:; } } } id ( string ) ; return digit ; } # 
匹配!
第330步
符号栈:<函数块闭包> } <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:} } } id ( string ) ; return digit ; } # 
所用推出式：<函数块闭包>->$

第331步
符号栈:} <否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:} } } id ( string ) ; return digit ; } # 
匹配!
第332步
符号栈:<否则语句> <函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:} } id ( string ) ; return digit ; } # 
所用推出式：<否则语句>->$

第333步
符号栈:<函数块闭包> } <函数块闭包> } <函数块闭包> } # 
输入栈:} } id ( string ) ; return digit ; } # 
所用推出式：<函数块闭包>->$

第334步
符号栈:} <函数块闭包> } <函数块闭包> } # 
输入栈:} } id ( string ) ; return digit ; } # 
匹配!
第335步
符号栈:<函数块闭包> } <函数块闭包> } # 
输入栈:} id ( string ) ; return digit ; } # 
所用推出式：<函数块闭包>->$

第336步
符号栈:} <函数块闭包> } # 
输入栈:} id ( string ) ; return digit ; } # 
匹配!
第337步
符号栈:<函数块闭包> } # 
输入栈:id ( string ) ; return digit ; } # 
所用推出式：<函数块闭包>-><赋值函数><函数块闭包>

第338步
符号栈:<赋值函数> <函数块闭包> } # 
输入栈:id ( string ) ; return digit ; } # 
所用推出式：<赋值函数>-><变量><赋值或函数调用>

第339步
符号栈:<变量> <赋值或函数调用> <函数块闭包> } # 
输入栈:id ( string ) ; return digit ; } # 
所用推出式：<变量>-><标志符><数组下标>

第340步
符号栈:<标志符> <数组下标> <赋值或函数调用> <函数块闭包> } # 
输入栈:id ( string ) ; return digit ; } # 
所用推出式：<标志符>->id

第341步
符号栈:id <数组下标> <赋值或函数调用> <函数块闭包> } # 
输入栈:id ( string ) ; return digit ; } # 
匹配!
第342步
符号栈:<数组下标> <赋值或函数调用> <函数块闭包> } # 
输入栈:( string ) ; return digit ; } # 
所用推出式：<数组下标>->$

第343步
符号栈:<赋值或函数调用> <函数块闭包> } # 
输入栈:( string ) ; return digit ; } # 
所用推出式：<赋值或函数调用>->(<参数列表>);

第344步
符号栈:( <参数列表> ) ; <函数块闭包> } # 
输入栈:( string ) ; return digit ; } # 
匹配!
第345步
符号栈:<参数列表> ) ; <函数块闭包> } # 
输入栈:string ) ; return digit ; } # 
所用推出式：<参数列表>-><参数><参数闭包>

第346步
符号栈:<参数> <参数闭包> ) ; <函数块闭包> } # 
输入栈:string ) ; return digit ; } # 
所用推出式：<参数>-><字符串>

第347步
符号栈:<字符串> <参数闭包> ) ; <函数块闭包> } # 
输入栈:string ) ; return digit ; } # 
所用推出式：<字符串>->string

第348步
符号栈:string <参数闭包> ) ; <函数块闭包> } # 
输入栈:string ) ; return digit ; } # 
匹配!
第349步
符号栈:<参数闭包> ) ; <函数块闭包> } # 
输入栈:) ; return digit ; } # 
所用推出式：<参数闭包>->$

第350步
符号栈:) ; <函数块闭包> } # 
输入栈:) ; return digit ; } # 
匹配!
第351步
符号栈:; <函数块闭包> } # 
输入栈:; return digit ; } # 
匹配!
第352步
符号栈:<函数块闭包> } # 
输入栈:return digit ; } # 
所用推出式：<函数块闭包>-><函数返回><函数块闭包>

第353步
符号栈:<函数返回> <函数块闭包> } # 
输入栈:return digit ; } # 
所用推出式：<函数返回>->return<因式>;

第354步
符号栈:return <因式> ; <函数块闭包> } # 
输入栈:return digit ; } # 
匹配!
第355步
符号栈:<因式> ; <函数块闭包> } # 
输入栈:digit ; } # 
所用推出式：<因式>-><数字>

第356步
符号栈:<数字> ; <函数块闭包> } # 
输入栈:digit ; } # 
所用推出式：<数字>->digit

第357步
符号栈:digit ; <函数块闭包> } # 
输入栈:digit ; } # 
匹配!
第358步
符号栈:; <函数块闭包> } # 
输入栈:; } # 
匹配!
第359步
符号栈:<函数块闭包> } # 
输入栈:} # 
所用推出式：<函数块闭包>->$

第360步
符号栈:} # 
输入栈:} # 
匹配!
第361步
符号栈:# 
输入栈:# 
成功!