基于Appel-Tiger编译器前端的简易语法分析器

本是古典何须时尚 2022-08-18 15:16 181阅读 0赞

**说明：**

本例修改自Appel的Tiger编译器前端。  
本例给出某文法的一个简单的语法分析器。它是在parser0的基础上添加语义动作而得到的。  
输入：用该文法所表示的语言写的源程序文件。  
输出：分析树的数据结构描述，可以显示在屏幕上，也可以写入指定的文件中。  
该语言的文法为：（与parser0文法相同）

program--> PROGRAM ID; vardec BEGIN stmts END. 
    vardec-->   VAR declist 
    declist-->  ID:INTEGER;
    stmts--> ID := exp
    exp--> INT

该语法分析器的测试例（输入文件）为：testcases/test0.p  
该语法分析器的词法分析器由lex编写，本例并未给出lex规则源程序，只给出了flex编译后的c语言程序lex.yy.c。本词法分析器支持以(\*开始，以\*)结束的注释（不支持注释的嵌套）。  
parsetest.c为该语法分析器主控程序，包含main函数。  
util.c含有一般工具函数，util.h是其头文件。  
errormsg.c含有错误管理函数，errormsg.h是其头文件。  
parser.y是语法分析器的文法说明文件。 在该文法说明文件中，我们为产生式添加了语义动 作，语义动作为产生语法分析树。

ast.h文件给出了语法分析器所应生成的语法分析树（抽象语法树）的各部分的数据结构；而ast.c则为这些数据结构提供了构造函数（注意：ast.c提供的构造函数并不完整，需要你进行完善）  
 prast.c文件含有语法分析树各个数据结构的打印函数。prast.h是其头文件。  
testcases文件夹下的文件为语法分析器的测试例，test0.p为当前语法分析器可通过的测试例，  
test1.p为P178页上机题所示文法的一个测试例。你写的其他测试例也应该放在该文件夹下。  
makefile文件表示了本例的编译方法：  
在cygwin下，输入make，将会得到一些中间object文件以及可执行文件parser1.exe；  
输入 make clean，会将编译及运行中生成的文件删除（只留下原有文件）；  
编译完成后，输入make test00，将会以testcases/test0.p为输入源程序运行生成的语法分析器parser0.exe，输出的分析树将显示在屏幕上。  
编译完成后，输入make test01，将会以testcases/test0.p为输入源程序运行生成的语法分析器parser0.exe，输出的分析树将写入指定文件test0.out中。

用到的文件截图：

![Center][]

# 源代码： #

（1） ast.c

/* 本文件给出抽象语法树上各数据结构的构造函数，实验8需要修改该文件的一些函数 */
    
    #include "ast.h"
    
    
    
    
    /* make id node */
    a_id A_Id(a_pos pos, string val){
      a_id ret = checked_malloc(sizeof(*ret));
      ret->pos = pos;
      ret->val = val;
      return ret;
    }
    
    
    /* make exp node from integer */
    a_exp A_IntExp(a_pos pos, int ival){
      a_exp ret = checked_malloc(sizeof(*ret));
      ret->kind = A_intExp;
      ret->pos = pos;
      ret->exp.ival = ival;
      return ret;
    }
    
    /* make exp node from real */
    a_exp A_RealExp(a_pos pos, double fval){
      a_exp ret = checked_malloc(sizeof(*ret));
      //请完善该函数
      ret->kind = A_realExp;
      ret->pos = pos;
      ret->exp.fval = fval;
      return ret;
    }
    
    /* make exp node from id node */
    a_exp A_VarExp(a_pos pos, a_id var){
      a_exp ret = checked_malloc(sizeof(*ret));
      //请完善该函数
      ret->kind = A_varExp;
      ret->pos = pos;
      ret->exp.var = var;
      return ret;
    }
    
     /* make binary operands exp node */
    a_exp A_OpExp(a_pos pos, a_op op, a_exp left, a_exp right){
      a_exp ret = checked_malloc(sizeof(*ret));
      //请完善该函数
      ret->kind = A_opExp;
      ret->pos = pos;
      ret->exp.biopExp.op=op;
      ret->exp.biopExp.left=left;
      //ret->exp.biopExp.right=right;
      ret->exp.biopExp.right=right;
      
      return ret;
    }
    
    /* make boolean exp node */
    a_bexp A_BExp(a_pos pos, a_bop bop, a_exp left, a_exp right){
      a_bexp ret = checked_malloc(sizeof(*ret));
      //请完善该函数
      ret->pos = pos;
      ret->bexp.bop = bop;
      ret->bexp.left = left;
      ret->bexp.right = right;
      return ret;
    }
    
    /* make assign statement */
    a_stm A_Assign (a_pos pos, a_id var, a_exp exp){
      a_stm ret = checked_malloc(sizeof(*ret));
      ret->kind = A_assign;
      ret->pos = pos;
      ret->stm.assign.var = var;
      ret->stm.assign.exp = exp;
      return ret;
    }
    
    /* make if statement */
    a_stm A_If(a_pos pos, a_bexp b, a_stm s1, a_stm s2){
      a_stm ret = checked_malloc(sizeof(*ret));
      //请完善该函数
      ret->kind = A_if;
      ret->pos = pos;
      ret->stm.iff.b=b;
      ret->stm.iff.s1=s1;
      ret->stm.iff.s2=s2;
      return ret;
    }
    
    /* make while statement */
    a_stm A_While(a_pos pos, a_bexp b, a_stm s){
      a_stm ret = checked_malloc(sizeof(*ret));
      //请完善该函数
      ret->kind = A_while;
      ret->pos = pos;
      ret->stm.whilee.b=b;
      ret->stm.whilee.s=s;
      return ret;
    }
    
    /* make sequence statement */
    a_stm A_Seq(a_pos pos, a_stm_list sl){
      a_stm ret = checked_malloc(sizeof(*ret));
      //请完善该函数
      ret->kind = A_seq;
      ret->pos = pos;
      ret->stm.seq=sl;
      return ret; 
    }
    
    /* make statement list */
    a_stm_list A_StmList(a_stm s, a_stm_list sl){
      a_stm_list ret = checked_malloc(sizeof(*ret));
      ret->head = s;
      ret->tail = sl;
      return ret;
    }
    
    /* make var list */
    a_var_list A_VarList(a_id v, a_var_list vl){
      a_var_list ret = checked_malloc(sizeof(*ret));
      ret->head = v;
      ret->tail = vl;
      return ret;
    }
    
    /* make variable declaration node */
    a_dec A_VarDec(a_pos pos, a_var_list vl, ttype t){
      a_dec ret = checked_malloc(sizeof(*ret));
      ret->type = t;
      ret->pos = pos;
      ret->varlist = vl;
      return ret;
    }
    
    /* make variable declaration list */
    a_dec_list A_DecList(a_dec vd, a_dec_list vdl){
      a_dec_list ret = checked_malloc(sizeof(*ret));
      ret->head = vd;
      ret->tail = vdl;
      return ret;
    }
    
    /* make program node */
    a_prog A_Prog (a_pos pos, char * name, a_dec_list dl, a_stm_list sl){
      a_prog ret = checked_malloc(sizeof(*ret));
      ret->name = name;
      ret->pos =pos;
      ret->declist = dl;
      ret->stmlist = sl;
      return ret;
    }

（2） ast.h

/* 定义抽象语法树（分析树）的数据结构 */
    
    #include "util.h"
    
    typedef int a_pos; //a_pos为源文件某记号的位置类型，报错用。
    
    typedef struct a_exp_ * a_exp;
    typedef struct a_bexp_ * a_bexp;
    typedef struct a_id_ * a_id;
    typedef struct a_stm_ * a_stm;
    typedef struct a_stm_list_ * a_stm_list;
    typedef struct a_dec_ * a_dec;
    typedef struct a_dec_list_ * a_dec_list;
    typedef struct a_var_list_ * a_var_list;
    typedef struct a_prog_ * a_prog;
    
    /* 变量类型有整型T_int和实型T_real两种 */
    typedef enum{T_int, T_real} ttype;
    
    /* 二元算术运算有四种：+ - * / */
    typedef enum {A_plusOp, A_minusOp, A_timesOp, A_divideOp} a_op;
    
    /* 二元布尔运算六种：=, <>, <, <=, >, >= */
    typedef enum {A_eqOp, A_neqOp, A_ltOp, A_leOp, A_gtOp, A_geOp} a_bop;
    
    
    /* id的数据结构，pos为位置，val为id的名字 */
    struct a_id_ {
      a_pos pos;
      string val;
    };
    
    /* 算术表达式数据结构。
     * kind为表达式的类型，分为变量、整型数、实型数和二元表达式
     */
    struct a_exp_ {
      enum {A_varExp, A_intExp, A_realExp, A_opExp} kind;
      a_pos pos;
      union {
        struct {
          a_op op;
          a_exp left;
          a_exp right;
        }biopExp; //二元运算表达式：left op right
        a_id var; //变量表达式
        int ival; //整型数表达式
        double fval;//实型数表达式
      }exp;
    };
    
    /* 布尔表达式数据结构 */
    struct a_bexp_{
    	a_pos pos;
    	struct {
        a_bop bop;
        a_exp left;
        a_exp right;
      } bexp;
    };
    
    /* 语句数据结构。
     * 类型分为赋值语句、if语句、while语句、顺序语句（语句序列） 
     */
    struct a_stm_ {
      enum {A_assign, A_if, A_while, A_seq} kind;
      a_pos pos;
      union {
        struct a_assign_stm_ {
          a_id var;
          a_exp exp;
        } assign;//赋值语句：var = exp;
        struct a_if_stm_ {
          a_bexp b;
          a_stm s1;
          a_stm s2;
        } iff;// if语句：if b then s1 else s2;
        struct a_while_stm_ {
          a_bexp b;
          a_stm s;
        } whilee;// while语句：while b do s;
        a_stm_list seq;//顺序语句：是若干顺序的语句的一个列表。
      } stm;
    };
    
    /* 语句列表数据结构 */
    struct a_stm_list_ {
      a_stm head;
      a_stm_list tail;
    };
    
    /* 变量列表数据结构 */
    struct a_var_list_ {
      a_id head;
      a_var_list tail;
    };
    
    /* 变量声明数据结构 。
     * 变量类型为type，变量列表为varlist。
     * 例：声明var a, b, c : INTEGER;
     *     其中a,b,c组成varlist，type为T_int（表示INTEGER）。
     */
    struct a_dec_ {
      ttype type;
      a_pos pos;
      a_var_list varlist;
    };
    
    /* 变量声明列表数据结构 */
    struct a_dec_list_ {
      a_dec head;
      a_dec_list tail;
    };
    
    /* 程序数据结构。
     * name为程序名，declist为程序变量声明列表 */
    struct a_prog_ {
      char * name;
      a_pos pos;
      a_dec_list declist;
      a_stm_list stmlist;
    };
    
    /* 下面的函数是各个语法结构的构造函数 */
    a_id A_Id(a_pos pos, string val);
    a_exp A_IntExp(a_pos pos, int ival);
    a_exp A_RealExp(a_pos pos, double fval);
    a_exp A_VarExp(a_pos pos, a_id var);
    a_exp A_OpExp(a_pos pos, a_op op, a_exp left, a_exp right);
    a_bexp A_BExp(a_pos pos, a_bop bop, a_exp left, a_exp right);
    a_stm A_Assign (a_pos pos, a_id var, a_exp exp);
    a_stm A_If(a_pos pos, a_bexp b, a_stm s1, a_stm s2);
    a_stm A_While(a_pos pos, a_bexp b, a_stm s);
    a_stm A_Seq(a_pos pos, a_stm_list sl);
    a_stm_list A_StmList(a_stm s, a_stm_list sl);
    a_var_list A_VarList(a_id v, a_var_list vl);
    a_dec A_VarDec(a_pos pos, a_var_list vl, ttype t);
    a_dec_list A_DecList(a_dec vd, a_dec_list vdl);
    a_prog A_Prog (a_pos pos, char * name, a_dec_list dl, a_stm_list sl);

（3）errormsg.c

/*
     * errormsg.c - functions used in all phases of the compiler to give
     *              error messages about the program.
     *
     */
    
    /* 本文件定义各种错误管理操作 */
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <stdarg.h>
    #include "util.h"
    #include "errormsg.h"
    
    extern void resetLexState();
    
    bool anyErrors= FALSE;
    
    static string fileName = "";
    
    static int lineNum = 1;//行号，用于报错
    
    int EM_tokPos=0;
    
    extern FILE *yyin;
    extern FILE *yyout;
    
    extern int yydebug;//bison中用于查错的标记，yydebug非0时，输出错误信息。
    
    
    
    typedef struct intList {int i; struct intList *rest;} *IntList;
    
    static IntList intList(int i, IntList rest) 
    {IntList l= checked_malloc(sizeof *l);
     l->i=i; l->rest=rest;
     return l;
    }
    
    static IntList linePos=NULL; //行内位置，用于报错。
    
    /* 换行时，处理行号和行内位置的函数。 */
    void EM_newline(void)
    {lineNum++;
     linePos = intList(EM_tokPos, linePos);
    }
    
    /* 报错函数，message是错误信息格式串，pos是错误位置。 */
    void EM_error(int pos, char *message,...)
    {va_list ap;//可变参数列表指针
     IntList lines = linePos; 
     int num=lineNum;
     
    
      anyErrors=TRUE;
      while (lines && lines->i >= pos) 
           {lines=lines->rest; num--;}
    
      if (fileName) fprintf(stderr,"%s:",fileName);
      if (lines) fprintf(stderr,"%d.%d: ", num, pos-lines->i);
      va_start(ap,message);//ap指向message这个参数的地址
      //格式打印到文件stderr中，格式串为message，所需的参数由ap指针指向
      vfprintf(stderr, message, ap);
      va_end(ap);//ap指针归零
      fprintf(stderr,"\n");
    
    }
    
    
    /* 重置关于错误管理的一些设置。 */
    void EM_reset(string fname, string output)
    {
     anyErrors=FALSE; fileName=fname; lineNum=1;
     linePos=intList(0,NULL);
     yyin = fopen(fname,"r");
     if (output){
     	yyout = fopen(output, "w");
     }
     yyrestart(yyin);//用于重置缓冲区的内容
     /* 在flex中，函数 void yyrestart(FILE * newfile) 会将yyin的指针指向newfile的开始处，并且，
      * 原lex输入缓冲区中的内容全部抹掉。这可以用来重启yylex()。（因为当文件读取一半时，重新
      * 调用yylex仍会接着原文件的位置分析，即使重新制定yyin，缓冲区内的内容也还是原来的内容）
      * 该函数不会重置lex的状态为INITIAL。
      */
     resetLexState(); //重置lex状态为INTIAL。
     if (!yyin) {EM_error(0,"cannot open"); exit(1);}
    }
    
    /* 此函数用于设定语法分析查错 */
    void EM_yydebug(){
    	yydebug = 1;
    }

（4）errormsg.h

extern bool EM_anyErrors;
    
    void EM_newline(void);
    
    extern int EM_tokPos;
    
    void EM_error(int, string,...);
    
    void EM_reset(string filename, string output);
    
    void EM_yydebug();

（5）lex.yy.c

#line 3 "lex.yy.c"
    
    #define  YY_INT_ALIGNED short int
    
    /* A lexical scanner generated by flex */
    
    #define FLEX_SCANNER
    #define YY_FLEX_MAJOR_VERSION 2
    #define YY_FLEX_MINOR_VERSION 5
    #define YY_FLEX_SUBMINOR_VERSION 35
    #if YY_FLEX_SUBMINOR_VERSION > 0
    #define FLEX_BETA
    #endif
    
    /* First, we deal with  platform-specific or compiler-specific issues. */
    
    /* begin standard C headers. */
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    #include <stdlib.h>
    
    /* end standard C headers. */
    
    /* flex integer type definitions */
    
    #ifndef FLEXINT_H
    #define FLEXINT_H
    
    /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
    
    #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    
    /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
     * if you want the limit (max/min) macros for int types. 
     */
    #ifndef __STDC_LIMIT_MACROS
    #define __STDC_LIMIT_MACROS 1
    #endif
    
    #include <inttypes.h>
    typedef int8_t flex_int8_t;
    typedef uint8_t flex_uint8_t;
    typedef int16_t flex_int16_t;
    typedef uint16_t flex_uint16_t;
    typedef int32_t flex_int32_t;
    typedef uint32_t flex_uint32_t;
    #else
    typedef signed char flex_int8_t;
    typedef short int flex_int16_t;
    typedef int flex_int32_t;
    typedef unsigned char flex_uint8_t; 
    typedef unsigned short int flex_uint16_t;
    typedef unsigned int flex_uint32_t;
    #endif /* ! C99 */
    
    /* Limits of integral types. */
    #ifndef INT8_MIN
    #define INT8_MIN               (-128)
    #endif
    #ifndef INT16_MIN
    #define INT16_MIN              (-32767-1)
    #endif
    #ifndef INT32_MIN
    #define INT32_MIN              (-2147483647-1)
    #endif
    #ifndef INT8_MAX
    #define INT8_MAX               (127)
    #endif
    #ifndef INT16_MAX
    #define INT16_MAX              (32767)
    #endif
    #ifndef INT32_MAX
    #define INT32_MAX              (2147483647)
    #endif
    #ifndef UINT8_MAX
    #define UINT8_MAX              (255U)
    #endif
    #ifndef UINT16_MAX
    #define UINT16_MAX             (65535U)
    #endif
    #ifndef UINT32_MAX
    #define UINT32_MAX             (4294967295U)
    #endif
    
    #endif /* ! FLEXINT_H */
    
    #ifdef __cplusplus
    
    /* The "const" storage-class-modifier is valid. */
    #define YY_USE_CONST
    
    #else	/* ! __cplusplus */
    
    /* C99 requires __STDC__ to be defined as 1. */
    #if defined (__STDC__)
    
    #define YY_USE_CONST
    
    #endif	/* defined (__STDC__) */
    #endif	/* ! __cplusplus */
    
    #ifdef YY_USE_CONST
    #define yyconst const
    #else
    #define yyconst
    #endif
    
    /* Returned upon end-of-file. */
    #define YY_NULL 0
    
    /* Promotes a possibly negative, possibly signed char to an unsigned
     * integer for use as an array index.  If the signed char is negative,
     * we want to instead treat it as an 8-bit unsigned char, hence the
     * double cast.
     */
    #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
    
    /* Enter a start condition.  This macro really ought to take a parameter,
     * but we do it the disgusting crufty way forced on us by the ()-less
     * definition of BEGIN.
     */
    #define BEGIN (yy_start) = 1 + 2 *
    
    /* Translate the current start state into a value that can be later handed
     * to BEGIN to return to the state.  The YYSTATE alias is for lex
     * compatibility.
     */
    #define YY_START (((yy_start) - 1) / 2)
    #define YYSTATE YY_START
    
    /* Action number for EOF rule of a given start state. */
    #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
    
    /* Special action meaning "start processing a new file". */
    #define YY_NEW_FILE yyrestart(yyin  )
    
    #define YY_END_OF_BUFFER_CHAR 0
    
    /* Size of default input buffer. */
    #ifndef YY_BUF_SIZE
    #define YY_BUF_SIZE 16384
    #endif
    
    /* The state buf must be large enough to hold one state per character in the main buffer.
     */
    #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
    
    #ifndef YY_TYPEDEF_YY_BUFFER_STATE
    #define YY_TYPEDEF_YY_BUFFER_STATE
    typedef struct yy_buffer_state *YY_BUFFER_STATE;
    #endif
    
    extern int yyleng;
    
    extern FILE *yyin, *yyout;
    
    #define EOB_ACT_CONTINUE_SCAN 0
    #define EOB_ACT_END_OF_FILE 1
    #define EOB_ACT_LAST_MATCH 2
    
        #define YY_LESS_LINENO(n)
        
    /* Return all but the first "n" matched characters back to the input stream. */
    #define yyless(n) \
    	do \
    		{ \
    		/* Undo effects of setting up yytext. */ \
            int yyless_macro_arg = (n); \
            YY_LESS_LINENO(yyless_macro_arg);\
    		*yy_cp = (yy_hold_char); \
    		YY_RESTORE_YY_MORE_OFFSET \
    		(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
    		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
    		} \
    	while ( 0 )
    
    #define unput(c) yyunput( c, (yytext_ptr)  )
    
    #ifndef YY_TYPEDEF_YY_SIZE_T
    #define YY_TYPEDEF_YY_SIZE_T
    typedef size_t yy_size_t;
    #endif
    
    #ifndef YY_STRUCT_YY_BUFFER_STATE
    #define YY_STRUCT_YY_BUFFER_STATE
    struct yy_buffer_state
    	{
    	FILE *yy_input_file;
    
    	char *yy_ch_buf;		/* input buffer */
    	char *yy_buf_pos;		/* current position in input buffer */
    
    	/* Size of input buffer in bytes, not including room for EOB
    	 * characters.
    	 */
    	yy_size_t yy_buf_size;
    
    	/* Number of characters read into yy_ch_buf, not including EOB
    	 * characters.
    	 */
    	int yy_n_chars;
    
    	/* Whether we "own" the buffer - i.e., we know we created it,
    	 * and can realloc() it to grow it, and should free() it to
    	 * delete it.
    	 */
    	int yy_is_our_buffer;
    
    	/* Whether this is an "interactive" input source; if so, and
    	 * if we're using stdio for input, then we want to use getc()
    	 * instead of fread(), to make sure we stop fetching input after
    	 * each newline.
    	 */
    	int yy_is_interactive;
    
    	/* Whether we're considered to be at the beginning of a line.
    	 * If so, '^' rules will be active on the next match, otherwise
    	 * not.
    	 */
    	int yy_at_bol;
    
        int yy_bs_lineno; /**< The line count. */
        int yy_bs_column; /**< The column count. */
        
    	/* Whether to try to fill the input buffer when we reach the
    	 * end of it.
    	 */
    	int yy_fill_buffer;
    
    	int yy_buffer_status;
    
    #define YY_BUFFER_NEW 0
    #define YY_BUFFER_NORMAL 1
    	/* When an EOF's been seen but there's still some text to process
    	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
    	 * shouldn't try reading from the input source any more.  We might
    	 * still have a bunch of tokens to match, though, because of
    	 * possible backing-up.
    	 *
    	 * When we actually see the EOF, we change the status to "new"
    	 * (via yyrestart()), so that the user can continue scanning by
    	 * just pointing yyin at a new input file.
    	 */
    #define YY_BUFFER_EOF_PENDING 2
    
    	};
    #endif /* !YY_STRUCT_YY_BUFFER_STATE */
    
    /* Stack of input buffers. */
    static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
    static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
    static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
    
    /* We provide macros for accessing buffer states in case in the
     * future we want to put the buffer states in a more general
     * "scanner state".
     *
     * Returns the top of the stack, or NULL.
     */
    #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
                              ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                              : NULL)
    
    /* Same as previous macro, but useful when we know that the buffer stack is not
     * NULL or when we need an lvalue. For internal use only.
     */
    #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
    
    /* yy_hold_char holds the character lost when yytext is formed. */
    static char yy_hold_char;
    static int yy_n_chars;		/* number of characters read into yy_ch_buf */
    int yyleng;
    
    /* Points to current character in buffer. */
    static char *yy_c_buf_p = (char *) 0;
    static int yy_init = 0;		/* whether we need to initialize */
    static int yy_start = 0;	/* start state number */
    
    /* Flag which is used to allow yywrap()'s to do buffer switches
     * instead of setting up a fresh yyin.  A bit of a hack ...
     */
    static int yy_did_buffer_switch_on_eof;
    
    void yyrestart (FILE *input_file  );
    void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
    YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
    void yy_delete_buffer (YY_BUFFER_STATE b  );
    void yy_flush_buffer (YY_BUFFER_STATE b  );
    void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
    void yypop_buffer_state (void );
    
    static void yyensure_buffer_stack (void );
    static void yy_load_buffer_state (void );
    static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
    
    #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
    
    YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
    YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
    YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
    
    void *yyalloc (yy_size_t  );
    void *yyrealloc (void *,yy_size_t  );
    void yyfree (void *  );
    
    #define yy_new_buffer yy_create_buffer
    
    #define yy_set_interactive(is_interactive) \
    	{ \
    	if ( ! YY_CURRENT_BUFFER ){ \
            yyensure_buffer_stack (); \
    		YY_CURRENT_BUFFER_LVALUE =    \
                yy_create_buffer(yyin,YY_BUF_SIZE ); \
    	} \
    	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
    	}
    
    #define yy_set_bol(at_bol) \
    	{ \
    	if ( ! YY_CURRENT_BUFFER ){\
            yyensure_buffer_stack (); \
    		YY_CURRENT_BUFFER_LVALUE =    \
                yy_create_buffer(yyin,YY_BUF_SIZE ); \
    	} \
    	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
    	}
    
    #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
    
    /* Begin user sect3 */
    
    typedef unsigned char YY_CHAR;
    
    FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
    
    typedef int yy_state_type;
    
    extern int yylineno;
    
    int yylineno = 1;
    
    extern char *yytext;
    #define yytext_ptr yytext
    
    static yy_state_type yy_get_previous_state (void );
    static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
    static int yy_get_next_buffer (void );
    static void yy_fatal_error (yyconst char msg[]  );
    
    /* Done after the current pattern has been matched and before the
     * corresponding action - sets up yytext.
     */
    #define YY_DO_BEFORE_ACTION \
    	(yytext_ptr) = yy_bp; \
    	yyleng = (size_t) (yy_cp - yy_bp); \
    	(yy_hold_char) = *yy_cp; \
    	*yy_cp = '\0'; \
    	(yy_c_buf_p) = yy_cp;
    
    #define YY_NUM_RULES 39
    #define YY_END_OF_BUFFER 40
    /* This struct is not used in this scanner,
       but its presence is necessary. */
    struct yy_trans_info
    	{
    	flex_int32_t yy_verify;
    	flex_int32_t yy_nxt;
    	};
    static yyconst flex_int16_t yy_accept[84] =
        {   0,
            0,    0,    0,    0,   40,   38,    5,    6,   10,   11,
           15,   13,    7,   14,   12,   16,   36,    8,    9,   19,
           17,   21,   35,   35,   35,   35,   35,   35,   35,   35,
           35,   35,    4,    3,    4,    5,    1,   37,    0,   36,
           23,   20,   18,   22,   35,   35,   35,   31,   35,   35,
           25,   35,   35,   35,   35,   35,   35,    2,   35,   35,
           30,   35,   35,   35,   35,   34,   35,   35,   27,   35,
           35,   32,   26,   35,   29,   35,   35,   28,   35,   35,
           33,   24,    0
        } ;
    
    static yyconst flex_int32_t yy_ec[256] =
        {   0,
            1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    2,    1,    1,    1,    1,    1,    1,    1,    4,
            5,    6,    7,    8,    9,   10,   11,   12,   12,   12,
           12,   12,   12,   12,   12,   12,   12,   13,   14,   15,
           16,   17,    1,    1,   18,   19,   20,   21,   22,   23,
           24,   25,   26,   20,   20,   27,   28,   29,   30,   31,
           20,   32,   33,   34,   20,   35,   36,   20,   20,   20,
            1,    1,    1,    1,    1,    1,   20,   20,   20,   20,
    
           20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
           20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
           20,   20,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1
        } ;
    
    static yyconst flex_int32_t yy_meta[37] =
        {   0,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    2,    1,    1,    1,    1,    1,    2,    2,    2,
            2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
            2,    2,    2,    2,    2,    2
        } ;
    
    static yyconst flex_int16_t yy_base[87] =
        {   0,
            0,    0,   34,   35,  141,  142,  138,  142,  133,  142,
          142,  142,  142,  142,  126,  142,   32,  121,  142,   29,
          142,  120,  123,   27,   31,   35,   36,   38,   41,   42,
           39,   43,  142,  142,  129,  131,  142,  120,  119,   46,
          142,  142,  142,  142,    0,  118,   48,  117,   40,   54,
          116,   57,   59,   62,   64,   65,   66,  142,   67,   72,
          111,   73,   75,   69,   71,  110,   76,   78,  109,   86,
           70,  108,  107,   89,  106,   92,   94,  105,   93,   96,
          104,  103,  142,  125,  111,  107
        } ;
    
    static yyconst flex_int16_t yy_def[87] =
        {   0,
           83,    1,   84,   84,   83,   83,   83,   83,   83,   83,
           83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
           83,   83,   85,   85,   85,   85,   85,   85,   85,   85,
           85,   85,   83,   83,   83,   83,   83,   83,   83,   83,
           83,   83,   83,   83,   86,   85,   85,   85,   85,   85,
           85,   85,   85,   85,   85,   85,   85,   83,   85,   85,
           85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
           85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
           85,   85,    0,   83,   83,   83
        } ;
    
    static yyconst flex_int16_t yy_nxt[179] =
        {   0,
            6,    7,    8,    9,   10,   11,   12,   13,   14,   15,
           16,   17,   18,   19,   20,   21,   22,   23,   24,   23,
           25,   26,   23,   23,   23,   27,   23,   23,   23,   23,
           28,   29,   23,   30,   31,   32,   34,   34,   45,   35,
           35,   39,   45,   40,   42,   43,   45,   45,   47,   45,
           45,   45,   45,   45,   45,   39,   56,   40,   51,   45,
           48,   49,   54,   50,   52,   45,   55,   57,   45,   53,
           45,   59,   60,   45,   61,   45,   45,   45,   45,   64,
           45,   45,   45,   45,   45,   65,   45,   45,   63,   45,
           62,   67,   68,   69,   70,   72,   66,   45,   71,   73,
    
           45,   77,   74,   45,   45,   45,   75,   45,   45,   76,
           78,   80,   46,   79,   45,   45,   45,   45,   45,   45,
           45,   45,   45,   82,   81,   33,   33,   45,   45,   45,
           38,   38,   36,   58,   45,   44,   41,   38,   37,   36,
           83,    5,   83,   83,   83,   83,   83,   83,   83,   83,
           83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
           83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
           83,   83,   83,   83,   83,   83,   83,   83
        } ;
    
    static yyconst flex_int16_t yy_chk[179] =
        {   0,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
            1,    1,    1,    1,    1,    1,    3,    4,   24,    3,
            4,   17,   25,   17,   20,   20,   26,   27,   24,   28,
           31,   49,   29,   30,   32,   40,   31,   40,   27,   47,
           25,   26,   29,   26,   27,   50,   30,   32,   52,   28,
           53,   47,   49,   54,   50,   55,   56,   57,   59,   54,
           64,   71,   65,   60,   62,   55,   63,   67,   53,   68,
           52,   57,   59,   60,   62,   64,   56,   70,   63,   65,
    
           74,   71,   67,   76,   79,   77,   68,   80,   86,   70,
           74,   77,   85,   76,   82,   81,   78,   75,   73,   72,
           69,   66,   61,   80,   79,   84,   84,   51,   48,   46,
           39,   38,   36,   35,   23,   22,   18,   15,    9,    7,
            5,   83,   83,   83,   83,   83,   83,   83,   83,   83,
           83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
           83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
           83,   83,   83,   83,   83,   83,   83,   83
        } ;
    
    static yy_state_type yy_last_accepting_state;
    static char *yy_last_accepting_cpos;
    
    extern int yy_flex_debug;
    int yy_flex_debug = 0;
    
    /* The intent behind this definition is that it'll catch
     * any uses of REJECT which flex missed.
     */
    #define REJECT reject_used_but_not_detected
    #define yymore() yymore_used_but_not_detected
    #define YY_MORE_ADJ 0
    #define YY_RESTORE_YY_MORE_OFFSET
    char *yytext;
    #line 1 "parser.l"
    #line 2 "parser.l"
    /* 对于记号ID来说，属性值是ID的名字（字符串）；
     * 对于整数和浮点数来说，属性值是整数或者浮点数的值。
     */
    #include <string.h>
    #include "ast.h"
    #include "parser.tab.h" /* 该文件中包含了词法分析所需的记号名等 */
    #include "errormsg.h"
    
    int charPos=1;
    
    int yywrap(void)
    {
     charPos=1;//当词法分析器结束扫描时，单词位置charPos复位。
     return 1;
    }
    
    /* 跟踪单词在字符流上的位置charPos。 */
    void adjust(void)
    {
     EM_tokPos=charPos;
     charPos+=yyleng;
    }
    
    /* 空白 */
    /* 注意：注释不能直接放在正规定义之后 */
    /* 多个空白 */
     
    /* COMMENT表示注释 */
    #line 541 "lex.yy.c"
    
    #define INITIAL 0
    #define COMMENT 1
    
    #ifndef YY_NO_UNISTD_H
    /* Special case for "unistd.h", since it is non-ANSI. We include it way
     * down here because we want the user's section 1 to have been scanned first.
     * The user has a chance to override it with an option.
     */
    #include <unistd.h>
    #endif
    
    #ifndef YY_EXTRA_TYPE
    #define YY_EXTRA_TYPE void *
    #endif
    
    static int yy_init_globals (void );
    
    /* Accessor methods to globals.
       These are made visible to non-reentrant scanners for convenience. */
    
    int yylex_destroy (void );
    
    int yyget_debug (void );
    
    void yyset_debug (int debug_flag  );
    
    YY_EXTRA_TYPE yyget_extra (void );
    
    void yyset_extra (YY_EXTRA_TYPE user_defined  );
    
    FILE *yyget_in (void );
    
    void yyset_in  (FILE * in_str  );
    
    FILE *yyget_out (void );
    
    void yyset_out  (FILE * out_str  );
    
    int yyget_leng (void );
    
    char *yyget_text (void );
    
    int yyget_lineno (void );
    
    void yyset_lineno (int line_number  );
    
    /* Macros after this point can all be overridden by user definitions in
     * section 1.
     */
    
    #ifndef YY_SKIP_YYWRAP
    #ifdef __cplusplus
    extern "C" int yywrap (void );
    #else
    extern int yywrap (void );
    #endif
    #endif
    
        static void yyunput (int c,char *buf_ptr  );
        
    #ifndef yytext_ptr
    static void yy_flex_strncpy (char *,yyconst char *,int );
    #endif
    
    #ifdef YY_NEED_STRLEN
    static int yy_flex_strlen (yyconst char * );
    #endif
    
    #ifndef YY_NO_INPUT
    
    #ifdef __cplusplus
    static int yyinput (void );
    #else
    static int input (void );
    #endif
    
    #endif
    
    /* Amount of stuff to slurp up with each read. */
    #ifndef YY_READ_BUF_SIZE
    #define YY_READ_BUF_SIZE 8192
    #endif
    
    /* Copy whatever the last rule matched to the standard output. */
    #ifndef ECHO
    /* This used to be an fputs(), but since the string might contain NUL's,
     * we now use fwrite().
     */
    #define ECHO fwrite( yytext, yyleng, 1, yyout )
    #endif
    
    /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
     * is returned in "result".
     */
    #ifndef YY_INPUT
    #define YY_INPUT(buf,result,max_size) \
    	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
    		{ \
    		int c = '*'; \
    		int n; \
    		for ( n = 0; n < max_size && \
    			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
    			buf[n] = (char) c; \
    		if ( c == '\n' ) \
    			buf[n++] = (char) c; \
    		if ( c == EOF && ferror( yyin ) ) \
    			YY_FATAL_ERROR( "input in flex scanner failed" ); \
    		result = n; \
    		} \
    	else \
    		{ \
    		errno=0; \
    		while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
    			{ \
    			if( errno != EINTR) \
    				{ \
    				YY_FATAL_ERROR( "input in flex scanner failed" ); \
    				break; \
    				} \
    			errno=0; \
    			clearerr(yyin); \
    			} \
    		}\
    \
    
    #endif
    
    /* No semi-colon after return; correct usage is to write "yyterminate();" -
     * we don't want an extra ';' after the "return" because that will cause
     * some compilers to complain about unreachable statements.
     */
    #ifndef yyterminate
    #define yyterminate() return YY_NULL
    #endif
    
    /* Number of entries by which start-condition stack grows. */
    #ifndef YY_START_STACK_INCR
    #define YY_START_STACK_INCR 25
    #endif
    
    /* Report a fatal error. */
    #ifndef YY_FATAL_ERROR
    #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
    #endif
    
    /* end tables serialization structures and prototypes */
    
    /* Default declaration of generated scanner - a define so the user can
     * easily add parameters.
     */
    #ifndef YY_DECL
    #define YY_DECL_IS_OURS 1
    
    extern int yylex (void);
    
    #define YY_DECL int yylex (void)
    #endif /* !YY_DECL */
    
    /* Code executed at the beginning of each rule, after yytext and yyleng
     * have been set up.
     */
    #ifndef YY_USER_ACTION
    #define YY_USER_ACTION
    #endif
    
    /* Code executed at the end of each rule. */
    #ifndef YY_BREAK
    #define YY_BREAK break;
    #endif
    
    #define YY_RULE_SETUP \
    	YY_USER_ACTION
    
    /** The main scanner function which does all the work.
     */
    YY_DECL
    {
    	register yy_state_type yy_current_state;
    	register char *yy_cp, *yy_bp;
    	register int yy_act;
        
    #line 43 "parser.l"
    
    #line 726 "lex.yy.c"
    
    	if ( !(yy_init) )
    		{
    		(yy_init) = 1;
    
    #ifdef YY_USER_INIT
    		YY_USER_INIT;
    #endif
    
    		if ( ! (yy_start) )
    			(yy_start) = 1;	/* first start state */
    
    		if ( ! yyin )
    			yyin = stdin;
    
    		if ( ! yyout )
    			yyout = stdout;
    
    		if ( ! YY_CURRENT_BUFFER ) {
    			yyensure_buffer_stack ();
    			YY_CURRENT_BUFFER_LVALUE =
    				yy_create_buffer(yyin,YY_BUF_SIZE );
    		}
    
    		yy_load_buffer_state( );
    		}
    
    	while ( 1 )		/* loops until end-of-file is reached */
    		{
    		yy_cp = (yy_c_buf_p);
    
    		/* Support of yytext. */
    		*yy_cp = (yy_hold_char);
    
    		/* yy_bp points to the position in yy_ch_buf of the start of
    		 * the current run.
    		 */
    		yy_bp = yy_cp;
    
    		yy_current_state = (yy_start);
    yy_match:
    		do
    			{
    			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
    			if ( yy_accept[yy_current_state] )
    				{
    				(yy_last_accepting_state) = yy_current_state;
    				(yy_last_accepting_cpos) = yy_cp;
    				}
    			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    				{
    				yy_current_state = (int) yy_def[yy_current_state];
    				if ( yy_current_state >= 84 )
    					yy_c = yy_meta[(unsigned int) yy_c];
    				}
    			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    			++yy_cp;
    			}
    		while ( yy_base[yy_current_state] != 142 );
    
    yy_find_action:
    		yy_act = yy_accept[yy_current_state];
    		if ( yy_act == 0 )
    			{ /* have to back up */
    			yy_cp = (yy_last_accepting_cpos);
    			yy_current_state = (yy_last_accepting_state);
    			yy_act = yy_accept[yy_current_state];
    			}
    
    		YY_DO_BEFORE_ACTION;
    
    do_action:	/* This label is used only to access EOF actions. */
    
    		switch ( yy_act )
    	{ /* beginning of action switch */
    			case 0: /* must back up */
    			/* undo the effects of YY_DO_BEFORE_ACTION */
    			*yy_cp = (yy_hold_char);
    			yy_cp = (yy_last_accepting_cpos);
    			yy_current_state = (yy_last_accepting_state);
    			goto yy_find_action;
    
    case 1:
    YY_RULE_SETUP
    #line 44 "parser.l"
    {adjust(); BEGIN COMMENT; }
    	YY_BREAK
    case 2:
    YY_RULE_SETUP
    #line 46 "parser.l"
    {adjust(); BEGIN INITIAL; }                     
    	YY_BREAK
    case 3:
    /* rule 3 can match eol */
    YY_RULE_SETUP
    #line 47 "parser.l"
    {adjust(); EM_newline(); }
    	YY_BREAK
    case 4:
    YY_RULE_SETUP
    #line 48 "parser.l"
    {adjust(); }
    	YY_BREAK
    case 5:
    YY_RULE_SETUP
    #line 51 "parser.l"
    {adjust();}
    	YY_BREAK
    case 6:
    /* rule 6 can match eol */
    YY_RULE_SETUP
    #line 52 "parser.l"
    {adjust(); EM_newline();}
    	YY_BREAK
    case 7:
    YY_RULE_SETUP
    #line 53 "parser.l"
    {adjust(); return COMMA;}
    	YY_BREAK
    case 8:
    YY_RULE_SETUP
    #line 54 "parser.l"
    {adjust(); return COLON;}
    	YY_BREAK
    case 9:
    YY_RULE_SETUP
    #line 55 "parser.l"
    {adjust(); return SEMICOLON;}
    	YY_BREAK
    case 10:
    YY_RULE_SETUP
    #line 56 "parser.l"
    {adjust(); return LPAREN;}
    	YY_BREAK
    case 11:
    YY_RULE_SETUP
    #line 57 "parser.l"
    {adjust(); return RPAREN;}
    	YY_BREAK
    case 12:
    YY_RULE_SETUP
    #line 58 "parser.l"
    {adjust(); return PERIOD;}
    	YY_BREAK
    case 13:
    YY_RULE_SETUP
    #line 59 "parser.l"
    {adjust(); return PLUS;}
    	YY_BREAK
    case 14:
    YY_RULE_SETUP
    #line 60 "parser.l"
    {adjust(); return MINUS;}
    	YY_BREAK
    case 15:
    YY_RULE_SETUP
    #line 61 "parser.l"
    {adjust(); return TIMES;}
    	YY_BREAK
    case 16:
    YY_RULE_SETUP
    #line 62 "parser.l"
    {adjust(); return DIVIDE;}
    	YY_BREAK
    case 17:
    YY_RULE_SETUP
    #line 63 "parser.l"
    {adjust(); return EQ;}
    	YY_BREAK
    case 18:
    YY_RULE_SETUP
    #line 64 "parser.l"
    {adjust(); return NEQ;}
    	YY_BREAK
    case 19:
    YY_RULE_SETUP
    #line 65 "parser.l"
    {adjust(); return LT;}
    	YY_BREAK
    case 20:
    YY_RULE_SETUP
    #line 66 "parser.l"
    {adjust(); return LE;}
    	YY_BREAK
    case 21:
    YY_RULE_SETUP
    #line 67 "parser.l"
    {adjust(); return GT;}
    	YY_BREAK
    case 22:
    YY_RULE_SETUP
    #line 68 "parser.l"
    {adjust(); return GE;}
    	YY_BREAK
    case 23:
    YY_RULE_SETUP
    #line 69 "parser.l"
    {adjust(); return ASSIGN;}
    	YY_BREAK
    case 24:
    YY_RULE_SETUP
    #line 71 "parser.l"
    {adjust(); return PROGRAM;}
    	YY_BREAK
    case 25:
    YY_RULE_SETUP
    #line 72 "parser.l"
    {adjust(); return IF;}
    	YY_BREAK
    case 26:
    YY_RULE_SETUP
    #line 73 "parser.l"
    {adjust(); return THEN;}
    	YY_BREAK
    case 27:
    YY_RULE_SETUP
    #line 74 "parser.l"
    {adjust(); return ELSE;}
    	YY_BREAK
    case 28:
    YY_RULE_SETUP
    #line 75 "parser.l"
    {adjust(); return WHILE;}
    	YY_BREAK
    case 29:
    YY_RULE_SETUP
    #line 76 "parser.l"
    {adjust(); return BEGINN;}
    	YY_BREAK
    case 30:
    YY_RULE_SETUP
    #line 77 "parser.l"
    {adjust(); return END;}
    	YY_BREAK
    case 31:
    YY_RULE_SETUP
    #line 78 "parser.l"
    {adjust(); return DO;}
    	YY_BREAK
    case 32:
    YY_RULE_SETUP
    #line 79 "parser.l"
    {adjust(); return REAL;}
    	YY_BREAK
    case 33:
    YY_RULE_SETUP
    #line 80 "parser.l"
    {adjust(); return INTEGER;}
    	YY_BREAK
    case 34:
    YY_RULE_SETUP
    #line 81 "parser.l"
    {adjust(); return VAR;}
    	YY_BREAK
    case 35:
    YY_RULE_SETUP
    #line 83 "parser.l"
    {adjust(); yylval.sval = String(yytext); return ID;}
    	YY_BREAK
    case 36:
    YY_RULE_SETUP
    #line 85 "parser.l"
    {adjust(); yylval.ival=atoi(yytext); return INT;}
    	YY_BREAK
    case 37:
    YY_RULE_SETUP
    #line 86 "parser.l"
    {adjust(); yylval.fval=atof(yytext); return FLOAT;}
    	YY_BREAK
    case 38:
    YY_RULE_SETUP
    #line 87 "parser.l"
    {adjust(); EM_error(EM_tokPos,"illegal token: %s", yytext);}
    	YY_BREAK
    case 39:
    YY_RULE_SETUP
    #line 89 "parser.l"
    ECHO;
    	YY_BREAK
    #line 1006 "lex.yy.c"
    case YY_STATE_EOF(INITIAL):
    case YY_STATE_EOF(COMMENT):
    	yyterminate();
    
    	case YY_END_OF_BUFFER:
    		{
    		/* Amount of text matched not including the EOB char. */
    		int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
    
    		/* Undo the effects of YY_DO_BEFORE_ACTION. */
    		*yy_cp = (yy_hold_char);
    		YY_RESTORE_YY_MORE_OFFSET
    
    		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
    			{
    			/* We're scanning a new file or input source.  It's
    			 * possible that this happened because the user
    			 * just pointed yyin at a new source and called
    			 * yylex().  If so, then we have to assure
    			 * consistency between YY_CURRENT_BUFFER and our
    			 * globals.  Here is the right place to do so, because
    			 * this is the first action (other than possibly a
    			 * back-up) that will match for the new input source.
    			 */
    			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    			YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
    			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
    			}
    
    		/* Note that here we test for yy_c_buf_p "<=" to the position
    		 * of the first EOB in the buffer, since yy_c_buf_p will
    		 * already have been incremented past the NUL character
    		 * (since all states make transitions on EOB to the
    		 * end-of-buffer state).  Contrast this with the test
    		 * in input().
    		 */
    		if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
    			{ /* This was really a NUL. */
    			yy_state_type yy_next_state;
    
    			(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
    
    			yy_current_state = yy_get_previous_state(  );
    
    			/* Okay, we're now positioned to make the NUL
    			 * transition.  We couldn't have
    			 * yy_get_previous_state() go ahead and do it
    			 * for us because it doesn't know how to deal
    			 * with the possibility of jamming (and we don't
    			 * want to build jamming into it because then it
    			 * will run more slowly).
    			 */
    
    			yy_next_state = yy_try_NUL_trans( yy_current_state );
    
    			yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    
    			if ( yy_next_state )
    				{
    				/* Consume the NUL. */
    				yy_cp = ++(yy_c_buf_p);
    				yy_current_state = yy_next_state;
    				goto yy_match;
    				}
    
    			else
    				{
    				yy_cp = (yy_c_buf_p);
    				goto yy_find_action;
    				}
    			}
    
    		else switch ( yy_get_next_buffer(  ) )
    			{
    			case EOB_ACT_END_OF_FILE:
    				{
    				(yy_did_buffer_switch_on_eof) = 0;
    
    				if ( yywrap( ) )
    					{
    					/* Note: because we've taken care in
    					 * yy_get_next_buffer() to have set up
    					 * yytext, we can now set up
    					 * yy_c_buf_p so that if some total
    					 * hoser (like flex itself) wants to
    					 * call the scanner after we return the
    					 * YY_NULL, it'll still work - another
    					 * YY_NULL will get returned.
    					 */
    					(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
    
    					yy_act = YY_STATE_EOF(YY_START);
    					goto do_action;
    					}
    
    				else
    					{
    					if ( ! (yy_did_buffer_switch_on_eof) )
    						YY_NEW_FILE;
    					}
    				break;
    				}
    
    			case EOB_ACT_CONTINUE_SCAN:
    				(yy_c_buf_p) =
    					(yytext_ptr) + yy_amount_of_matched_text;
    
    				yy_current_state = yy_get_previous_state(  );
    
    				yy_cp = (yy_c_buf_p);
    				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    				goto yy_match;
    
    			case EOB_ACT_LAST_MATCH:
    				(yy_c_buf_p) =
    				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
    
    				yy_current_state = yy_get_previous_state(  );
    
    				yy_cp = (yy_c_buf_p);
    				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
    				goto yy_find_action;
    			}
    		break;
    		}
    
    	default:
    		YY_FATAL_ERROR(
    			"fatal flex scanner internal error--no action found" );
    	} /* end of action switch */
    		} /* end of scanning one token */
    } /* end of yylex */
    
    /* yy_get_next_buffer - try to read in a new buffer
     *
     * Returns a code representing an action:
     *	EOB_ACT_LAST_MATCH -
     *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
     *	EOB_ACT_END_OF_FILE - end of file
     */
    static int yy_get_next_buffer (void)
    {
        	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
    	register char *source = (yytext_ptr);
    	register int number_to_move, i;
    	int ret_val;
    
    	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
    		YY_FATAL_ERROR(
    		"fatal flex scanner internal error--end of buffer missed" );
    
    	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
    		{ /* Don't try to fill the buffer, so this is an EOF. */
    		if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
    			{
    			/* We matched a single character, the EOB, so
    			 * treat this as a final EOF.
    			 */
    			return EOB_ACT_END_OF_FILE;
    			}
    
    		else
    			{
    			/* We matched some text prior to the EOB, first
    			 * process it.
    			 */
    			return EOB_ACT_LAST_MATCH;
    			}
    		}
    
    	/* Try to read more data. */
    
    	/* First move last chars to start of buffer. */
    	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
    
    	for ( i = 0; i < number_to_move; ++i )
    		*(dest++) = *(source++);
    
    	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
    		/* don't do the read, it's not guaranteed to return an EOF,
    		 * just force an EOF
    		 */
    		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
    
    	else
    		{
    			int num_to_read =
    			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
    
    		while ( num_to_read <= 0 )
    			{ /* Not enough room in the buffer - grow it. */
    
    			/* just a shorter name for the current buffer */
    			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
    
    			int yy_c_buf_p_offset =
    				(int) ((yy_c_buf_p) - b->yy_ch_buf);
    
    			if ( b->yy_is_our_buffer )
    				{
    				int new_size = b->yy_buf_size * 2;
    
    				if ( new_size <= 0 )
    					b->yy_buf_size += b->yy_buf_size / 8;
    				else
    					b->yy_buf_size *= 2;
    
    				b->yy_ch_buf = (char *)
    					/* Include room in for 2 EOB chars. */
    					yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
    				}
    			else
    				/* Can't grow it, we don't own it. */
    				b->yy_ch_buf = 0;
    
    			if ( ! b->yy_ch_buf )
    				YY_FATAL_ERROR(
    				"fatal error - scanner input buffer overflow" );
    
    			(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
    
    			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
    						number_to_move - 1;
    
    			}
    
    		if ( num_to_read > YY_READ_BUF_SIZE )
    			num_to_read = YY_READ_BUF_SIZE;
    
    		/* Read in more data. */
    		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
    			(yy_n_chars), (size_t) num_to_read );
    
    		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    		}
    
    	if ( (yy_n_chars) == 0 )
    		{
    		if ( number_to_move == YY_MORE_ADJ )
    			{
    			ret_val = EOB_ACT_END_OF_FILE;
    			yyrestart(yyin  );
    			}
    
    		else
    			{
    			ret_val = EOB_ACT_LAST_MATCH;
    			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
    				YY_BUFFER_EOF_PENDING;
    			}
    		}
    
    	else
    		ret_val = EOB_ACT_CONTINUE_SCAN;
    
    	if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
    		/* Extend the array by 50%, plus the number we really need. */
    		yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
    		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
    		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
    			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
    	}
    
    	(yy_n_chars) += number_to_move;
    	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
    	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
    
    	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
    
    	return ret_val;
    }
    
    /* yy_get_previous_state - get the state just before the EOB char was reached */
    
        static yy_state_type yy_get_previous_state (void)
    {
    	register yy_state_type yy_current_state;
    	register char *yy_cp;
        
    	yy_current_state = (yy_start);
    
    	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
    		{
    		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
    		if ( yy_accept[yy_current_state] )
    			{
    			(yy_last_accepting_state) = yy_current_state;
    			(yy_last_accepting_cpos) = yy_cp;
    			}
    		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    			{
    			yy_current_state = (int) yy_def[yy_current_state];
    			if ( yy_current_state >= 84 )
    				yy_c = yy_meta[(unsigned int) yy_c];
    			}
    		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    		}
    
    	return yy_current_state;
    }
    
    /* yy_try_NUL_trans - try to make a transition on the NUL character
     *
     * synopsis
     *	next_state = yy_try_NUL_trans( current_state );
     */
        static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
    {
    	register int yy_is_jam;
        	register char *yy_cp = (yy_c_buf_p);
    
    	register YY_CHAR yy_c = 1;
    	if ( yy_accept[yy_current_state] )
    		{
    		(yy_last_accepting_state) = yy_current_state;
    		(yy_last_accepting_cpos) = yy_cp;
    		}
    	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    		{
    		yy_current_state = (int) yy_def[yy_current_state];
    		if ( yy_current_state >= 84 )
    			yy_c = yy_meta[(unsigned int) yy_c];
    		}
    	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    	yy_is_jam = (yy_current_state == 83);
    
    	return yy_is_jam ? 0 : yy_current_state;
    }
    
        static void yyunput (int c, register char * yy_bp )
    {
    	register char *yy_cp;
        
        yy_cp = (yy_c_buf_p);
    
    	/* undo effects of setting up yytext */
    	*yy_cp = (yy_hold_char);
    
    	if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    		{ /* need to shift things up to make room */
    		/* +2 for EOB chars. */
    		register int number_to_move = (yy_n_chars) + 2;
    		register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
    					YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
    		register char *source =
    				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
    
    		while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
    			*--dest = *--source;
    
    		yy_cp += (int) (dest - source);
    		yy_bp += (int) (dest - source);
    		YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
    			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
    
    		if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
    			YY_FATAL_ERROR( "flex scanner push-back overflow" );
    		}
    
    	*--yy_cp = (char) c;
    
    	(yytext_ptr) = yy_bp;
    	(yy_hold_char) = *yy_cp;
    	(yy_c_buf_p) = yy_cp;
    }
    
    #ifndef YY_NO_INPUT
    #ifdef __cplusplus
        static int yyinput (void)
    #else
        static int input  (void)
    #endif
    
    {
    	int c;
        
    	*(yy_c_buf_p) = (yy_hold_char);
    
    	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
    		{
    		/* yy_c_buf_p now points to the character we want to return.
    		 * If this occurs *before* the EOB characters, then it's a
    		 * valid NUL; if not, then we've hit the end of the buffer.
    		 */
    		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
    			/* This was really a NUL. */
    			*(yy_c_buf_p) = '\0';
    
    		else
    			{ /* need more input */
    			int offset = (yy_c_buf_p) - (yytext_ptr);
    			++(yy_c_buf_p);
    
    			switch ( yy_get_next_buffer(  ) )
    				{
    				case EOB_ACT_LAST_MATCH:
    					/* This happens because yy_g_n_b()
    					 * sees that we've accumulated a
    					 * token and flags that we need to
    					 * try matching the token before
    					 * proceeding.  But for input(),
    					 * there's no matching to consider.
    					 * So convert the EOB_ACT_LAST_MATCH
    					 * to EOB_ACT_END_OF_FILE.
    					 */
    
    					/* Reset buffer status. */
    					yyrestart(yyin );
    
    					/*FALLTHROUGH*/
    
    				case EOB_ACT_END_OF_FILE:
    					{
    					if ( yywrap( ) )
    						return EOF;
    
    					if ( ! (yy_did_buffer_switch_on_eof) )
    						YY_NEW_FILE;
    #ifdef __cplusplus
    					return yyinput();
    #else
    					return input();
    #endif
    					}
    
    				case EOB_ACT_CONTINUE_SCAN:
    					(yy_c_buf_p) = (yytext_ptr) + offset;
    					break;
    				}
    			}
    		}
    
    	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
    	*(yy_c_buf_p) = '\0';	/* preserve yytext */
    	(yy_hold_char) = *++(yy_c_buf_p);
    
    	return c;
    }
    #endif	/* ifndef YY_NO_INPUT */
    
    /** Immediately switch to a different input stream.
     * @param input_file A readable stream.
     * 
     * @note This function does not reset the start condition to @c INITIAL .
     */
        void yyrestart  (FILE * input_file )
    {
        
    	if ( ! YY_CURRENT_BUFFER ){
            yyensure_buffer_stack ();
    		YY_CURRENT_BUFFER_LVALUE =
                yy_create_buffer(yyin,YY_BUF_SIZE );
    	}
    
    	yy_init_buffer(YY_CURRENT_BUFFER,input_file );
    	yy_load_buffer_state( );
    }
    
    /** Switch to a different input buffer.
     * @param new_buffer The new input buffer.
     * 
     */
        void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
    {
        
    	/* TODO. We should be able to replace this entire function body
    	 * with
    	 *		yypop_buffer_state();
    	 *		yypush_buffer_state(new_buffer);
         */
    	yyensure_buffer_stack ();
    	if ( YY_CURRENT_BUFFER == new_buffer )
    		return;
    
    	if ( YY_CURRENT_BUFFER )
    		{
    		/* Flush out information for old buffer. */
    		*(yy_c_buf_p) = (yy_hold_char);
    		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
    		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    		}
    
    	YY_CURRENT_BUFFER_LVALUE = new_buffer;
    	yy_load_buffer_state( );
    
    	/* We don't actually know whether we did this switch during
    	 * EOF (yywrap()) processing, but the only time this flag
    	 * is looked at is after yywrap() is called, so it's safe
    	 * to go ahead and always set it.
    	 */
    	(yy_did_buffer_switch_on_eof) = 1;
    }
    
    static void yy_load_buffer_state  (void)
    {
        	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
    	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
    	(yy_hold_char) = *(yy_c_buf_p);
    }
    
    /** Allocate and initialize an input buffer state.
     * @param file A readable stream.
     * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
     * 
     * @return the allocated buffer state.
     */
        YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
    {
    	YY_BUFFER_STATE b;
        
    	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
    	if ( ! b )
    		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    
    	b->yy_buf_size = size;
    
    	/* yy_ch_buf has to be 2 characters longer than the size given because
    	 * we need to put in 2 end-of-buffer characters.
    	 */
    	b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
    	if ( ! b->yy_ch_buf )
    		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    
    	b->yy_is_our_buffer = 1;
    
    	yy_init_buffer(b,file );
    
    	return b;
    }
    
    /** Destroy the buffer.
     * @param b a buffer created with yy_create_buffer()
     * 
     */
        void yy_delete_buffer (YY_BUFFER_STATE  b )
    {
        
    	if ( ! b )
    		return;
    
    	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
    		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
    
    	if ( b->yy_is_our_buffer )
    		yyfree((void *) b->yy_ch_buf  );
    
    	yyfree((void *) b  );
    }
    
    #ifndef __cplusplus
    extern int isatty (int );
    #endif /* __cplusplus */
        
    /* Initializes or reinitializes a buffer.
     * This function is sometimes called more than once on the same buffer,
     * such as during a yyrestart() or at EOF.
     */
        static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
    
    {
    	int oerrno = errno;
        
    	yy_flush_buffer(b );
    
    	b->yy_input_file = file;
    	b->yy_fill_buffer = 1;
    
        /* If b is the current buffer, then yy_init_buffer was _probably_
         * called from yyrestart() or through yy_get_next_buffer.
         * In that case, we don't want to reset the lineno or column.
         */
        if (b != YY_CURRENT_BUFFER){
            b->yy_bs_lineno = 1;
            b->yy_bs_column = 0;
        }
    
            b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
        
    	errno = oerrno;
    }
    
    /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
     * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
     * 
     */
        void yy_flush_buffer (YY_BUFFER_STATE  b )
    {
        	if ( ! b )
    		return;
    
    	b->yy_n_chars = 0;
    
    	/* We always need two end-of-buffer characters.  The first causes
    	 * a transition to the end-of-buffer state.  The second causes
    	 * a jam in that state.
    	 */
    	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
    	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
    
    	b->yy_buf_pos = &b->yy_ch_buf[0];
    
    	b->yy_at_bol = 1;
    	b->yy_buffer_status = YY_BUFFER_NEW;
    
    	if ( b == YY_CURRENT_BUFFER )
    		yy_load_buffer_state( );
    }
    
    /** Pushes the new state onto the stack. The new state becomes
     *  the current state. This function will allocate the stack
     *  if necessary.
     *  @param new_buffer The new state.
     *  
     */
    void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
    {
        	if (new_buffer == NULL)
    		return;
    
    	yyensure_buffer_stack();
    
    	/* This block is copied from yy_switch_to_buffer. */
    	if ( YY_CURRENT_BUFFER )
    		{
    		/* Flush out information for old buffer. */
    		*(yy_c_buf_p) = (yy_hold_char);
    		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
    		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    		}
    
    	/* Only push if top exists. Otherwise, replace top. */
    	if (YY_CURRENT_BUFFER)
    		(yy_buffer_stack_top)++;
    	YY_CURRENT_BUFFER_LVALUE = new_buffer;
    
    	/* copied from yy_switch_to_buffer. */
    	yy_load_buffer_state( );
    	(yy_did_buffer_switch_on_eof) = 1;
    }
    
    /** Removes and deletes the top of the stack, if present.
     *  The next element becomes the new top.
     *  
     */
    void yypop_buffer_state (void)
    {
        	if (!YY_CURRENT_BUFFER)
    		return;
    
    	yy_delete_buffer(YY_CURRENT_BUFFER );
    	YY_CURRENT_BUFFER_LVALUE = NULL;
    	if ((yy_buffer_stack_top) > 0)
    		--(yy_buffer_stack_top);
    
    	if (YY_CURRENT_BUFFER) {
    		yy_load_buffer_state( );
    		(yy_did_buffer_switch_on_eof) = 1;
    	}
    }
    
    /* Allocates the stack if it does not exist.
     *  Guarantees space for at least one push.
     */
    static void yyensure_buffer_stack (void)
    {
    	int num_to_alloc;
        
    	if (!(yy_buffer_stack)) {
    
    		/* First allocation is just for 2 elements, since we don't know if this
    		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
    		 * immediate realloc on the next call.
             */
    		num_to_alloc = 1;
    		(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
    								(num_to_alloc * sizeof(struct yy_buffer_state*)
    								);
    		if ( ! (yy_buffer_stack) )
    			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
    								  
    		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
    				
    		(yy_buffer_stack_max) = num_to_alloc;
    		(yy_buffer_stack_top) = 0;
    		return;
    	}
    
    	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
    
    		/* Increase the buffer to prepare for a possible push. */
    		int grow_size = 8 /* arbitrary grow size */;
    
    		num_to_alloc = (yy_buffer_stack_max) + grow_size;
    		(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
    								((yy_buffer_stack),
    								num_to_alloc * sizeof(struct yy_buffer_state*)
    								);
    		if ( ! (yy_buffer_stack) )
    			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
    
    		/* zero only the new slots.*/
    		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
    		(yy_buffer_stack_max) = num_to_alloc;
    	}
    }
    
    /** Setup the input buffer state to scan directly from a user-specified character buffer.
     * @param base the character buffer
     * @param size the size in bytes of the character buffer
     * 
     * @return the newly allocated buffer state object. 
     */
    YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
    {
    	YY_BUFFER_STATE b;
        
    	if ( size < 2 ||
    	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
    	     base[size-1] != YY_END_OF_BUFFER_CHAR )
    		/* They forgot to leave room for the EOB's. */
    		return 0;
    
    	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
    	if ( ! b )
    		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
    
    	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
    	b->yy_buf_pos = b->yy_ch_buf = base;
    	b->yy_is_our_buffer = 0;
    	b->yy_input_file = 0;
    	b->yy_n_chars = b->yy_buf_size;
    	b->yy_is_interactive = 0;
    	b->yy_at_bol = 1;
    	b->yy_fill_buffer = 0;
    	b->yy_buffer_status = YY_BUFFER_NEW;
    
    	yy_switch_to_buffer(b  );
    
    	return b;
    }
    
    /** Setup the input buffer state to scan a string. The next call to yylex() will
     * scan from a @e copy of @a str.
     * @param yystr a NUL-terminated string to scan
     * 
     * @return the newly allocated buffer state object.
     * @note If you want to scan bytes that may contain NUL values, then use
     *       yy_scan_bytes() instead.
     */
    YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
    {
        
    	return yy_scan_bytes(yystr,strlen(yystr) );
    }
    
    /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
     * scan from a @e copy of @a bytes.
     * @param bytes the byte buffer to scan
     * @param len the number of bytes in the buffer pointed to by @a bytes.
     * 
     * @return the newly allocated buffer state object.
     */
    YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
    {
    	YY_BUFFER_STATE b;
    	char *buf;
    	yy_size_t n;
    	int i;
        
    	/* Get memory for full buffer, including space for trailing EOB's. */
    	n = _yybytes_len + 2;
    	buf = (char *) yyalloc(n  );
    	if ( ! buf )
    		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
    
    	for ( i = 0; i < _yybytes_len; ++i )
    		buf[i] = yybytes[i];
    
    	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
    
    	b = yy_scan_buffer(buf,n );
    	if ( ! b )
    		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
    
    	/* It's okay to grow etc. this buffer, and we should throw it
    	 * away when we're done.
    	 */
    	b->yy_is_our_buffer = 1;
    
    	return b;
    }
    
    #ifndef YY_EXIT_FAILURE
    #define YY_EXIT_FAILURE 2
    #endif
    
    static void yy_fatal_error (yyconst char* msg )
    {
        	(void) fprintf( stderr, "%s\n", msg );
    	exit( YY_EXIT_FAILURE );
    }
    
    /* Redefine yyless() so it works in section 3 code. */
    
    #undef yyless
    #define yyless(n) \
    	do \
    		{ \
    		/* Undo effects of setting up yytext. */ \
            int yyless_macro_arg = (n); \
            YY_LESS_LINENO(yyless_macro_arg);\
    		yytext[yyleng] = (yy_hold_char); \
    		(yy_c_buf_p) = yytext + yyless_macro_arg; \
    		(yy_hold_char) = *(yy_c_buf_p); \
    		*(yy_c_buf_p) = '\0'; \
    		yyleng = yyless_macro_arg; \
    		} \
    	while ( 0 )
    
    /* Accessor  methods (get/set functions) to struct members. */
    
    /** Get the current line number.
     * 
     */
    int yyget_lineno  (void)
    {
            
        return yylineno;
    }
    
    /** Get the input stream.
     * 
     */
    FILE *yyget_in  (void)
    {
            return yyin;
    }
    
    /** Get the output stream.
     * 
     */
    FILE *yyget_out  (void)
    {
            return yyout;
    }
    
    /** Get the length of the current token.
     * 
     */
    int yyget_leng  (void)
    {
            return yyleng;
    }
    
    /** Get the current token.
     * 
     */
    
    char *yyget_text  (void)
    {
            return yytext;
    }
    
    /** Set the current line number.
     * @param line_number
     * 
     */
    void yyset_lineno (int  line_number )
    {
        
        yylineno = line_number;
    }
    
    /** Set the input stream. This does not discard the current
     * input buffer.
     * @param in_str A readable stream.
     * 
     * @see yy_switch_to_buffer
     */
    void yyset_in (FILE *  in_str )
    {
            yyin = in_str ;
    }
    
    void yyset_out (FILE *  out_str )
    {
            yyout = out_str ;
    }
    
    int yyget_debug  (void)
    {
            return yy_flex_debug;
    }
    
    void yyset_debug (int  bdebug )
    {
            yy_flex_debug = bdebug ;
    }
    
    static int yy_init_globals (void)
    {
            /* Initialization is the same as for the non-reentrant scanner.
         * This function is called from yylex_destroy(), so don't allocate here.
         */
    
        (yy_buffer_stack) = 0;
        (yy_buffer_stack_top) = 0;
        (yy_buffer_stack_max) = 0;
        (yy_c_buf_p) = (char *) 0;
        (yy_init) = 0;
        (yy_start) = 0;
    
    /* Defined in main.c */
    #ifdef YY_STDINIT
        yyin = stdin;
        yyout = stdout;
    #else
        yyin = (FILE *) 0;
        yyout = (FILE *) 0;
    #endif
    
        /* For future reference: Set errno on error, since we are called by
         * yylex_init()
         */
        return 0;
    }
    
    /* yylex_destroy is for both reentrant and non-reentrant scanners. */
    int yylex_destroy  (void)
    {
        
        /* Pop the buffer stack, destroying each element. */
    	while(YY_CURRENT_BUFFER){
    		yy_delete_buffer(YY_CURRENT_BUFFER  );
    		YY_CURRENT_BUFFER_LVALUE = NULL;
    		yypop_buffer_state();
    	}
    
    	/* Destroy the stack itself. */
    	yyfree((yy_buffer_stack) );
    	(yy_buffer_stack) = NULL;
    
        /* Reset the globals. This is important in a non-reentrant scanner so the next time
         * yylex() is called, initialization will occur. */
        yy_init_globals( );
    
        return 0;
    }
    
    /*
     * Internal utility routines.
     */
    
    #ifndef yytext_ptr
    static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
    {
    	register int i;
    	for ( i = 0; i < n; ++i )
    		s1[i] = s2[i];
    }
    #endif
    
    #ifdef YY_NEED_STRLEN
    static int yy_flex_strlen (yyconst char * s )
    {
    	register int n;
    	for ( n = 0; s[n]; ++n )
    		;
    
    	return n;
    }
    #endif
    
    void *yyalloc (yy_size_t  size )
    {
    	return (void *) malloc( size );
    }
    
    void *yyrealloc  (void * ptr, yy_size_t  size )
    {
    	/* The cast to (char *) in the following accommodates both
    	 * implementations that use char* generic pointers, and those
    	 * that use void* generic pointers.  It works with the latter
    	 * because both ANSI C and C++ allow castless assignment from
    	 * any pointer type to void*, and deal with argument conversions
    	 * as though doing an assignment.
    	 */
    	return (void *) realloc( (char *) ptr, size );
    }
    
    void yyfree (void * ptr )
    {
    	free( (char *) ptr );	/* see yyrealloc() for (char *) cast */
    }
    
    #define YYTABLES_NAME "yytables"
    
    #line 89 "parser.l"
    
    
    
    /* 该函数重置lex状态为初始状态 */
    void resetLexState(){
      BEGIN INITIAL;
    }

（6）makefile

parser1.exe: parsetest.o parser.tab.o lex.yy.o errormsg.o util.o ast.o prast.o
    	gcc -o parser1 parsetest.o parser.tab.o lex.yy.o errormsg.o util.o ast.o prast.o
    
    parsetest.o: parsetest.c errormsg.h ast.h util.h prast.h
    	gcc -c parsetest.c
    
    parser.tab.o: parser.tab.c ast.h util.h errormsg.h
    	gcc -c parser.tab.c
    
    parser.tab.c: parser.y
    	bison -dv parser.y
    
    parser.tab.h: parser.tab.c
    	echo "parser.tab.h was created at the same time as parser.tab.c"
    
    errormsg.o: errormsg.c errormsg.h util.h
    	gcc -c errormsg.c
    
    ast.o: ast.c ast.h util.h
    	gcc -c ast.c
    
    lex.yy.o: lex.yy.c parser.tab.h errormsg.h ast.h util.h
    	gcc -c lex.yy.c
    
    #lex.yy.c: parser.l
    #	flex parser.l
    
    
    util.o: util.c util.h
    	gcc -c util.c
    
    prast.o: prast.c prast.h ast.h
    	gcc -c prast.c
    
    
    #测试例test0.p（只指定输入文件，屏幕输出）
    test00:
    	./parser1.exe testcases/test0.p
    
    #测试例test0.p （指定了输入和输出文件）
    test01:
    	./parser1.exe testcases/test0.p test0.out
    
    
    
    clean: 
    	rm -f parser1.exe util.o parsetest.o lex.yy.o errormsg.o parser.tab.c parser.tab.h parser.tab.o ast.o prast.o *.stackdump parser.output *.out

（7）parser.y

%{
    #include <stdio.h>
    #include "ast.h" //该文件定义了抽象语法树（分析树）的数据结构
    #include "errormsg.h"
    
    int yylex(void); /* function prototype */
    
    /* 该函数显示错误信息s，显示时包含了错误发生的位置。*/
    void yyerror(char *s)
    {
     EM_error(EM_tokPos, "%s", s);
    }
    
    /* 存放抽象语法树中 "程序" 数据结构的变量 */
    a_prog program = NULL;
    %}
    
    
     /* 定义属性值栈的类型，实验7需要修改此处 */
    %union {
    	int ival;
    	double fval;
    	string sval;
    	a_exp  expv;   /*true*/
      a_bexp bexpv; /*true*/
      a_id   idv;  /*true*/
      ttype  tttypev; /*true*/
      a_stm  stmv; /*true*/
      a_stm_list stmsv; /*true*/
      a_prog  progv; /*true*/
      a_var_list varlv; /*true*/
      a_dec  decv; /*true*/
      a_dec_list declv;
      a_bop bopv; /*true*/
    }
    
     /* 定义各个终结符，以及他们的属性值的类型，实验7需要修改此处 */
    %token <sval> ID /* id */
    %token <ival> INT  /*整型数*/
    %token <fval> FLOAT /*浮点数*/
    %token INTEGER REAL  /*两种类型名：整型、实型*/
    %token 
      COMMA COLON SEMICOLON LPAREN RPAREN PERIOD /* 符号 , : ; ( ) . */
      PROGRAM BEGINN END VAR IF WHILE DO   /* 关键字：PROGRAM BEGIN END VAR IF WHILE Do */
      /* 想想为什么不声明为BEGIN？ */
      THEN ELSE /* 关键字：THEN ELSE */
      ASSIGN EQ NEQ LT LE GT GE /* 符号 :=	 =  <>  <  <=  >  >= */
      PLUS MINUS TIMES DIVIDE /* 符号 + = * / */
     
    %start program /* 开始符号为program */
    
    %type <progv> program 
    %type <decv> blsm 
    %type <declv> blsmb 
    %type <tttypev> lx 
    %type <varlv> blb 
    %type <stmv> whileyj tjyj fzyj yj 
    %type <stmsv> yjb fhyj  
    %type <expv> cs ssbds x ys 
    %type <bexpv> gxbds 
    %type <bopv> gxf  
    %type <idv> bl 
    
    %debug /* 允许跟踪错误 */
    
    %nonassoc LOWER_THAN_COMMA
    %nonassoc COMMA
    %nonassoc LOWER_THAN_SEMICOLON
    %nonassoc SEMICOLON
    
    %%
    
    program : PROGRAM ID SEMICOLON VAR blsmb BEGINN yjb END PERIOD    {program = A_Prog(EM_tokPos,$2,$5,$7);}
       ;
        
    blsmb : blsm   {$$ = A_DecList($1,NULL);}
          | blsm blsmb   {$$ = A_DecList($1,$2);}
          ;
    
    blsm : blb COLON lx SEMICOLON    {$$ =A_VarDec(EM_tokPos,$1,$3);}
         ;
          
    lx : INTEGER   {$$ = T_int;}
       | REAL      {$$ = T_real;}
       ;
       
    blb : bl %prec LOWER_THAN_COMMA   {$$ = A_VarList($1,NULL);}
        | bl COMMA blb   {$$ = A_VarList($1,$3);}
        ;     
        
    yjb : yj %prec LOWER_THAN_SEMICOLON   {$$ = A_StmList($1,NULL);}
        | yj SEMICOLON yjb   {$$ = A_StmList($1,$3);}
        ;
        
    yj : fzyj   {$$ = $1;}
       | tjyj   {$$ = $1;}
       | whileyj {$$ = $1;} 
       | fhyj   {$$ = A_Seq(EM_tokPos,$1);}
       ;
       
    fzyj : bl ASSIGN ssbds  {$$ = A_Assign(EM_tokPos,$1,$3);}
         ;
         
    tjyj : IF gxbds THEN yj ELSE yj   {$$ = A_If(EM_tokPos,$2,$4,$6);}
         ;
         
    whileyj : WHILE gxbds DO yj   {$$ = A_While(EM_tokPos,$2,$4);}
            ;
         
    fhyj : BEGINN yjb END  {$$ = $2 ;}
         ;
         
    ssbds : x     {$$ = $1;}
          | ssbds PLUS x   {$$ = A_OpExp(EM_tokPos,A_plusOp,$1,$3);}
          | ssbds MINUS x   {$$ = A_OpExp(EM_tokPos,A_minusOp,$1,$3);}
          ;
          
    x : ys  {$$ = $1;}   
      | x TIMES ys   {$$ = A_OpExp(EM_tokPos,A_timesOp,$1,$3);}
      | x DIVIDE ys   {$$ = A_OpExp(EM_tokPos,A_divideOp,$1,$3);}
      ;
      
    ys : bl  {$$ = A_VarExp(EM_tokPos,$1);}
       | cs   {$$ = $1;}
       | LPAREN ssbds RPAREN  {$$ = $2;}
       ;
       
    gxbds : ssbds gxf ssbds    {$$ = A_BExp(EM_tokPos,$2,$1,$3);}
          ; 
        
    cs : INT   {$$ = A_IntExp(EM_tokPos,$1);}
       | FLOAT  {$$ = A_RealExp(EM_tokPos,$1);}
       ;
       
    bl : ID   {$$ = A_Id(EM_tokPos,$1);}
       ;
       
    gxf : EQ  {$$ = A_eqOp;}
        | NEQ  {$$ = A_neqOp;}
        | LT   {$$ = A_ltOp;}
        | LE   {$$ = A_leOp;}
        | GT   {$$ = A_gtOp;}
        | GE    {$$ = A_geOp;}
        ;

（8）parsetest.c

/* 本文件是语法分析器的主控程序 */
    #include <stdio.h>
    #include "ast.h"
    #include "errormsg.h"
    #include "prast.h"
    
    
    extern int yyparse(void);//yacc生成的语法分析驱动程序
    extern a_prog program;//program的分析树存放于此
    extern FILE * yyout;
    
    /* 语法分析函数，如果分析成功，返回语法分析树；分析失败，返回NULL。
     * 参数：输入文件名fname，输出文件名output，
     * 返回值：语法分析树 
     */
    a_prog parse(string fname, string output) {  
    	int yy ;
    	EM_reset(fname, output);
    	//EM_yydebug();/*将本行注释去掉则运行时进入错误跟踪状态。*/
    	yy = yyparse();
      if (yy == 0) {/* parsing worked */
     	  printf("\nParse Successful!\n");
        return program;
      }
      else return NULL;
    }
    
    
    int main(int argc, char **argv) {
    	int i;
    	a_prog prog; //prog存放program的分析树。
    	/* 若缺少参数，则显示使用方法。*/
     	if ((argc!=2)&&(argc!=3)) {fprintf(stderr,"usage: a.exe inputfile [outputfile]\n"); exit(1);}
     	/* 若只有输入文件，则输出显示在屏幕上 */
     	else if (argc == 2){
     		printf("\nParsing begin: %s\n", argv[1]);
     		prog = parse(argv[1], "");
     		pr_prog(yyout, prog); //pr_prog是将program分析树打印出来的函数。
     		printf("\nParsing end: %s\n", argv[1]);
     	} else { /* 输入、输出文件齐全的情况 */
     	  printf("\nParsing begin: %s\n", argv[1]);
     		prog = parse(argv[1], argv[2]);
     		pr_prog(yyout, prog);
     		printf("Parsing end: %s\n", argv[1]);
    	}
     	
     	return 0;
    }

（9）prast.c

/* 本文件定义各个数据结构的打印操作 */
    
    #include <stdio.h>
    #include "ast.h"
    #include "prast.h" /* function prototype */
    
    
    static void indent(FILE *out, int d);
    static void pr_id(FILE *out, a_id id, int d);
    static void pr_op(FILE *out, a_op d);
    static void pr_bop(FILE *out, a_bop d);
    static void pr_ty(FILE *out, ttype d);
    static void pr_exp(FILE *out, a_exp v, int d);
    static void pr_bexp(FILE * out, a_bexp v, int d);
    static void pr_stm(FILE *out, a_stm v, int d); 
    static void pr_stmList(FILE *out, a_stm_list v, int d);
    static void pr_varList(FILE *out, a_var_list v, int d);
    static void pr_decList(FILE *out, a_dec_list v, int d);
    static void pr_dec(FILE *out, a_dec v, int d);
    
    /* 打印长度为d的空格 */
    static void indent(FILE *out, int d) {
     int i;
     for (i = 0; i <= d; i++) fprintf(out, " ");
    }
    
    /* 打印id */
    static void pr_id(FILE *out, a_id id, int d) {
    	indent(out, d);
    	fprintf(out, "VAR(%s)", id->val); 
    }
    
    
    static char str_op[][10] = {
       "PLUS", "MINUS", "TIMES", "DIVIDE" 
    };
    
    static char str_bop[][10] = {
       "EQUAL", "NOTEQUAL", "LESSTHAN", "LESSEQ", "GREATTHAN", "GREATEQ"
    };
    
    static char str_ty[][10] = {
       "INTEGER", "REAL"
    };
    
    /* 打印二元算术运算操作符 */ 
    static void pr_op(FILE *out, a_op d) {
      fprintf(out, "%s", str_op[d]);
    }
    
    /* 打印二元布尔运算操作符 */
    static void pr_bop(FILE *out, a_bop d){
    	fprintf(out, "%s", str_bop[d]);
    }
    
    /* 打印类型 */
    static void pr_ty(FILE *out, ttype d){
    	fprintf(out, "%s", str_ty[d]);
    }
    
    /* 打印算术表达式 */
    static void pr_exp(FILE *out, a_exp v, int d) {
     indent(out, d);
     switch (v->kind) {
     case A_varExp:
       fprintf(out, "varExp(\n"); pr_id(out, v->exp.var, d+1); 
       fprintf(out, "%s", ")");
       break;
     case A_intExp:
       fprintf(out, "intExp(%d)", v->exp.ival);
       break;
     case A_realExp:
       fprintf(out, "realExp(%f)", v->exp.fval);
       break;
     case A_opExp:
       fprintf(out, "opExp(\n");
       indent(out, d+1); pr_op(out, v->exp.biopExp.op); fprintf(out, ",\n"); 
       pr_exp(out, v->exp.biopExp.left, d+1); fprintf(out, ",\n"); 
       pr_exp(out, v->exp.biopExp.right, d+1); fprintf(out, ")");
       break;
      default:
       assert(0); 
    	}
    }	
    
    /* 打印布尔表达式 */
    static void pr_bexp(FILE * out, a_bexp v, int d){
    	indent(out, d);
    	fprintf(out, "BExp(\n");
      indent(out, d+1); pr_bop(out, v->bexp.bop); fprintf(out, ",\n"); 
      pr_exp(out, v->bexp.left, d+1); fprintf(out, ",\n"); 
      pr_exp(out, v->bexp.right, d+1); fprintf(out, ")");
    } 	 	 	
    
    /* 打印语句 */
    static void pr_stm(FILE *out, a_stm v, int d) {
    	indent(out, d);
     	switch (v->kind) {
     	case A_assign:
      	fprintf(out, "assignStm(\n");
       	pr_id(out, v->stm.assign.var, d+1); fprintf(out, ",\n");
       	pr_exp(out, v->stm.assign.exp, d+1); fprintf(out, ")");
       	break;
     	case A_if:
       	fprintf(out, "ifStm(\n");
       	pr_bexp(out, v->stm.iff.b, d+1); fprintf(out, ",\n");
       	pr_stm(out, v->stm.iff.s1, d+1);
       	if (v->stm.iff.s2) { /* else is optional */
          fprintf(out, ",\n");
          pr_stm(out, v->stm.iff.s2, d+1);
       	}
       	fprintf(out, ")");
       	break;
     	case A_while:
       	fprintf(out, "whileStm(\n");
       	pr_bexp(out, v->stm.whilee.b, d+1); fprintf(out, ",\n");
       	pr_stm(out, v->stm.whilee.s, d+1); fprintf(out, ")\n");
       	break;
     	case A_seq:
     		fprintf(out, "seqStm(\n");
       	pr_stmList(out, v->stm.seq, d+1); fprintf(out, ")");
     		break;
     	default:
       	assert(0); 
    	}
    }
    
    /* 打印语句列表 */
    static void pr_stmList(FILE *out, a_stm_list v, int d) {
    	indent(out, d);
     	if (v) {
       	fprintf(out, "stmList(\n"); 
       	pr_stm(out, v->head, d+1); fprintf(out, ",\n");
       	pr_stmList(out, v->tail, d+1);
       	fprintf(out, ")");
     	} else fprintf(out, "stmList()"); 
    }
    
    /* 打印变量列表 */
    static void pr_varList(FILE *out, a_var_list v, int d) {
     	indent(out, d);
     	if (v) {
       	fprintf(out, "varList(\n"); 
       	pr_id(out, v->head, d+1); fprintf(out, ",\n");
       	pr_varList(out, v->tail, d+1);
       	fprintf(out, ")");
     	} else fprintf(out, "varList()"); 
    
    }
    
    /* 打印变量声明列表 */
    static void pr_decList(FILE *out, a_dec_list v, int d) {
     	indent(out, d);
     	if (v) {
       	fprintf(out, "decList(\n"); 
       	pr_dec(out, v->head, d+1); fprintf(out, ",\n");
       	pr_decList(out, v->tail, d+1);
       	fprintf(out, ")");
     	} else fprintf(out, "decList()"); 
    
    }
    
    /* 打印变量声明 */
    static void pr_dec(FILE *out, a_dec v, int d) {
     	indent(out, d);
      fprintf(out, "varDec(\n");
      indent(out, d+1);
      fprintf(out, "TType(");
      pr_ty(out, v->type); 
      fprintf(out, ")"); fprintf(out, ",\n");
      pr_varList(out, v->varlist, d+1);
      fprintf(out, ")");
    }
    
    
    /* 打印程序数据结构 */
    void pr_prog(FILE *out, a_prog v){
    	if(v){
    		fprintf(out, "Prog(\n");
    		indent(out, 1); fprintf(out, "ProgName(%s)\n", v->name);
    		pr_decList(out, v->declist, 1);
    		fprintf(out, ",\n");
    		pr_stmList(out, v->stmlist, 1);
    		fprintf(out, ")");
    	} else fprintf(out, "Prog()");
    }

（10）prast.h

void pr_prog(FILE *out, a_prog v);

（11）util.c

/*
     * util.c - commonly used utility functions.
     */
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include "util.h"
    
    /* 检查并分配长度为len的内存空间，然后返回这块内存空间的指针 */
    void *checked_malloc(int len)
    {void *p = malloc(len);
     if (!p) {
        fprintf(stderr,"\nRan out of memory!\n");
        exit(1);
     }
     return p;
    }
    
    /* 将串s重新拷贝一份并返回。返回的串具有自己的内存空间。*/
    string String(char *s)
    {string p = checked_malloc(strlen(s)+1);
     strcpy(p,s);
     return p;
    }

（12）util.h

#include <assert.h>
    
    typedef char *string; 
    typedef char bool;
    
    #define TRUE 1
    #define FALSE 0
    
    void *checked_malloc(int);
    string String(char *);

[Center]: /images/20220731/a10b0a2e23e84ed4ba60c704f6e605c0.png