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
<表达式> -> <因子> <项>
<因子> -> <因式> <因式递归>
<因式递归> -> * <因式> <因式递归> | / <因式> <因式递归> | $
<项> -> + <因子> <项> | - <因子> <项> | $
<參数声明> -> <声明> <声明闭包> | $
<声明> -> <修饰词闭包> <类型> <变量> <赋初值>
<赋初值> -> = <右值> | $
<右值> -> <表达式> | { <多个数据> }
<多个数据> -> <数字> <数字闭包>
<数字闭包> -> , <数字> <数字闭包> | $
<声明闭包> -> , <声明> <声明闭包> | $
<函数块> -> <声明语句闭包> <函数块闭包>
<声明语句闭包> -> <声明语句> <声明语句闭包> | $
<声明语句> -> <声明> ;
<函数块闭包> -> <赋值函数> <函数块闭包> | <for循环> <函数块闭包> | <条件语句> <函数块闭包> | <函数返回> <函数块闭包> | $
<赋值函数> -> <变量> <赋值或函数调用>
<赋值或函数调用> -> = <右值> ; | ( <參数列表> ) ;
<參数列表> -> <參数> <參数闭包>
<參数闭包> -> , <參数> <參数闭包> | $
<參数> -> <标志符> | <数字> | <字符串>
<字符串> -> string
<for循环> -> for ( <赋值函数> <逻辑表达式> ; <后缀表达式> ) { <函数块> }
<逻辑表达式> -> <表达式> <逻辑运算符> <表达式>
<逻辑运算符> -> < | > | == | !=
<后缀表达式> -> <变量> <后缀运算符>
<后缀运算符> -> ++ | --
<条件语句> -> if ( <逻辑表达式> ) { <函数块> } <否则语句>
<否则语句> -> else { <函数块> } | $
<函数返回> -> return <因式> ;

词法分析头文件：
LexAnalysis.h

//LexAnalysis.h
#ifndef _LEXANALYSIS_H
#define _LEXANALYSIS_H

//keyword
#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 "keyword"

//标志符
#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 <iostream>
#include <fstream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <iomanip>
#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<pair<const char *,int> > keyMap;
vector<pair<const char *,int> > operMap;
vector<pair<const char *,int> > limitMap;

//初始化C语言的keyword的集合
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<<"************************************分析表******************************"<<endl<<endl;
cout<<setw(30)<<"内容"<<setw(10)<<"描写叙述"<<"\t"<<"种别码"<<"\t"<<"地址"<<"\t"<<"行号"<<endl;
while(p!=NULL)
{
if(p->type == IDENTIFER)
{
cout<<setw(30)<<p->content<<setw(10)<<p->describe<<"\t"<<p->type<<"\t"<<p->addr<<"\t"<<p->line<<endl;
}
else
{
cout<<setw(30)<<p->content<<setw(10)<<p->describe<<"\t"<<p->type<<"\t"<<"\t"<<p->line<<endl;
}
p = p->next;
}
cout<<endl<<endl;
}
/*
错误种类：
1.float表示错误
2.double表示错误
3.凝视没有结束符
4.字符串常量没有结束符
5.字符常量没有结束符
6.非法字符
7.'('没有相应项
8.预处理错误
*/
void printErrorLink()
{
ErrorNode * p = errorHead;
p = p->next;
cout<<"************************************错误表******************************"<<endl<<endl;
cout<<setw(10)<<"内容"<<setw(30)<<"描写叙述"<<"\t"<<"类型"<<"\t"<<"行号"<<endl;
while(p!=NULL)
{
cout<<setw(10)<<p->content<<setw(30)<<p->describe<<"\t"<<p->type<<"\t"<<p->line<<endl;
p = p->next;
}
cout<<endl<<endl;
}
//标志符表，有反复部分。暂不考虑
void printIdentLink()
{
IdentiferNode * p = idenHead;
p = p->next;
cout<<"************************************标志符表******************************"<<endl<<endl;
cout<<setw(30)<<"内容"<<setw(10)<<"描写叙述"<<"\t"<<"种别码"<<"\t"<<"地址"<<"\t"<<"行号"<<endl;
while(p!=NULL)
{
cout<<setw(30)<<p->content<<setw(10)<<p->describe<<"\t"<<p->type<<"\t"<<p->addr<<"\t"<<p->line<<endl;
p = p->next;
}
cout<<endl<<endl;
}
int mystrlen(char * word)
{
if(*word == '\0')
{
return 0;
}
else
{
return 1+mystrlen(word+1);
}
}
//预处理，处理头文件和宏定义
void preProcess(char * word,int line)
{
const char * include_temp = "include";
const char * define_temp = "define";
char * p_include,*p_define;
int flag = 0;
p_include = strstr(word,include_temp);
if(p_include!=NULL)
{
flag = 1;
int i;
for(i=7;;)
{
if(*(p_include+i) == ' ' || *(p_include+i) == '\t')
{
i++;
}
else
{
break;
}
}
createNewNode(p_include+i,HEADER_DESC,HEADER,-1,line);
}
else
{
p_define = strstr(word,define_temp);
if(p_define!=NULL)
{
flag = 1;
int i;
for(i=7;;)
{
if(*(p_define+i) == ' ' || *(p_define+i) == '\t')
{
i++;
}
else
{
break;
}
}
createNewNode(p_define+i,CONSTANT_DESC,MACRO_VAL,-1,line);
}
}
if(flag == 0)
{
createNewError(word,PRE_PROCESS_ERROR,PRE_PROCESS_ERROR_NUM,line);
}
}

void close()
{
//delete idenHead;
//delete errorHead;
//delete normalHead;
}

int seekKey(char * word)
{
for(int i=0; i<keyMap.size(); i++)
{
if(strcmp(word,keyMap[i].first) == 0)
{
return i+1;
}
}
return IDENTIFER;
}

void scanner()
{
char filename[30];
char ch;
char array[30];//单词长度上限是30
char * word;
int i;
int line = 1;//行数

FILE * infile;
printf("请输入要进行语法分析的C语言程序：\n");
scanf("%s",filename);
infile = fopen(filename,"r");
while(!infile)
{
printf("打开文件失败！\n");
return;
}
ch = fgetc(infile);
while(ch!=EOF)
{

i = 0;
//以字母或者下划线开头,处理keyword或者标识符
if((ch>='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 <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <fstream>
#include <vector>
#include <conio.h>
#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<pair<const char *,int> > keyMap;
extern vector<pair<const char *,int> > operMap;
extern vector<pair<const char *,int> > limitMap;

extern NormalNode * normalHead;//首结点

fstream resultfile;

vector<pair<const char *,int> > nonTerMap;//非终结符映射表,不可反复的
vector<pair<const char *,int> > terMap;//终结符映射表,不可反复的
vector<pair<const char *,int> > 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<specialMap.size(); i++)
{
if(specialMap[i].second == num)
{
return specialMap[i].first;
}
}
//处理非终结符
for(int i=0; i<nonTerMap.size(); i++)
{
if(nonTerMap[i].second == num)
{
return nonTerMap[i].first;
}
}
//处理终结符
for(int i=0; i<terMap.size(); i++)
{
if(terMap[i].second == num)
{
return terMap[i].first;
}
}

}

//动态生成非终结符，在基点的基础上，确保不和终结符冲突
int dynamicNonTer(char *word)
{
int i = 0;
int dynamicNum;
for(i=0; i<nonTerMap.size(); i++)
{
if(strcmp(word,nonTerMap[i].first) == 0)
{
return nonTerMap[i].second;
}
}
if(i == nonTerMap.size())
{
if(i == 0)
{
dynamicNum = GRAMMAR_BASE;
nonTerMap.push_back(make_pair(word,dynamicNum));
}
else
{
dynamicNum = nonTerMap[nonTerMap.size()-1].second + 1;
nonTerMap.push_back(make_pair(word,dynamicNum));
}
}
return dynamicNum;
}
//推断某个标号是不是非终结符的标号,1代表是。0代表否
int inNonTer(int n)
{
for(int i=0; i<nonTerMap.size(); i++)
{
if(nonTerMap[i].second == n)
{
return 1;
}
}
return 0;
}
//推断某个标号是不是终结符的标号，1代表是。0代表否
int inTer(int n)
{
for(int i=0; i<terMap.size(); i++)
{
if(terMap[i].second == n)
{
return 1;
}
}
return 0;
}
//推断某个标号在不在此时的empty集中。1代表是。0代表否
int inEmpty(int n)
{
//当前Empty集的长度
int emptyLength = 0;
for(emptyLength = 0;; emptyLength++)
{
if(empty[emptyLength] == -1)
{
break;
}
}
for(int i = 0; i<emptyLength; i++)
{
if(empty[i] == n)
{
return 1;
}
}
return 0;

}
//推断某个标号在不在此时的emptyRecu集中。1代表是。0代表否
int inEmptyRecu(int n)
{
//当前Empty集的长度
int emptyLength = 0;
for(emptyLength = 0;; emptyLength++)
{
if(emptyRecu[emptyLength] == -1)
{
break;
}
}
for(int i = 0; i<emptyLength; i++)
{
if(emptyRecu[i] == n)
{
return 1;
}
}
return 0;
}
//推断某个标号在不在此时的followRecu集中，1代表是。0代表否
int inFollowRecu(int n)
{
int followLength = 0;
for(followLength = 0;; followLength++)
{
if(followRecu[followLength] == -1)
{
break;
}
}
for(int i = 0; i<followLength; i++)
{
if(followRecu[i] == n)
{
return 1;
}
}
return 0;
}

//推断某个标号是不是在产生式的右边
int inProcRight(int n,int * p)
{
//注意这里默认是从3開始
for(int i=3;; i++)
{
if(p[i] == -1)
{
break;
}
if(p[i] == n)
{
return 1;
}
}
return 0;
}

int seekCodeNum(char * word)
{
//处理文法中的特殊符号
for(int i = 0; i<specialMap.size(); i++)
{
if(strcmp(word,specialMap[i].first) == 0)
{
return specialMap[i].second;
}
}
//先搜索终结符映射表中有没有此终结符
for(int i=0; i<terMap.size(); i++)
{
if(strcmp(word,terMap[i].first) == 0)
{
return terMap[i].second;
}
}
for(int i = 0; i<keyMap.size(); i++)
{
if(strcmp(word,keyMap[i].first) == 0)
{
terMap.push_back(make_pair(word,keyMap[i].second));
return keyMap[i].second;
}
}

for(int i = 0; i<operMap.size(); i++)
{
if(strcmp(word,operMap[i].first) == 0)
{
terMap.push_back(make_pair(word,operMap[i].second));
return operMap[i].second;
}
}

for(int i = 0; i<limitMap.size(); i++)
{
if(strcmp(word,limitMap[i].first) == 0)
{
terMap.push_back(make_pair(word,limitMap[i].second));
return limitMap[i].second;
}
}

if(strcmp(word,"id")==0)
{
//处理标志符
terMap.push_back(make_pair(word,IDENTIFER));
return IDENTIFER;
}
else
{
//处理keyword、运算符、限界符表，即非终结符
return dynamicNonTer(word);
}
}
//切割" | "文法
void splitProc(int p[][Max_Length],int &line,int orNum)
{
if(p[line][1] == -1 || orNum == 0)
{
return;
}
int head = p[line][1];
int push = p[line][2];
int length = 0;
int right,left;
int lineTrue = line + orNum;
for(length = 3;;length++)
{
if(p[line][length] == -1)
{
break;
}
}
length--;
for(left = length,right = length;left>=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; i<line; i++)
{
for(int j=1; j<Max_Length; j++)
{
if(proc[i][j]!=-1)
{
printf("%s ",searchMapping(proc[i][j]));
}
else
{
break;
}
}
printf("\n");
}
printf("\n************************************文法终结符******************************\n\n");
for(int i=0; i<terMap.size(); i++)
{
printf("%s ",terMap[i].first);
}
printf("\n");
printf("\n************************************文法非终结符******************************\n\n");
for(int i=0; i<nonTerMap.size(); i++)
{
printf("%s ",nonTerMap[i].first);
}
printf("\n");
}
//将s集合合并至d集合中，type = 1代表包含空（$）,type = 2代表不包含空
void merge(int *d,int *s,int type)
{
int flag = 0;
for(int i = 0;; i++)
{
flag = 0;
if(s[i] == -1)
{
break;
}
int j = 0;
for(j = 0;; j++)
{
if(d[j] == -1)
{
break;
}
if(d[j] == s[i])
{
flag = 1;
break;
}
}
if(flag == 1)
{
continue;
}
if(type == 1)
{
d[j] = s[i];
}
else
{
if(s[i] != GRAMMAR_NULL)
{
d[j] = s[i];
}
}
d[j + 1] = -1;
}
}

void nullSet(int currentNum)
{
int temp[2];
for(int j = 1; j<=procNum; j++)
{
//假设右边的第一个是该字符。而且长度仅仅有1
if(proc[j][3] == currentNum && proc[j][4] == -1)
{
temp[0] = proc[j][1];
temp[1] = -1;
merge(empty,temp,1);
nullSet(proc[j][1]);
}
}
}
//推断该非终结符能否推出空。但终结符也可能传入，但没关系
int reduNull(int currentNon)
{
int temp[2];
int result = 1;
int mark = 0;
temp[0] = currentNon;
temp[1] = -1;
merge(emptyRecu,temp,1);//先将此符号并入防递归集合中
if(inEmpty(currentNon) == 1)
{
return 1;
}

for(int j = 1; j<=procNum; j++)
{
if(proc[j][1] == currentNon)
{
int rightLength = 0;
//先求出右部的长度
for(rightLength = 3;; rightLength++)
{
if(proc[j][rightLength] == -1)
{
break;
}
}
rightLength--;
//假设长度为1，而且已经求过
if(rightLength - 2 == 1 && inEmpty(proc[j][rightLength]))
{
return 1;
}
//假设长度为1，而且是终结符
else if(rightLength -2 == 1 && inTer(proc[j][rightLength]))
{
return 0;
}
//假设长度超过了2
else
{
for(int k=3; k<=rightLength; k++)
{
if(inEmptyRecu(proc[j][k]))
{
mark = 1;
}
}
if(mark == 1)
{
continue;
}
else
{
for(int k=3; k<=rightLength; k++)
{
result*= reduNull(proc[j][k]);
temp[0] = proc[j][k];
temp[1] = -1;
merge(emptyRecu,temp,1);//先将此符号并入防递归集合中
}
}
}
if(result == 0)
{
continue;
}
else if(result == 1)
{
return 1;
}
}
}
return 0;
}

//求first集。传入的參数是在非终结符集合中的序号
void firstSet(int i)
{
int k = 0;
int currentNon = nonTerMap[i].second;//当前的非终结符标号
//依次遍历所有产生式
for(int j = 1; j<=procNum; j++) //j代表第几个产生式
{
//找到该非终结符的产生式
if(currentNon == proc[j][1])//注意从1開始
{
//当右边的第一个是终结符或者空的时候
if(inTer(proc[j][3]) == 1 || proc[j][3] == GRAMMAR_NULL)
{
//并入当前非终结符的first集中
int temp[2];
temp[0] = proc[j][3];
temp[1] = -1;//事实上是模拟字符串操作的手段
merge(first[i],temp,1);
}
//当右边的第一个是非终结符的时候
else if(inNonTer(proc[j][3]) == 1)
{
//假设遇到左递归形式的，直接放过？
if(proc[j][3] == currentNon)
{
continue;
}
//记录下右边第一个非终结符的位置
for(k=0;; k++)
{
if(nonTerMap[k].second == proc[j][3])
{
break;
}

}
//当右边第一个非终结符还未訪问过的时候
if(firstVisit[k] == 0)
{
firstSet(k);
firstVisit[k] = 1;
}
merge(first[i],first[k],2);//假设first[k]此时有空值的话。临时不把空值并入first[i]中
int rightLength = 0;
//先求出右部的长度

for(rightLength = 3;; rightLength++)
{
if(proc[j][rightLength] == -1)
{
break;
}
}
//到眼下为止。仅仅求出了右边的第一个(还不包含空的部分)。For循环处理之后的
for(k = 3; k<rightLength; k++)
{
emptyRecu[0] = -1;//相当于初始化这个防递归集合

//假设右部的当前字符能推出空而且还不是最后一个字符，就将之后的一个字符并入First集中
if(reduNull(proc[j][k]) == 1 && k<rightLength -1)
{
int u = 0;
for(u=0;; u++)
{
//注意是记录下一个符号的位置
if(nonTerMap[u].second == proc[j][k+1])
{
break;
}
}
if(firstVisit[u] == 0)
{
firstSet(u);
firstVisit[u] = 1;
}
merge(first[i],first[u],2);
}
//到达最后一个字符，而且产生式右部都能推出空,将$并入First集中
else if(reduNull(proc[j][k]) == 1 && k == rightLength -1)
{
int temp[2];
temp[0] = GRAMMAR_NULL;
temp[1] = -1;//事实上是模拟字符串操作的手段
merge(first[i],temp,1);
}
else
{
break;
}
}
}
}
}
firstVisit[i] = 1;
}
void First()
{
//先求出能直接推出空的非终结符集合
nullSet(GRAMMAR_NULL);
printf("\n");
for(int i=0; i<nonTerMap.size(); i++)
{
firstSet(i);
}
printf("\n************************************First集******************************\n\n");
for(int i=0; i<nonTerMap.size(); i++)
{
printf("First[%s] = ",nonTerMap[i].first);
for(int j=0;; j++)
{
if(first[i][j] == -1)
{
break;
}
printf("%s ",searchMapping(first[i][j]));
}
printf("\n");
}
}
//将First结合起来的函数
void connectFirstSet(int *p)
{
int i = 0;
int flag = 0;
int temp[2];
//假设P的长度为1
if(p[1] == -1)
{
if(p[0] == GRAMMAR_NULL)
{
connectFirst[0] = GRAMMAR_NULL;
connectFirst[1] = -1;
}
else
{
for(i=0; i<nonTerMap.size(); i++)
{
if(nonTerMap[i].second == p[0])
{
flag = 1;
merge(connectFirst,first[i],1);
break;
}
}
//也可能是终结符
if(flag == 0)
{
for(i=0; i<terMap.size(); i++)
{
if(terMap[i].second == p[0])
{
temp[0] = terMap[i].second;
temp[1] = -1;
merge(connectFirst,temp,2);//终结符的First集就是其本身
break;
}
}
}
}
}
//假设p的长度大于1
else
{
for(i=0; i<nonTerMap.size(); i++)
{
if(nonTerMap[i].second == p[0])
{
flag = 1;
merge(connectFirst,first[i],2);
break;
}
}
//也可能是终结符
if(flag == 0)
{
for(i=0; i<terMap.size(); i++)
{
if(terMap[i].second == p[0])
{
temp[0] = terMap[i].second;
temp[1] = -1;
merge(connectFirst,temp,2);//终结符的First集就是其本身
break;
}
}
}
flag = 0;
int length = 0;
for(length = 0;; length++)
{
if(p[length] == -1)
{
break;
}
}
for(int k=0; k<length; k++)
{
emptyRecu[0] = -1;//相当于初始化这个防递归集合

//假设右部的当前字符能推出空而且还不是最后一个字符，就将之后的一个字符并入First集中
if(reduNull(p[k]) == 1 && k<length -1)
{
int u = 0;
for(u=0; u<nonTerMap.size(); u++)
{
//注意是记录下一个符号的位置
if(nonTerMap[u].second == p[k+1])
{
flag = 1;
merge(connectFirst,first[u],2);
break;
}
}
//也可能是终结符
if(flag == 0)
{
for(u=0; u<terMap.size(); u++)
{
//注意是记录下一个符号的位置
if(terMap[u].second == p[k+1])
{
temp[0] = terMap[i].second;
temp[1] = -1;
merge(connectFirst,temp,2);
break;
}
}
}
flag = 0;
}
//到达最后一个字符，而且产生式右部都能推出空,将$并入First集中
else if(reduNull(p[k]) == 1 && k == length -1)
{
temp[0] = GRAMMAR_NULL;
temp[1] = -1;//事实上是模拟字符串操作的手段
merge(connectFirst,temp,1);
}
else
{
break;
}
}
}
}
void followSet(int i)
{
int currentNon = nonTerMap[i].second;//当前的非终结符标号
int temp[2];
int result = 1;
temp[0] = currentNon;
temp[1] = -1;
merge(followRecu,temp,1);//将当前标号增加防递归集合中

//假设当前符号就是開始符号,把特殊符号增加其Follow集中
if(proc[1][1] == currentNon)
{
temp[0] = GRAMMAR_SPECIAL;//这个也是要处理的
temp[1] = -1;
merge(follow[i],temp,1);
}
for(int j = 1; j<=procNum; j++) //j代表第几个产生式
{
//假设该非终结符在某个产生式的右部存在
if(inProcRight(currentNon,proc[j]) == 1)
{
int rightLength = 1;
int k = 0;//k为该非终结符在产生式右部的序号
int flag = 0;
int leftNum = proc[j][1];//产生式的左边
int h = 0;
int kArray[Max_Length2];
memset(kArray,-1,sizeof(kArray));
for(h = 0; h < nonTerMap.size(); h++)
{
if(nonTerMap[h].second == leftNum)
{
break;
}
}

for(rightLength = 1;; rightLength++)
{
if(currentNon == proc[j][rightLength+2])
{
kArray[k++] = rightLength;
}
if(proc[j][rightLength+2] == -1)
{
break;
}
}
rightLength--;
for(int y=0;; y++)
{
if(kArray[y] == -1)
{
break;
}
//假设该非终结符在右部产生式的最后
if(kArray[y] == rightLength)
{

if(inFollowRecu(leftNum) == 1)
{
merge(follow[i],follow[h],1);
continue;
}
if(followVisit[h] == 0)
{
followSet(h);
followVisit[h] = 1;
}
merge(follow[i],follow[h],1);
}
//假设不在最后
else
{
int n = 0;
result = 1;//这是关键的，曾在这里失误过
for(n=kArray[y]+1; n<=rightLength; n++)
{
emptyRecu[0] = -1;
result *= reduNull(proc[j][n+2]);
}
if(result == 1)
{
if(inFollowRecu(leftNum) == 1)
{
merge(follow[i],follow[h],1);
continue;
}
if(followVisit[h] == 0)
{
followSet(h);
followVisit[h] = 1;
}
merge(follow[i],follow[h],1);
}
int temp2[Max_Length];
memset(temp2,-1,sizeof(temp2));
for(n=kArray[y]+1; n<=rightLength; n++)
{
temp2[n-kArray[y]-1] = proc[j][n+2];
}
temp2[rightLength-kArray[y]] = -1;
connectFirst[0] = -1;//应该又一次初始化一下
connectFirstSet(temp2);
merge(follow[i],connectFirst,2);
}
}
}
}
followVisit[i] = 1;
}

//求所有非终结符的Follow集
void Follow()
{
for(int i=0; i<nonTerMap.size(); i++)
{
followRecu[0] = -1;
followSet(i);
}
printf("\n************************************Follow集******************************\n\n");
for(int i=0; i<nonTerMap.size(); i++)
{
printf("Follow[%s] = ",nonTerMap[i].first);
for(int j=0;; j++)
{
if(follow[i][j] == -1)
{
break;
}
printf("%s ",searchMapping(follow[i][j]));
}
printf("\n");
}
}
//求已经分解的产生式相应的Select集,注意Select集中不能含有空($),因而Type=2
void Select()
{
for(int i = 1; i<=procNum; i++) //j代表第几个产生式
{
int leftNum = proc[i][1];//产生式的左边
int h = 0;
int result = 1;
for(h = 0; h < nonTerMap.size(); h++)
{
if(nonTerMap[h].second == leftNum)
{
break;
}
}

int rightLength = 1;
for(rightLength = 1;; rightLength++)
{
if(proc[i][rightLength+2] == -1)
{
break;
}
}
rightLength--;
//假设右部推出式的长度为1而且是空,select[i-1] = follow[左边]
if(rightLength == 1 && proc[i][rightLength + 2] == GRAMMAR_NULL)
{
merge(select[i-1],follow[h],2);
}
//假设右部不是空的时候,select[i-1] = first[右部所有]
//假设右部可以推出空，select[i-1] = first[右部所有] ^ follow[左边]
else
{
int temp2[Max_Length];
int n = 0;
memset(temp2,-1,sizeof(temp2));
for(n=1; n<=rightLength; n++)
{
temp2[n-1] = proc[i][n+2];
}
temp2[rightLength] = -1;
connectFirst[0] = -1;//应该又一次初始化一下
connectFirstSet(temp2);
merge(select[i-1],connectFirst,2);
for(n=1; n<=rightLength; n++)
{
emptyRecu[0] = -1;
result *= reduNull(proc[i][n+2]);
}
//假设右部能推出空，将follow[左边]并入select[i-1]中
if(result == 1)
{
merge(select[i-1],follow[h],2);
}
}
}
printf("\n************************************Select集******************************\n\n");
for(int i=0; i<procNum; i++)
{
printf("Select[%d] = ",i+1);
for(int j=0;; j++)
{
if(select[i][j] == -1)
{
break;
}
printf("%s ",searchMapping(select[i][j]));
}
printf("\n");
}
}
//输出预測分析表
void MTable()
{
fstream outfile;
outfile.open("preciateTable.txt",ios::out);

for(int i=0; i<procNum; i++)
{
int m = 0;//非终结符的序号
for(int t=0; t<nonTerMap.size(); t++)
{
if(nonTerMap[t].second == proc[i+1][1])
{
m = t;
break;
}
}

for(int j=0;; j++)
{
if(select[i][j] == -1)
{
break;
}
for(int k=0; k<terMap.size(); k++)
{
if(terMap[k].second == select[i][j])
{
int n = 0;
for(n=1; n<=Max_Length2; n++)
{
M[m][k][n-1] = proc[i+1]
;
if(proc[i+1]
== -1)
{
break;
}
}
break;
}
}
}
}
//printf("\n*********************************预測分析表******************************\n\n");
outfile<<endl<<"*********************************预測分析表******************************"<<endl;
for(int i=0; i<nonTerMap.size(); i++)
{
for(int j=0; j<terMap.size(); j++)
{
outfile<<"M["<<nonTerMap[i].first<<"]["<<terMap[j].first<<"] = ";
//printf("M[%s][%s] = ",nonTerMap[i].first,terMap[j].first);
for(int k=0;; k++)
{
if(M[i][j][k] == -1)
{
break;
}
outfile<<searchMapping(M[i][j][k]);
//printf("%s ",searchMapping(M[i][j][k]));
}
outfile<<endl;
//printf("\n");
}
outfile<<endl<<endl;
//printf("\n\n");
}
outfile.close();
}

void InitStack(SeqStack *S)    /*初始化顺序栈*/
{
S->top = -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<<searchMapping(S->elem[i])<<" ";
}
}
void ShowStack2(SeqStack *S)   /*显示栈的字符，先输出栈顶元素*/
{

int i;
for(i=S->top; i>=0; i--)
{
//printf("%s ",searchMapping(S->elem[i]));
resultfile<<searchMapping(S->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<<"第"<<i + 1<<"步"<<endl;
//printf("符号栈:");
resultfile<<"符号栈:";
ShowStack1(&s1);
//printf("\n");
resultfile<<endl;
//printf("输入栈:");
resultfile<<"输入栈:";
ShowStack2(&s2);
//printf("\n");
resultfile<<endl;

GetTop(&s1,&c1);   /*取栈顶元素，记为c1。c2*/
GetTop(&s2,&c2);
if(c1 == GRAMMAR_SPECIAL && c2 == GRAMMAR_SPECIAL)  /*当符号栈和输入栈都剩余#时。分析成功*/
{
//printf("成功!\n");
resultfile<<"成功!"<<endl;
break;
}
if(c1 == GRAMMAR_SPECIAL && c2!= GRAMMAR_SPECIAL)  /*当符号栈剩余#，而输入串未结束时。分析失败 */
{
//printf("失败!\n");
resultfile<<"失败!"<<endl;
break;
}
if(c1 == c2)/*符号栈的栈顶元素和输入串的栈顶元素同样时。同一时候弹出*/
{
Pop(&s1);
Pop(&s2);
flag = 1;
}

else /*查预測分析表*/
{
//记录下非终结符的位置
for(h1=0; h1<nonTerMap.size(); h1++)
{
if(nonTerMap[h1].second == c1)
{
break;
}
}
//记录下终结符的位置
for(h2=0; h2<terMap.size(); h2++)
{
if(terMap[h2].second == c2)
{
break;
}
}
if(M[h1][h2][0] == -1)
{
//printf("Error\n");
resultfile<<"Error"<<endl;
break;//假设错误的话，直接终止分析
}
else
{
int length = 0;
//记录下推导式的长度
for(length = 0;; length++)
{
if(M[h1][h2][length] == -1)
{
break;
}
}
Pop(&s1);
//假设不是空的话，反向入栈
if(M[h1][h2][2] != GRAMMAR_NULL)
{
for(int k = length-1; k>=2; k--)
{
Push(&s1,M[h1][h2][k]);
}
}
}
}
if(flag == 1)
{
//printf("匹配。\n");
resultfile<<"匹配!"<<endl;
}
else
{
resultfile<<"所用推出式：";
//printf("所用推出式：");
int w = 0;
//记录下推导式的长度
for(w = 0;; w++)
{
if(M[h1][h2][w] == -1)
{
break;
}
//printf("%s ",searchMapping(M[h1][h2][w]));
resultfile<<searchMapping(M[h1][h2][w]);
}
//printf("\n\n");
resultfile<<endl<<endl;
}
}
resultfile.close();
}

主文件：

main.cpp

//main.cpp
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iomanip>
#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
<表达式> -> <因子> <项>
<因子> -> <因式> <因式递归>
<因式递归> -> * <因式> <因式递归>
<因式递归> -> / <因式> <因式递归>
<因式递归> -> $
<项> -> + <因子> <项>
<项> -> - <因子> <项>
<项> -> $
<參数声明> -> <声明> <声明闭包>
<參数声明> -> $
<声明> -> <修饰词闭包> <类型> <变量> <赋初值>
<赋初值> -> = <右值>
<赋初值> -> $
<右值> -> <表达式>
<右值> -> { <多个数据> }
<多个数据> -> <数字> <数字闭包>
<数字闭包> -> , <数字> <数字闭包>
<数字闭包> -> $
<声明闭包> -> , <声明> <声明闭包>
<声明闭包> -> $
<函数块> -> <声明语句闭包> <函数块闭包>
<声明语句闭包> -> <声明语句> <声明语句闭包>
<声明语句闭包> -> $
<声明语句> -> <声明> ;
<函数块闭包> -> <赋值函数> <函数块闭包>
<函数块闭包> -> <for循环> <函数块闭包>
<函数块闭包> -> <条件语句> <函数块闭包>
<函数块闭包> -> <函数返回> <函数块闭包>
<函数块闭包> -> $
<赋值函数> -> <变量> <赋值或函数调用>
<赋值或函数调用> -> = <右值> ;
<赋值或函数调用> -> ( <參数列表> ) ;
<參数列表> -> <參数> <參数闭包>
<參数闭包> -> , <參数> <參数闭包>
<參数闭包> -> $
<參数> -> <标志符>
<參数> -> <数字>
<參数> -> <字符串>
<字符串> -> string
<for循环> -> for ( <赋值函数> <逻辑表达式> ; <后缀表达式> ) { <函数块> }
<逻辑表达式> -> <表达式> <逻辑运算符> <表达式>
<逻辑运算符> -> <
<逻辑运算符> -> >
<逻辑运算符> -> ==
<逻辑运算符> -> !=
<后缀表达式> -> <变量> <后缀运算符>
<后缀运算符> -> ++
<后缀运算符> -> --
<条件语句> -> if ( <逻辑表达式> ) { <函数块> } <否则语句>
<否则语句> -> else { <函数块> }
<否则语句> -> $
<函数返回> -> return <因式> ;

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

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

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

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

************************************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循环>] = 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[<for循环>] = } 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] = <函数块闭包>-><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[<for循环>][(] =
M[<for循环>][)] =
M[<for循环>][{] =
M[<for循环>][}] =
M[<for循环>][describe] =
M[<for循环>][type] =
M[<for循环>][*] =
M[<for循环>][id] =
M[<for循环>][[] =
M[<for循环>][]] =
M[<for循环>][digit] =
M[<for循环>][/] =
M[<for循环>][+] =
M[<for循环>][-] =
M[<for循环>][=] =
M[<for循环>][,] =
M[<for循环>][;] =
M[<for循环>][string] =
M[<for循环>][for] = <for循环>->for(<赋值函数><逻辑表达式>;<后缀表达式>){<函数块>}
M[<for循环>][<] =
M[<for循环>][>] =
M[<for循环>][==] =
M[<for循环>][!=] =
M[<for循环>][++] =
M[<for循环>][--] =
M[<for循环>][if] =
M[<for循环>][else] =
M[<for循环>][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 ; } #
所用推出式：<函数块闭包>-><for循环><函数块闭包>

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

第218步
符号栈:<for循环> <函数块闭包> } <函数块闭包> } #
输入栈:for ( id = id + digit ; id < digit ; id -- ) { if ( id == digit ) { id [ id ] = id ; } } } id ( string ) ; return digit ; } #
所用推出式：<for循环>->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步骤
符号栈:#
进入堆栈:#
成功!