编译原理课设参考

   1 /*** PL0 COMPILER WITH CODE GENERATION ***/
   2 /**
   3  * 时间2015/12/28 22:35 
   4  * 添加 前++ 后++ 前-- 后--
   5  * 
   6  */
   7 //---------------------------------------------------------------------------
   8 #include <vcl.h>
   9 #pragma hdrstop
  10 #include "Unit1.h"
  11 //---------------------------------------------------------------------------
  12 #pragma package(smart_init)
  13 #pragma resource "*.dfm"
  14 TForm1 *Form1;
  15 //---------------------------------------------------------------------------
  16 const  AL    =  10;  /* LENGTH OF IDENTIFIERS */
  17 const  NORW  =  24;  /* # OF RESERVED WORDS */
  18 const  TXMAX = 100;  /* LENGTH OF IDENTIFIER TABLE */
  19 const  NMAX  =  14;  /* MAX NUMBER OF DEGITS IN NUMBERS */
  20 const  AMAX  =2047;  /* MAXIMUM ADDRESS */
  21 const  LEVMAX=   3;  /* MAX DEPTH OF BLOCK NESTING */
  22 const  CXMAX = 200;  /* SIZE OF CODE ARRAY */
  23 int SYMMAX = 53;//记录SYMBOL元素个数，原为33
  24 typedef enum  { NUL, IDENT, NUMBER, PLUS, MINUS, TIMES,
  25                 SLASH, ODDSYM, EQL, NEQ, LSS, LEQ, GTR, GEQ,
  26                 LPAREN, RPAREN, COMMA, SEMICOLON, PERIOD,
  27                 BECOMES, BEGINSYM, ENDSYM, IFSYM, THENSYM,
  28                 WHILESYM, WRITESYM, READSYM, DOSYM, CALLSYM,
  29                 CONSTSYM, VARSYM, PROCSYM,PROGSYM,
  30                 /*添加字符  & || !*/
  31                 AND,OR,NOT,
  32                 /*添加运算符 += -= *= /= ++ -- */
  33                 PLUSBECOMES,MINUSBECOMES,MEQ,DEQ,DPLUS,DMINUS,
  34                 //关键字
  35                 ELSESYM,FORSYM,STEPSYM,UNTILSYM,RETURNSYM,
  36                 /*添加类型 */
  37                 OFSYM,INTSYM, CHARSYM, REALSYM,
  38                 //左右方括号
  39                 LBK,RBK
  40               } SYMBOL;
  41 char *SYMOUT[] = {"NUL", "IDENT", "NUMBER", "PLUS", "MINUS", "TIMES",
  42                   "SLASH", "ODDSYM", "EQL", "NEQ", "LSS", "LEQ", "GTR", "GEQ",
  43                   "LPAREN", "RPAREN", "COMMA", "SEMICOLON", "PERIOD",
  44                   "BECOMES", "BEGINSYM", "ENDSYM", "IFSYM", "THENSYM",
  45                   "WHILESYM", "WRITESYM", "READSYM", "DOSYM", "CALLSYM",
  46                   "CONSTSYM", "VARSYM", "PROCSYM", "PROGSYM",
  47                   /*添加字符  & || !*/
  48                   "AND","OR","NOT",
  49                   /*添加运算符 += -= *= /= ++ -- */
  50                   "PLUSBECOMES","MINUSBECOMES","MEQ","DEQ","DPLUS","DMINUS",
  51                   //关键字
  52                   "ELSESYM","FORSYM", "STEPSYM","UNTILSYM","RETURNSYM",
  53                    /*添类型*/
  54                    "OFSYM","INTSYM","CHARSYM","REALSYM",
  55                    //左右方括号
  56                    "LBK","RBK"
  57                  };
  58 typedef  int *SYMSET; // SET OF SYMBOL;
  59 typedef  char ALFA[11];
  60 typedef  enum { CONSTANT, VARIABLE, PROCEDUR,ARRAY} OBJECTS ;
  61 typedef  enum { LIT, OPR, LOD, STO, CAL, INI, JMP, JPC,
  62                 GAR, TAR, DEL, SAR, JUD} FCT;
  63 typedef struct
  64 {
  65     FCT F;     /*FUNCTION CODE*/
  66     int L;  /*0..LEVMAX  LEVEL*/
  67     float A;     /*0..AMAX    DISPLACEMENT ADDR*/ //int
  68 } INSTRUCTION;
  69 /* LIT O A -- LOAD CONSTANT A             */
  70 /* OPR 0 A -- EXECUTE OPR A               */
  71 /* LOD L A -- LOAD VARIABLE L,A           */
  72 /* STO L A -- STORE VARIABLE L,A          */
  73 /* CAL L A -- CALL PROCEDURE A AT LEVEL L */
  74 /* INI 0 A -- INCREMET T-REGISTER BY A    */
  75 /* JMP 0 A -- JUMP TO A                   */
  76 /* JPC 0 A -- JUMP CONDITIONAL TO A       */
  77 char   CH;  /*LAST CHAR READ*/
  78 SYMBOL SYM; /*LAST SYMBOL READ*/
  79 ALFA   ID;  /*LAST IDENTIFIER READ*/
  80 float    NUM; /*LAST NUMBER READ*/       //int
  81 int    CC;  /*CHARACTER COUNT*/
  82 int    LL;  /*LINE LENGTH*/
  83 int    CX;  /*CODE ALLOCATION INDEX*/
  84 char   LINE[81];
  85 
  86 //记录数组的大小
  87 float ARRYSIZE;
  88 INSTRUCTION  CODE[CXMAX];
  89 ALFA    KWORD[NORW+1];
  90 SYMBOL  WSYM[NORW+1];
  91 SYMBOL  SSYM[‘^‘+1];
  92 ALFA    MNEMONIC[9];
  93 SYMSET  DECLBEGSYS, STATBEGSYS, FACBEGSYS;
  94 //类型
  95 typedef enum { CHARCON, INTCON, REALCON, NOTYP} TYPES;
  96 TYPES TY;   //记录类型
  97 struct
  98 {
  99     ALFA NAME;
 100     OBJECTS KIND;
 101     TYPES TYPE; //增加类型
 102     union
 103     {
 104         float VAL;   /*CONSTANT*/  //统一用浮点型记录  //int
 105         struct
 106         {
 107             int LEVEL,ADR,SIZE;
 108         } vp;  /*VARIABLE,PROCEDUR: 层次、地址、存储空间*/
 109     };
 110 } TABLE[TXMAX];
 111 
 112 FILE *FIN,*FOUT;
 113 int ERR;
 114 void EXPRESSION(SYMSET FSYS, int LEV, int &TX);
 115 void TERM(SYMSET FSYS, int LEV, int &TX);
 116 //---------------------------------------------------------------------------
 117 int SymIn(SYMBOL SYM, SYMSET S1)
 118 {
 119     return S1[SYM];
 120 }
 121 //---------------------------------------------------------------------------
 122 SYMSET SymSetUnion(SYMSET S1, SYMSET S2)
 123 {
 124     SYMSET S=(SYMSET)malloc(sizeof(int)*SYMMAX);
 125     for (int i=0; i<SYMMAX; i++)
 126         if (S1[i] || S2[i]) S[i]=1;
 127         else S[i]=0;
 128     return S;
 129 }
 130 //---------------------------------------------------------------------------
 131 SYMSET SymSetAdd(SYMBOL SY, SYMSET S)
 132 {
 133     SYMSET S1;
 134     S1=(SYMSET)malloc(sizeof(int)*SYMMAX);
 135     for (int i=0; i<SYMMAX; i++) S1[i]=S[i];
 136     S1[SY]=1;
 137     return S1;
 138 }
 139 //---------------------------------------------------------------------------
 140 SYMSET SymSetNew(SYMBOL a)
 141 {
 142     SYMSET S;
 143     int i,k;
 144     S=(SYMSET)malloc(sizeof(int)*SYMMAX);
 145     for (i=0; i<SYMMAX; i++) S[i]=0;
 146     S[a]=1;
 147     return S;
 148 }
 149 //---------------------------------------------------------------------------
 150 SYMSET SymSetNew(SYMBOL a, SYMBOL b)
 151 {
 152     SYMSET S;
 153     int i,k;
 154     S=(SYMSET)malloc(sizeof(int)*SYMMAX);
 155     for (i=0; i<SYMMAX; i++) S[i]=0;
 156     S[a]=1;
 157     S[b]=1;
 158     return S;
 159 }
 160 //---------------------------------------------------------------------------
 161 SYMSET SymSetNew(SYMBOL a, SYMBOL b, SYMBOL c)
 162 {
 163     SYMSET S;
 164     int i,k;
 165     S=(SYMSET)malloc(sizeof(int)*SYMMAX);
 166     for (i=0; i<SYMMAX; i++) S[i]=0;
 167     S[a]=1;
 168     S[b]=1;
 169     S[c]=1;
 170     return S;
 171 }
 172 //---------------------------------------------------------------------------
 173 SYMSET SymSetNew(SYMBOL a, SYMBOL b, SYMBOL c, SYMBOL d)
 174 {
 175     SYMSET S;
 176     int i,k;
 177     S=(SYMSET)malloc(sizeof(int)*SYMMAX);
 178     for (i=0; i<SYMMAX; i++) S[i]=0;
 179     S[a]=1;
 180     S[b]=1;
 181     S[c]=1;
 182     S[d]=1;
 183     return S;
 184 }
 185 //---------------------------------------------------------------------------
 186 SYMSET SymSetNew(SYMBOL a, SYMBOL b, SYMBOL c, SYMBOL d,SYMBOL e)
 187 {
 188     SYMSET S;
 189     int i,k;
 190     S=(SYMSET)malloc(sizeof(int)*SYMMAX);
 191     for (i=0; i<SYMMAX; i++) S[i]=0;
 192     S[a]=1;
 193     S[b]=1;
 194     S[c]=1;
 195     S[d]=1;
 196     S[e]=1;
 197     return S;
 198 }
 199 //---------------------------------------------------------------------------
 200 SYMSET SymSetNew(SYMBOL a, SYMBOL b, SYMBOL c, SYMBOL d,SYMBOL e, SYMBOL f)
 201 {
 202     SYMSET S;
 203     int i,k;
 204     S=(SYMSET)malloc(sizeof(int)*SYMMAX);
 205     for (i=0; i<SYMMAX; i++) S[i]=0;
 206     S[a]=1;
 207     S[b]=1;
 208     S[c]=1;
 209     S[d]=1;
 210     S[e]=1;
 211     S[f]=1;
 212     return S;
 213 }
 214 //---------------------------------------------------------------------------
 215 SYMSET SymSetNULL()
 216 {
 217     SYMSET S;
 218     int i,n,k;
 219     S=(SYMSET)malloc(sizeof(int)*SYMMAX);
 220     for (i=0; i<SYMMAX; i++) S[i]=0;
 221     return S;
 222 }
 223 //---------------------------------------------------------------------------
 224 void Error(int n)
 225 {
 226     String s = "***"+AnsiString::StringOfChar(‘ ‘, CC-1)+"^";
 227     Form1->printls(s.c_str(),n);
 228     fprintf(FOUT,"%s%d\n", s.c_str(), n);
 229     ERR++;
 230 } /*Error*/
 231 //---------------------------------------------------------------------------
 232 void GetCh()
 233 {
 234      if (CC==LL)                /*如果缓冲区读完*/
 235     {
 236         if (feof(FIN))   //检查文件是否结束 结束返回非零值 否则返回0
 237         {
 238             Form1->printfs("PROGRAM INCOMPLETE");
 239             fprintf(FOUT,"PROGRAM INCOMPLETE\n");
 240             fclose(FOUT);
 241             exit(0);
 242         }
 243         LL=0;CC=0;   //line length
 244         CH=‘ ‘;
 245         
 246         //s1为注释内容所用的数组，s为每一行所要执行内容所用的数组
 247         String s1 = "注释：";
 248 
 249         while (!feof(FIN) && CH!=10)
 250         //文件未结束或者没遇到换行符
 251         {
 252             CH=fgetc(FIN);
 253             //--------------------课设---------------
 254             if(CH==‘/‘)
 255             {
 256                 CH=getc(FIN);
 257                 if(CH==‘*‘)
 258                 {  //判断是否出现/*  */字段，若是则将其读进一个数组s1里面去 并且略去/**/
 259                     while(!feof(FIN))
 260                     {
 261                         CH=getc(FIN);
 262                         if(CH==‘*‘ && (CH=getc(FIN))==‘/‘)
 263                         {
 264                                 Form1->printfs(s1.c_str());
 265                                 fprintf(FOUT,"%s\n",s1);
 266                                 break;
 267                         }
 268                         //将字符加入到s1数组中
 269                         s1 = s1 + CH;
 270                     }
 271                     continue;
 272                 }
 273                 else
 274                     LINE[LL++] = ‘/‘; //若是没有/**/则将/补回去
 275             }
 276             LINE[LL++]=CH; //将从文件中读取的字符存储在数组line中
 277         }
 278         LINE[LL-1]=‘ ‘;
 279         LINE[LL]=0;
 280         if(s1.Length()==6)
 281         {
 282             //因为"注释："为6个字符时表示没读到注释掉的语句，所以需要判断
 283             String s=IntToStr(CX);
 284             while(s.Length()<3) s=" "+s;
 285             s=s+" "+LINE;
 286             Form1->printfs(s.c_str());
 287             fprintf(FOUT,"%s\n",s);
 288         }
 289     }
 290     CH=LINE[CC++];      //将当前第一个读取到的字符赋值给ch；字符数+1；
 291 } /*GetCh()*/
 292 //---------------------------------------------------------------------------
 293 void GetSym()
 294 {
 295     int i,J,K;
 296     ALFA  A;
 297     while (CH<=‘ ‘) GetCh();
 298     if (CH>=‘A‘ && CH<=‘Z‘)   /*ID OR RESERVED WORD*/
 299     {
 300         K=0;
 301         do
 302         {
 303             if (K<AL) A[K++]=CH;
 304             GetCh();
 305         }
 306         while((CH>=‘A‘ && CH<=‘Z‘)||(CH>=‘0‘ && CH<=‘9‘));
 307         A[K]=‘\0‘;
 308         strcpy(ID,A);
 309         i=1;
 310         J=NORW;
 311         do
 312         {
 313             K=(i+J) / 2;
 314             if (strcmp(ID,KWORD[K])<=0) J=K-1;
 315             if (strcmp(ID,KWORD[K])>=0) i=K+1;
 316         }
 317         while(i<=J);
 318         if (i-1 > J) SYM=WSYM[K];
 319         else SYM=IDENT;
 320     }
 321     else if (CH>=‘0‘ && CH<=‘9‘)  /*NUMBER*/
 322     {
 323         K=0;
 324         NUM=0;
 325         SYM=NUMBER;
 326         TY=INTCON;      //add-----------
 327         float count=10;        //add-----------
 328         do
 329         {
 330             if(CH==‘.‘){    //实数
 331                 GetCh();  
 332                 TY=REALCON;
 333                 while(CH>=‘0‘ && CH<=‘9‘){
 334                      NUM=NUM+(CH-‘0‘)/count;
 335                      K++;
 336                      count*=10;
 337                      GetCh();
 338                 }
 339                 break;
 340             }
 341             else{   //整数
 342                 NUM=10*NUM+(CH-‘0‘);
 343                 K++;
 344                 GetCh();
 345             }
 346 
 347         }
 348         while(CH>=‘0‘ && CH<=‘9‘||CH==‘.‘);
 349         if (K>NMAX) Error(30);
 350     }
 351     else if((int)CH==39)  //对应‘号  可输入一个字符
 352     {
 353         SYM = NUMBER;
 354         GetCh();
 355         if((CH>=‘A‘ && CH<=‘Z‘)||(CH>=‘a‘ && CH<=‘z‘))
 356         {
 357              NUM=(int)CH;
 358              GetCh();
 359              if((int)CH==39)
 360                 TY=CHARCON;
 361              else {
 362                 NUM=0;
 363                 SYM=NUL;
 364                 Error(49);
 365              }  //类型错误
 366         } else Error(49); //类型不匹配
 367         GetCh();
 368     }
 369     else if (CH==‘:‘)
 370     {
 371         GetCh();
 372         if (CH==‘=‘)
 373         {
 374             SYM=BECOMES;
 375             GetCh();
 376         }
 377         else SYM=OFSYM;
 378     }
 379     else /* THE FOLLOWING TWO CHECK WERE ADDED
 380              BECAUSE ASCII DOES NOT HAVE A SINGLE CHARACTER FOR <= OR >= */
 381         if (CH==‘<‘)
 382         {
 383             GetCh();
 384             if (CH==‘=‘)
 385             {
 386                 SYM=LEQ;
 387                 GetCh();
 388             }
 389             else if(CH==‘>‘)
 390             {
 391                 SYM=NEQ;
 392                 GetCh();
 393             }
 394             else SYM=LSS;
 395         }
 396         else if (CH==‘>‘)
 397         {
 398             GetCh();
 399             if (CH==‘=‘)
 400             {
 401                 SYM=GEQ;
 402                 GetCh();
 403             }
 404             else SYM=GTR;
 405         }
 406     /*课设*/
 407         else if(CH==‘+‘)
 408         {
 409             GetCh();
 410             if(CH==‘+‘)
 411             {
 412                 SYM=DPLUS;
 413                 GetCh();
 414             }
 415             else if(CH==‘=‘)
 416             {
 417                 SYM=PLUSBECOMES;
 418                 GetCh();
 419             }
 420 
 421             else SYM=PLUS;
 422         }
 423         else if(CH==‘-‘)
 424         {
 425             GetCh();
 426             if(CH==‘=‘)
 427             {
 428                 SYM=MINUSBECOMES;
 429                 GetCh();
 430             }
 431             else if(CH==‘-‘)
 432             {
 433                 SYM=DMINUS;
 434                 GetCh();
 435             }
 436             else SYM=MINUS;
 437         }
 438         else if(CH==‘*‘)
 439         {
 440             GetCh();
 441             if(CH==‘=‘)
 442             {
 443                 SYM=MEQ;
 444                 GetCh();
 445             }
 446             else SYM=TIMES;
 447         }
 448         else if(CH==‘/‘)
 449         {
 450             GetCh();
 451             if(CH==‘=‘)
 452             {
 453                 SYM=DEQ;
 454                 GetCh();
 455             }
 456             else
 457                 SYM=SLASH;
 458         }
 459         else if(CH==‘|‘)
 460         {
 461             GetCh();
 462             if(CH==‘|‘)
 463             {
 464                 SYM=OR;
 465                 GetCh();
 466             }
 467             else
 468                 Error(11);
 469         }
 470         else
 471         {
 472             SYM=SSYM[CH];
 473             GetCh();
 474         }
 475 } /*GetSym()*/
 476 //---------------------------------------------------------------------------
 477 //修改 Z int -> float
 478 void GEN(FCT X, int Y, float Z)
 479 {
 480     if (CX>CXMAX)
 481     {
 482         Form1->printfs("PROGRAM TOO LONG");
 483         fprintf(FOUT,"PROGRAM TOO LONG\n");
 484         fclose(FOUT);
 485         exit(0);
 486     }
 487     CODE[CX].F=X;
 488     CODE[CX].L=Y;
 489     CODE[CX].A=Z;
 490     CX++;
 491 } /*GEN*/
 492 //---------------------------------------------------------------------------
 493 void TEST(SYMSET S1, SYMSET S2, int N)
 494 {
 495     if (!SymIn(SYM,S1))
 496     {
 497         Error(N);
 498         while (!SymIn(SYM,SymSetUnion(S1,S2))) GetSym();
 499     }
 500 } /*TEST*/
 501 //---------------------------------------------------------------------------
 502 void ENTER(OBJECTS K, int LEV, int &TX, int &DX)   /*ENTER OBJECT INTO TABLE*/
 503 {
 504     TX++;
 505     strcpy(TABLE[TX].NAME,ID);
 506     TABLE[TX].KIND=K;
 507     switch (K)
 508     {
 509     case CONSTANT:
 510         if (NUM>AMAX)
 511         {
 512             Error(31);
 513             NUM=0;
 514         }
 515         TABLE[TX].VAL=NUM;
 516         break;
 517     case VARIABLE:
 518         TABLE[TX].vp.LEVEL=LEV;
 519         TABLE[TX].vp.ADR=DX;
 520         TABLE[TX].vp.SIZE = 0;
 521         DX++;
 522         break;
 523     case PROCEDUR:
 524         TABLE[TX].vp.LEVEL=LEV;
 525         break;
 526 
 527     case ARRAY: /*数组名字 加到TABLE表中*/
 528         TABLE[TX].vp.LEVEL=LEV;
 529         TABLE[TX].vp.ADR=DX-ARRYSIZE;
 530         TABLE[TX].vp.SIZE=ARRYSIZE;
 531         break;
 532     }
 533 } /*ENTER*/
 534 //---------------------------------------------------------------------------
 535 int POSITION(ALFA ID, int TX)   /*FIND IDENTIFIER IN TABLE*/
 536 {
 537     int i=TX;
 538     strcpy(TABLE[0].NAME,ID);
 539     while (strcmp(TABLE[i].NAME,ID)!=0) i--;
 540     return i;
 541 } /*POSITION*/
 542 //---------------------------------------------------------------------------
 543 void ConstDeclaration(int LEV,int &TX,int &DX)
 544 {
 545     if (SYM==IDENT)
 546     {
 547         GetSym();
 548         if (SYM==EQL||SYM==BECOMES)
 549         {
 550             if (SYM==BECOMES) Error(1);
 551             GetSym();
 552             if (SYM==NUMBER)
 553             {
 554                 ENTER(CONSTANT,LEV,TX,DX);
 555                 GetSym();
 556             }
 557             else Error(2);
 558         }
 559         else Error(3);
 560     }
 561     else Error(4);
 562 } /*ConstDeclaration()*/
 563 //---------------------------------------------------------------------------
 564 void VarDeclaration(int LEV,int &TX,int &DX)
 565 {
 566     int i;
 567     char IDTEMP[AL+1];//临时保存数组名?
 568     if (SYM==IDENT)
 569     {
 570         ALFA ID0;
 571         strcpy(ID0, ID);
 572         strcpy(IDTEMP,ID);
 573         GetSym();
 574         if (SYM==COMMA)
 575         {
 576             GetSym();
 577             VarDeclaration(LEV,TX,DX);
 578         }
 579         if(SYM == OFSYM)         //声明变量类型
 580         {
 581             GetSym();
 582             switch(SYM)
 583             {
 584             case CHARSYM:
 585                 TY = CHARCON;
 586                 break;
 587             case INTSYM:
 588                 TY = INTCON;
 589                 break;
 590             case REALSYM:
 591                 TY = REALCON;
 592                 break;
 593             default:
 594                 Error(52);
 595             }
 596             GetSym();
 597             strcpy(ID, ID0);
 598             ENTER(VARIABLE,LEV,TX,DX);
 599             TABLE[TX].TYPE = TY;
 600         }
 601         else if(SYM==LBK)//数组的左中括号
 602         {
 603             GetSym();
 604             if(SYM==NUMBER)//a[]中的中括号里是数字的话
 605             {
 606                 DX=DX+NUM;//为数组分配空间
 607                 ARRYSIZE=NUM;//保存数组的长度
 608             }
 609             else
 610             {
 611                 if(SYM==IDENT)//a[]中的中括号里是变量的话
 612                 {
 613                     //要检查是不是以声明的常量
 614                     i=POSITION(ID,TX);//查找名字表
 615                     if(i==0)
 616                     {
 617                         Error(11);//标识符未说明
 618                     }
 619                     else
 620                     {
 621                         if(TABLE[i].KIND==CONSTANT)//标识符的属性是常量
 622                         {
 623                             DX=DX+TABLE[i].VAL;//为数组分配空间
 624                             ARRYSIZE=TABLE[i].VAL;//保存数组的长度
 625                         }
 626                         else
 627                         {
 628                             Error(25);//数组下标定义不符合规定，应为常量
 629                         }
 630                     }
 631                 }//if
 632                 else
 633                 {
 634                     Error(25);//数组下标定义不符合规定，应为常量
 635                 }
 636             }//else
 637             strcpy(ID,IDTEMP);//恢复数组名字id
 638             ENTER(ARRAY,TX,LEV,DX);//填写名字表
 639             GetSym();
 640             if(SYM!=RBK)//如果不是[结尾
 641             {
 642                 Error(26);
 643             }
 644             else
 645             {
 646                 GetSym();
 647             }
 648             if(SYM == OFSYM)         //声明变量类型
 649             {
 650                 GetSym();
 651                 switch(SYM)
 652                 {
 653                 case CHARSYM:
 654                     TY = CHARCON;
 655                     break;
 656                 case INTSYM:
 657                     TY = INTCON;
 658                     break;
 659                 case REALSYM:
 660                     TY = REALCON;
 661                     break;
 662                 default:
 663                     Error(52);
 664                 }
 665                 TABLE[TX].TYPE = TY;
 666                 GetSym();
 667             }
 668         }
 669         else Error(19);
 670     }
 671     else Error(4);
 672 } /*VarDeclaration()*/
 673 //---------------------------------------------------------------------------
 674 void ListCode(int CX0)    /*LIST CODE GENERATED FOR THIS Block*/
 675 {
 676     if (Form1->ListSwitch->ItemIndex==0)
 677         for (int i=CX0; i<CX; i++)
 678         {
 679             String s=IntToStr(i);
 680             while(s.Length()<3)s=" "+s;
 681             s=s+" "+MNEMONIC[CODE[i].F]+" "+IntToStr(CODE[i].L)+" "
 682             +IntToStr((int)CODE[i].A);
 683             Form1->printfs(s.c_str());
 684             fprintf(FOUT,"%3d%5s%4d%4d\n",i,MNEMONIC[CODE[i].F],CODE[i].L,CODE[i].A);
 685         }
 686 } /*ListCode()*/;
 687 //---------------------------------------------------------------------------
 688 void FACTOR(SYMSET FSYS, int LEV, int &TX)
 689 {
 690     int i;
 691     TEST(FACBEGSYS,FSYS,24);
 692     while (SymIn(SYM,FACBEGSYS))
 693     {
 694         if (SYM==IDENT)
 695         {
 696             i=POSITION(ID,TX);
 697             if (i==0) Error(11);
 698             else
 699             {
 700                 switch (TABLE[i].KIND)
 701                 {
 702                 case CONSTANT:
 703                     GEN(LIT,0,TABLE[i].VAL);
 704                     break;
 705                 case VARIABLE:
 706                     GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
 707                     break;
 708                 case PROCEDUR:
 709                     Error(21);
 710                     break;
 711                 case ARRAY:
 712                     GetSym();
 713                     if(SYM == LBK)
 714                     {
 715                         GetSym();
 716                         EXPRESSION(SymSetUnion(FSYS,SymSetNew(RBK)),LEV,TX);
 717                         if(SYM != RBK)
 718                         {
 719                             Error(44);
 720                         }
 721                         GEN(GAR,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
 722                     }
 723                     else Error(28);
 724                     break;
 725                 }
 726                 GetSym();
 727                 ////后++,后--
 728                 if(SYM==DPLUS||SYM==DMINUS)     //++或--
 729                 {
 730                     switch (TABLE[i].KIND)
 731                     {
 732                         case CONSTANT:
 733                             Error(36);
 734                             break;  //常量不能++或--
 735                         case VARIABLE:
 736                             GEN(LIT,0,1);
 737                             if(SYM==DPLUS)GEN(OPR,0,2); //++
 738                             else if(SYM==DMINUS)GEN(OPR,0,3);   //--
 739                             GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); //将栈顶送入变量单元
 740                             GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); //将变量送入栈顶
 741                             GetSym();
 742                             break;
 743                         case PROCEDUR:
 744                             Error(36);
 745                             break;
 746                     }//switch
 747                 }//if
 748                 else if(SYM==DPLUS||SYM==DMINUS)
 749                 {
 750                     if(SYM==DPLUS)  //前++
 751                     {
 752                         GetSym();
 753                         if(SYM==IDENT)
 754                         {
 755                             i=POSITION(ID,TX);
 756                             if (i==0) Error(11);
 757                             else if (TABLE[i].KIND!=VARIABLE)  /*ASSIGNMENT TO NON-VARIABLE*/
 758                             {
 759                                 Error(36);
 760                                 i=0;
 761                             }
 762                             if(i!=0)
 763                             {
 764                                 GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
 765                                 GEN(LIT,0,1);
 766                                 GEN(OPR,0,2);
 767                                 GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
 768                                 GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
 769                             }
 770                             GetSym();
 771                         }
 772                         else Error(36);
 773                     }//if
 774                     else    //前--
 775                     {
 776                         GetSym();
 777                         if(SYM==IDENT)
 778                         {
 779                             i=POSITION(ID,TX);
 780                             if (i==0) Error(11);
 781                             else if (TABLE[i].KIND!=VARIABLE)  /*ASSIGNMENT TO NON-VARIABLE*/
 782                             {
 783                                 Error(36);
 784                                 i=0;
 785                             }
 786                             if(i!=0)
 787                             {
 788                                 GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
 789                                 GEN(LIT,0,1);
 790                                 GEN(OPR,0,3);
 791                                 GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
 792                                 GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
 793                             }
 794                             GetSym();
 795                         }
 796                         else Error(36);
 797                     }//else
 798                 }//i
 799             }
 800             if(TABLE[i].TYPE > TY)
 801                 TY =  TABLE[i].TYPE;         //向高层的数据类型转
 802 
 803         }
 804         else if (SYM==NUMBER)
 805         {
 806             if (NUM>AMAX)
 807             {
 808                 Error(31);
 809                 NUM=0;
 810             }
 811             GEN(LIT,0,NUM);
 812             GetSym();
 813         }
 814         else if (SYM==LPAREN)
 815         {
 816             GetSym();
 817             EXPRESSION(SymSetAdd(RPAREN,FSYS),LEV,TX);
 818             if (SYM==RPAREN) GetSym();
 819             else Error(22);
 820         }
 821         TEST(FSYS,FACBEGSYS,23);
 822     }
 823 }/*FACTOR*/
 824 //---------------------------------------------------------------------------
 825 void TERM(SYMSET FSYS, int LEV, int &TX)    /*TERM*/
 826 {
 827     SYMBOL MULOP;
 828     FACTOR(SymSetUnion(FSYS,SymSetNew(TIMES,SLASH)), LEV,TX);
 829     while (SYM==TIMES || SYM==SLASH)
 830     {
 831         MULOP=SYM;
 832         GetSym();
 833         FACTOR(SymSetUnion(FSYS,SymSetNew(TIMES,SLASH)),LEV,TX);
 834         if (MULOP==TIMES) GEN(OPR,0,4);
 835         else GEN(OPR,0,5);
 836     }
 837 } /*TERM*/;
 838 //---------------------------------------------------------------------------
 839 void EXPRESSION(SYMSET FSYS, int LEV, int &TX)
 840 {
 841     SYMBOL ADDOP;
 842     if (SYM==PLUS || SYM==MINUS)
 843     {
 844         ADDOP=SYM;
 845         GetSym();
 846         TERM(SymSetUnion(FSYS,SymSetNew(PLUS,MINUS)),LEV,TX);
 847         if (ADDOP==MINUS) GEN(OPR,0,1);
 848     }
 849     else TERM(SymSetUnion(FSYS,SymSetNew(PLUS,MINUS)),LEV,TX);
 850     while (SYM==PLUS || SYM==MINUS)
 851     {
 852         ADDOP=SYM;
 853         GetSym();
 854         TERM(SymSetUnion(FSYS,SymSetNew(PLUS,MINUS)),LEV,TX);
 855         if (ADDOP==PLUS) GEN(OPR,0,2);
 856         else GEN(OPR,0,3);
 857     }
 858 } /*EXPRESSION*/
 859 //---------------------------------------------------------------------------
 860 void CONDITION(SYMSET FSYS,int LEV,int &TX)
 861 {
 862     SYMBOL RELOP;
 863     if (SYM==ODDSYM)
 864     {
 865         GetSym();
 866         EXPRESSION(FSYS,LEV,TX);
 867         GEN(OPR,0,6);
 868     }
 869     else
 870     {
 871         EXPRESSION(SymSetUnion(SymSetNew(EQL,NEQ,LSS,LEQ,GTR,GEQ),FSYS),LEV,TX);
 872         if (!SymIn(SYM,SymSetNew(EQL,NEQ,LSS,LEQ,GTR,GEQ))) Error(20);
 873         else
 874         {
 875             RELOP=SYM;
 876             GetSym();
 877             EXPRESSION(FSYS,LEV,TX);
 878             switch (RELOP)
 879             {
 880             case EQL:
 881                 GEN(OPR,0,8);
 882                 break;
 883             case NEQ:
 884                 GEN(OPR,0,9);
 885                 break;
 886             case LSS:
 887                 GEN(OPR,0,10);
 888                 break;
 889             case GEQ:
 890                 GEN(OPR,0,11);
 891                 break;
 892             case GTR:
 893                 GEN(OPR,0,12);
 894                 break;
 895             case LEQ:
 896                 GEN(OPR,0,13);
 897                 break;
 898             }
 899         }
 900     }
 901 } /*CONDITION*/
 902 //---------------------------------------------------------------------------
 903 int flag=0;
 904 void STATEMENT(SYMSET FSYS,int LEV,int &TX)     /*STATEMENT*/
 905 {
 906     int i,CX1,CX2;
 907     switch (SYM)
 908     {
 909     case IDENT:
 910         i=POSITION(ID,TX);
 911         if (i==0) Error(11);
 912         else if (TABLE[i].KIND==VARIABLE||TABLE[i].KIND==ARRAY)  /*ASSIGNMENT TO NON-VARIABLE*/
 913         {
 914             GetSym();
 915             if(SYM == LBK)
 916             {
 917                 GetSym();
 918                 EXPRESSION(SymSetUnion(SymSetNew(RBK),FSYS),LEV,TX);
 919                 if(SYM != RBK)
 920                 {
 921                     Error(44);
 922                 }
 923                 GetSym();
 924             }
 925         }
 926         else
 927         {
 928             Error(12);
 929             i=0;
 930         }
 931         if (SYM==BECOMES) {
 932                 GetSym();
 933                 TY = CHARCON;   //初始为字符型
 934                 EXPRESSION(FSYS,LEV,TX);//计算表达式的值
 935                 if (i!=0) {
 936                     if(TY > TABLE[i].TYPE)
 937                         Error(50);  //类型无法转换
 938                     GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
 939                 }
 940         }
 941         else if(SYM==DPLUS)     //语句中后++运算
 942         {
 943             if(i!=0)GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); //取变量
 944             GEN(LIT,0,1);   //常量取到栈顶
 945             GEN(OPR,0,2);
 946             if(i!=0)GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); //存变量
 947             GetSym();
 948         }
 949         else if(SYM==DMINUS)    //语句中后--运算
 950         {
 951             if(i!=0)GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
 952             GEN(LIT,0,1);
 953             GEN(OPR,0,3);
 954             if(i!=0)GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
 955             GetSym();
 956         }
 957         else if ( SYM==MEQ || SYM==DEQ || SYM==PLUSBECOMES || SYM==MINUSBECOMES )
 958          //添加处理加等、减等、乘等、除等
 959         {
 960             if (SYM==MEQ)
 961             {
 962                 flag = 1;
 963             }
 964             if (SYM==DEQ)
 965             {
 966                 flag = 2;
 967             }
 968             if (SYM==PLUSBECOMES)
 969             {
 970                 flag = 3;
 971             }
 972             if (SYM==MINUSBECOMES)
 973             { 
 974                 flag = 4;
 975             }
 976 
 977             if(TABLE[i].KIND==ARRAY)  //先把值存入栈
 978                 GEN(TAR,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
 979             else
 980                 GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
 981 
 982             GetSym();
 983             EXPRESSION(FSYS,LEV,TX);
 984              if (i!=0) {
 985                 switch (flag)
 986                 {
 987                     case 1:                                               //标记为1的时候处理乘法
 988                         GEN(OPR,0,4);
 989                         flag = 0;
 990                         break;
 991                     case 2:                                               //标记为2的时候处理除法
 992                         GEN(OPR,0,5);
 993                         flag = 0;
 994                         break;
 995                     case 3:                                               //标记为3的时候处理加法
 996                         GEN(OPR,0,2);
 997                         flag = 0;
 998                         break;
 999                     case 4:                                               //标记为4的时候处理减法
1000                         GEN(OPR,0,3);
1001                         flag = 0;
1002                         break;
1003                     default:
1004                         flag = 0;
1005                         break;
1006                 }
1007                 if(TABLE[i].KIND==ARRAY)
1008                     GEN(SAR,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1009                 else
1010                     GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1011              }
1012         }
1013         
1014         else Error(13);
1015         break;
1016     case READSYM:
1017         GetSym();
1018         if (SYM!=LPAREN) Error(34);
1019         else
1020             do
1021             {
1022                 GetSym();
1023                 if (SYM==IDENT)
1024                 {
1025                     i=POSITION(ID,TX);
1026                     if (TABLE[i].KIND==ARRAY)   /*ASSIGNMENT TO NON-VARIABLE*/
1027                     {
1028                         GetSym();
1029                         if(SYM == LBK)
1030                         {
1031                             GetSym();
1032                             EXPRESSION(SymSetUnion(SymSetNew(RBK),FSYS),LEV,TX);
1033                             GEN(LIT,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.SIZE);
1034                             GEN(JUD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1035                             GEN(DEL,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1036                             if(SYM != RBK)
1037                             {
1038                                 Error(44);
1039                             }
1040                         }
1041                     }
1042                 }
1043                 else i=0;
1044                 if (i==0) Error(35);
1045                 else               //读入处理
1046                 {
1047                     switch(TABLE[i].TYPE)
1048                     {
1049                     case CHARCON:
1050                         GEN(OPR,0,18);
1051                         break;
1052                     case INTCON:
1053                         GEN(OPR,0,19);
1054                         break;
1055                     case REALCON:
1056                         GEN(OPR,0,20);
1057                         break;
1058                     }
1059                     if(TABLE[i].KIND==ARRAY)   //判断是否是数组类型并 把栈顶内容放到数组或变量中
1060                         GEN(SAR,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1061                     else
1062                         GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1063                 }
1064                 GetSym();
1065             }
1066             while(SYM==COMMA);
1067         if (SYM!=RPAREN)
1068         {
1069             Error(33);
1070             while (!SymIn(SYM,FSYS)) GetSym();
1071         }
1072         else GetSym();
1073         break; /* READSYM */
1074     case WRITESYM:
1075         GetSym();
1076         if (SYM==LPAREN)
1077         {
1078             do
1079             {
1080                 GetSym();
1081                 if (SYM==IDENT)
1082                 {
1083                     i=POSITION(ID,TX);
1084                     if (TABLE[i].KIND==ARRAY)   /*ASSIGNMENT TO NON-VARIABLE*/
1085                     {
1086                         GetSym();
1087                         if(SYM == LBK)
1088                         {
1089                             GetSym();
1090                             EXPRESSION(SymSetUnion(SymSetNew(RBK),FSYS),LEV,TX);
1091                             GEN(LIT,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.SIZE);
1092                             GEN(JUD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1093                             GEN(DEL,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1094                             if(SYM != RBK)
1095                             {
1096                                 Error(44);
1097                             }
1098                         }
1099                     }
1100                 }
1101                 else i=0;
1102                 if (i==0) Error(35);
1103                 else               //输出处理
1104                 {
1105                     if(TABLE[i].KIND==ARRAY) //判断是否是数组类型并 把值栈顶
1106                         GEN(GAR,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1107                     else
1108                         GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1109                     switch(TABLE[i].TYPE)
1110                     {
1111                     case CHARCON:
1112                         GEN(OPR,0,14);
1113                         break;
1114                     case INTCON:
1115                         GEN(OPR,0,15);
1116                         break;
1117                     case REALCON:
1118                         GEN(OPR,0,16);
1119                         break;
1120                     }
1121                 }
1122                 GetSym();
1123             }
1124             while(SYM==COMMA);
1125             if (SYM!=RPAREN) Error(33);
1126             else GetSym();
1127         }
1128         break; /*WRITESYM*/
1129     case CALLSYM:
1130         GetSym();
1131         if (SYM!=IDENT) Error(14);
1132         else
1133         {
1134             i=POSITION(ID,TX);
1135             if (i==0) Error(11);
1136             else if (TABLE[i].KIND==PROCEDUR)
1137                 GEN(CAL,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1138             else Error(15);
1139             GetSym();
1140         }
1141         break;
1142     case IFSYM:
1143         GetSym();
1144         CONDITION(SymSetUnion(SymSetNew(THENSYM,DOSYM),FSYS),LEV,TX);
1145         if (SYM==THENSYM) 
1146             GetSym();
1147         else Error(16);
1148         CX1=CX;
1149         GEN(JPC,0,0);
1150         STATEMENT(SymSetUnion(SymSetNew(ELSESYM),FSYS),LEV,TX);
1151 
1152         if(SYM!=ELSESYM)
1153         {
1154             CODE[CX1].A=CX;
1155         }
1156         else
1157         {
1158             GetSym();
1159             CX2=CX;
1160             GEN(JMP,0,0);
1161             CODE[CX1].A=CX;
1162             STATEMENT(FSYS,LEV,TX);
1163             CODE[CX2].A=CX;
1164         }
1165         break;
1166     case BEGINSYM:
1167         GetSym();
1168         STATEMENT(SymSetUnion(SymSetNew(SEMICOLON,ENDSYM),FSYS),LEV,TX);
1169         while (SymIn(SYM, SymSetAdd(SEMICOLON,STATBEGSYS)))
1170         {
1171             if (SYM==SEMICOLON) GetSym();
1172             else Error(10);
1173             STATEMENT(SymSetUnion(SymSetNew(SEMICOLON,ENDSYM),FSYS),LEV,TX);
1174         }
1175         if (SYM==ENDSYM) GetSym();
1176         else Error(17);
1177         break;
1178     case WHILESYM:
1179         CX1=CX;
1180         GetSym();
1181         CONDITION(SymSetAdd(DOSYM,FSYS),LEV,TX);
1182         CX2=CX;
1183         GEN(JPC,0,0);
1184         if (SYM==DOSYM) GetSym();
1185         else Error(18);
1186         STATEMENT(FSYS,LEV,TX);
1187         GEN(JMP,0,CX1);
1188         CODE[CX2].A=CX;
1189         break;
1190     /*添加代码*/
1191     case FORSYM:
1192         GetSym();
1193         if(SYM != IDENT) Error(38);
1194         else
1195         {
1196             i=POSITION(ID,TX); //查找名字的位置，找到则返回在名字表的位置，否则返回0
1197             if(i == 0)
1198                 Error(11);
1199             else if (TABLE[i].KIND!=VARIABLE)   /*判断是不是变量*/
1200             {
1201                 Error(12);
1202                 i=0;
1203             }
1204             GetSym();
1205             if(SYM == BECOMES)
1206                 GetSym();
1207             else Error(13);
1208             EXPRESSION(SymSetUnion(SymSetNew(STEPSYM,UNTILSYM,DOSYM),FSYS),LEV,TX);
1209             //把栈顶的值送到变量
1210             if(i != 0)
1211                 //赋值，处理是i：=1
1212                 GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1213             if(SYM==STEPSYM)
1214                 GetSym();
1215             else Error(46);
1216             CX1=CX;    //保存地址，等待回填
1217             GEN(JMP,0,0);   //无条件跳转
1218             CX2=CX;
1219             EXPRESSION(SymSetUnion(SymSetNew(UNTILSYM,DOSYM),FSYS),LEV,TX); //表达式处理
1220             GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); //将变量送回栈顶
1221             GEN(OPR,0,2);  //栈顶与次栈顶相加
1222             GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);//把栈顶的值送到变量
1223             if(SYM==UNTILSYM)
1224                 GetSym();
1225             else Error(34);
1226             CODE[CX1].A=CX;    //将当前地址回填
1227             EXPRESSION(SymSetUnion(SymSetNew(DOSYM),FSYS),LEV,TX);//终止条件
1228             GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); //将变量送回栈顶
1229             GEN(OPR,0,11);      //判断栈顶跟次栈顶数据大小
1230             CX1=CX;   //保存地址，等待回填
1231             GEN(JPC,0,0);   //条件跳转，当栈顶布尔值非真则跳转，否则顺序执行 ，跳出程序
1232             if(SYM==DOSYM)
1233                 GetSym();
1234             else Error(34);
1235             STATEMENT(FSYS,LEV,TX);
1236             GEN(JMP,0,CX2);      //无条件跳转到CX2处
1237             CODE[CX1].A=CX;     //回填假出口
1238         }
1239         break;
1240     //修改statememt 添加 ++ --
1241     case DPLUS:
1242         Form1->printfs("识别出++\n");
1243         GetSym();
1244         if(SYM==IDENT)
1245         {
1246             i=POSITION(ID,TX);
1247             if (i==0) Error(11);
1248             else if (TABLE[i].KIND!=VARIABLE)  /*ASSIGNMENT TO NON-VARIABLE*/
1249             {
1250                 Error(36);
1251                 i=0;
1252             }
1253             if(i!=0)
1254             {
1255                 GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1256                 GEN(LIT,0,1);
1257                 GEN(OPR,0,2);
1258                 GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1259             }
1260             GetSym();
1261         }
1262         else Error(36);
1263         break;
1264     case DMINUS:
1265         Form1->printfs("识别出--\n");
1266         GetSym();
1267         if(SYM==IDENT)
1268         {
1269             i=POSITION(ID,TX);
1270             if (i==0) Error(11);
1271             else if (TABLE[i].KIND!=VARIABLE)  /*ASSIGNMENT TO NON-VARIABLE*/
1272             {
1273                 Error(36);
1274                 i=0;
1275             }
1276             if(i!=0)
1277             {
1278                 GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1279                 GEN(LIT,0,1);
1280                 GEN(OPR,0,3);
1281                 GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
1282             }
1283             GetSym();
1284         }
1285         else Error(36);
1286         break;
1287     }
1288     TEST(FSYS,SymSetNULL(),19);
1289 } /*STATEMENT*/
1290 //---------------------------------------------------------------------------
1291 void Block(int LEV, int TX, SYMSET FSYS)
1292 {
1293     int DX=3;    /*DATA ALLOCATION INDEX*/
1294     int TX0=TX;  /*INITIAL TABLE INDEX*/
1295     int CX0=CX;  /*INITIAL CODE INDEX*/
1296     TABLE[TX].vp.ADR=CX;
1297     GEN(JMP,0,0);
1298     if (LEV>LEVMAX) Error(32);
1299     do
1300     {
1301         if (SYM==CONSTSYM)
1302         {
1303             GetSym();
1304             do
1305             {
1306                 ConstDeclaration(LEV,TX,DX);
1307                 while (SYM==COMMA)
1308                 {
1309                     GetSym();
1310                     ConstDeclaration(LEV,TX,DX);
1311                 }
1312                 if (SYM==SEMICOLON) GetSym();
1313                 else Error(5);
1314             }
1315             while(SYM==IDENT);
1316         }
1317         if (SYM==VARSYM)
1318         {
1319             GetSym();
1320             do
1321             {
1322                 VarDeclaration(LEV,TX,DX);
1323                 while (SYM==COMMA)
1324                 {
1325                     GetSym();
1326                     VarDeclaration(LEV,TX,DX);
1327                 }
1328                 if (SYM==SEMICOLON) GetSym();
1329                 else Error(5);
1330             }
1331             while(SYM==IDENT);
1332         }
1333         while ( SYM==PROCSYM)
1334         {
1335             GetSym();
1336             if (SYM==IDENT)
1337             {
1338                 ENTER(PROCEDUR,LEV,TX,DX);
1339                 GetSym();
1340             }
1341             else Error(4);
1342             if (SYM==SEMICOLON) GetSym();
1343             else Error(5);
1344             Block(LEV+1,TX,SymSetAdd(SEMICOLON,FSYS));
1345             if (SYM==SEMICOLON)
1346             {
1347                 GetSym();
1348                 TEST(SymSetUnion(SymSetNew(IDENT,PROCSYM),STATBEGSYS),FSYS,6);
1349             }
1350             else Error(5);
1351         }
1352         TEST(SymSetAdd(IDENT,STATBEGSYS), DECLBEGSYS,7);
1353     }
1354     while(SymIn(SYM,DECLBEGSYS));
1355     CODE[TABLE[TX0].vp.ADR].A=CX;
1356     TABLE[TX0].vp.ADR=CX;   /*START ADDR OF CODE*/
1357     TABLE[TX0].vp.SIZE=DX;  /*SIZE OF DATA SEGMENT*/
1358     GEN(INI,0,DX);
1359     STATEMENT(SymSetUnion(SymSetNew(SEMICOLON,ENDSYM),FSYS),LEV,TX);
1360     GEN(OPR,0,0);  /*RETURN*/
1361     TEST(FSYS,SymSetNULL(),8);
1362     ListCode(CX0);
1363 } /*Block*/
1364 //---------------------------------------------------------------------------
1365 int BASE(int L,int B,float S[])
1366 {
1367     int B1=B; /*FIND BASE L LEVELS DOWN*/
1368     while (L>0)
1369     {
1370         B1=S[B1];
1371         L=L-1;
1372     }
1373     return B1;
1374 } /*BASE*/
1375 //---------------------------------------------------------------------------
1376 void Interpret()
1377 {
1378     const STACKSIZE = 500;
1379     int P,B,T;      /*PROGRAM BASE TOPSTACK REGISTERS*/
1380     INSTRUCTION I;
1381     String s;
1382     float  S[STACKSIZE];    /*DATASTORE*/    //int
1383     Form1->printfs("~~~ RUN PL0 ~~~");
1384     fprintf(FOUT,"~~~ RUN PL0 ~~~\n");
1385     T=0;
1386     B=1;
1387     P=0;
1388     S[1]=0;
1389     S[2]=0;
1390     S[3]=0;
1391     do
1392     {
1393         I=CODE[P];
1394         P=P+1;
1395         switch (I.F)
1396         {
1397         case LIT:
1398             T++;
1399             S[T]=I.A;
1400             break;
1401         case OPR:
1402             switch ((int)I.A)   /*OPERATOR*/
1403             {
1404             case 0: /*RETURN*/
1405                 T=B-1;
1406                 P=S[T+3];
1407                 B=S[T+2];
1408                 break;
1409             case 1:
1410                 S[T]=-S[T];
1411                 break;
1412             case 2:
1413                 T--;
1414                 S[T]=S[T]+S[T+1];
1415                 break;
1416             case 3:
1417                 T--;
1418                 S[T]=S[T]-S[T+1];
1419                 break;
1420             case 4:
1421                 T--;
1422                 S[T]=S[T]*S[T+1];
1423                 break;
1424             case 5:
1425                 T--;
1426                 S[T]=S[T] / S[T+1];
1427                 break;
1428             case 6:
1429                 S[T]=(S[T]/2!=0);
1430                 break;
1431             case 8:
1432                 T--;
1433                 S[T]=S[T]==S[T+1];
1434                 break;
1435             case 9:
1436                 T--;
1437                 S[T]=S[T]!=S[T+1];
1438                 break;
1439             case 10:
1440                 T--;
1441                 S[T]=S[T]<S[T+1];
1442                 break;
1443             case 11:
1444                 T--;
1445                 S[T]=S[T]>=S[T+1];
1446                 break;
1447             case 12:
1448                 T--;
1449                 S[T]=S[T]>S[T+1];
1450                 break;
1451             case 13:
1452                 T--;
1453                 S[T]=S[T]<=S[T+1];
1454                 break;
1455             case 14: //字符输出
1456                 Form1->printcs((char)S[T]);
1457                 fprintf(FOUT,"%c\n",(char)S[T]);
1458                 T--;
1459                 break;
1460             case 15: //整数输出
1461                 Form1->printls("",S[T]);
1462                 fprintf(FOUT,"%d\n",(int)S[T]);
1463                 T--;
1464                 break;
1465             case 16: //实数输出
1466                 s = FloatToStrF(S[T],ffNumber,8,6);
1467                 Form1->printfs(s.c_str());
1468                 fprintf(FOUT,"%.2f\n",S[T]);
1469                 T--;
1470                 break;
1471             case 17: /*Form1->printfs(""); fprintf(FOUT,"\n"); */ break;
1472             case 18:    //输入字符
1473                 T++;
1474                 s=InputBox("输入","输入字符:", 0);
1475                 S[T] =  (float)(*s.SubString(1,1).c_str());
1476                 Form1->printcs(‘ ‘);
1477                 Form1->printcs((char)S[T]);
1478                 fprintf(FOUT," %c\n",(char)S[T]);
1479                break;
1480             case 19:    //输入整型
1481             T++;
1482                 S[T]=InputBox("输入","输入整数：", 0).ToDouble();
1483                 while((S[T]-(int)S[T])!=0) {
1484                         S[T]=InputBox("输入","输入整数：", 0).ToDouble();
1485                 }
1486                 Form1->printrs("",S[T]);
1487                 fprintf(FOUT,"? %f\n",S[T]);
1488                 break;
1489             case 20: //输入实数
1490             T++;
1491                 S[T]=InputBox("输入","输入实数：",0).ToDouble();
1492                 s = " " + FloatToStrF(S[T],ffNumber,8,6);
1493                 Form1->printfs(s.c_str()); 
1494                 fprintf(FOUT,".2f\n",S[T]);
1495                 break;
1496             }
1497             break;
1498         case LOD:
1499             T++;
1500             S[T]=S[(int)(BASE(I.L,B,S)+(int)I.A)];
1501             break;
1502         case STO:
1503             S[(int)(BASE(I.L,B,S)+(int)I.A)]=S[T];
1504             T--;
1505             break;
1506         case CAL: /*GENERAT NEW Block MARK*/
1507             S[T+1]=BASE(I.L,B,S);
1508             S[T+2]=B;
1509             S[T+3]=P;
1510             B=T+1;
1511             P=I.A;
1512             break;
1513         case INI:
1514             T=T+I.A;
1515             break;
1516         case JMP:
1517             P=I.A;
1518             break;
1519         case JPC:
1520             if (S[T]==0) P=I.A;
1521             T--;
1522             break;
1523         //添加指令操作
1524         case GAR: 
1525             S[T]=S[(int)(BASE(I.L,B,S)+I.A+S[T])]; 
1526             break;
1527         case SAR: 
1528             T--; S[(int)(BASE(I.L,B,S)+I.A+S[T])] = S[T+1]; T--; 
1529             break;
1530         case TAR: 
1531             T++; S[T]=S[(int)(BASE(I.L,B,S)+I.A+S[T-1])];
1532             break;
1533         case DEL: 
1534             T--;
1535             break;
1536         case JUD: 
1537             S[T]=S[T-1]-S[T];if(S[T]>=0)Error(53);
1538             break;
1539         } /*switch*/
1540     }
1541     while(P!=0);
1542     Form1->printfs("~~~ END PL0 ~~~");
1543     fprintf(FOUT,"~~~ END PL0 ~~~\n");
1544 } /*Interpret*/
1545 //---------------------------------------------------------------------------
1546 void __fastcall TForm1::ButtonRunClick(TObject *Sender)
1547 {
1548     for (CH=‘ ‘; CH<=‘^‘; CH++) SSYM[CH]=NUL;
1549     strcpy(KWORD[1],"BEGIN");
1550     strcpy(KWORD[2],"CALL");
1551     strcpy(KWORD[3],"CHAR");
1552     strcpy(KWORD[4],"CONST");
1553     strcpy(KWORD[5],"DMINUS");
1554     strcpy(KWORD[6],"DO");
1555     strcpy(KWORD[7],"DPLUS");
1556     strcpy(KWORD[8],"ELSE");
1557     strcpy(KWORD[9],"END");
1558     strcpy(KWORD[10],"FOR");
1559     strcpy(KWORD[11],"IF");
1560     strcpy(KWORD[12],"INT");
1561     strcpy(KWORD[13],"ODD");
1562     strcpy(KWORD[14],"PROCEDURE");
1563     strcpy(KWORD[15],"PROGRAM");
1564     strcpy(KWORD[16],"READ");
1565     strcpy(KWORD[17],"REAL");
1566     strcpy(KWORD[18],"RETURN");
1567     strcpy(KWORD[19],"STEP");
1568     strcpy(KWORD[20],"THEN");
1569     strcpy(KWORD[21],"UNTIL");
1570     strcpy(KWORD[22],"VAR");
1571     strcpy(KWORD[23],"WHILE");
1572     strcpy(KWORD[24],"WRITE");
1573     WSYM[1]=BEGINSYM;
1574     WSYM[2]=CALLSYM;
1575     WSYM[3]=CHARSYM;
1576     WSYM[4]=CONSTSYM;
1577     WSYM[5]=DMINUS;
1578     WSYM[6]=DOSYM;
1579     WSYM[7]=DPLUS;
1580     WSYM[8]=ELSESYM;
1581     WSYM[9]=ENDSYM;
1582     WSYM[10]=FORSYM;
1583     WSYM[11]=IFSYM;
1584     WSYM[12]=INTSYM;
1585     WSYM[13]=ODDSYM;
1586     WSYM[14]=PROCSYM;
1587     WSYM[15]=PROGSYM;
1588     WSYM[16]=READSYM;
1589     WSYM[17]=REALSYM;
1590     WSYM[18]=RETURNSYM;
1591     WSYM[19]=STEPSYM;
1592     WSYM[20]=THENSYM;
1593     WSYM[21]=UNTILSYM;
1594     WSYM[22]=VARSYM;
1595     WSYM[23]=WHILESYM;
1596     WSYM[24]=WRITESYM;
1597 
1598     SSYM[‘+‘]=PLUS;
1599     SSYM[‘-‘]=MINUS;
1600     SSYM[‘*‘]=TIMES;
1601     SSYM[‘/‘]=SLASH;
1602     SSYM[‘(‘]=LPAREN;
1603     SSYM[‘)‘]=RPAREN;
1604     SSYM[‘=‘]=EQL;
1605     SSYM[‘,‘]=COMMA;
1606     SSYM[‘.‘]=PERIOD;    //SSYM[‘#‘]=NEQ;
1607     SSYM[‘;‘]=SEMICOLON;
1608     SSYM[‘&‘]=AND;
1609     SSYM[‘!‘]=NOT;
1610 
1611     SSYM[‘[‘]=LBK;//一维数组的左括号[
1612     SSYM[‘]‘]=RBK;//一维数组的右括号]
1613 
1614 
1615     strcpy(MNEMONIC[LIT],"LIT");
1616     strcpy(MNEMONIC[OPR],"OPR");
1617     strcpy(MNEMONIC[LOD],"LOD");
1618     strcpy(MNEMONIC[STO],"STO");
1619     strcpy(MNEMONIC[CAL],"CAL");
1620     strcpy(MNEMONIC[INI],"INI");
1621     strcpy(MNEMONIC[JMP],"JMP");
1622     strcpy(MNEMONIC[JPC],"JPC");
1623 
1624     strcpy(MNEMONIC[GAR],"GAR");//根据栈顶的偏移地址从数组中取值到新的栈顶（删除次栈顶，即偏移量）
1625     strcpy(MNEMONIC[TAR],"TAR");//根据栈顶的偏移地址从数组中取值到新的栈顶(不删除偏移量)
1626     strcpy(MNEMONIC[DEL],"DEL");//删除栈顶
1627     strcpy(MNEMONIC[SAR],"SAR");//根据次栈顶的偏移地址把栈顶的值存入数组
1628     strcpy(MNEMONIC[JUD],"JUD");//判断数组是否越界
1629 
1630     DECLBEGSYS=(int*)malloc(sizeof(int)*SYMMAX);
1631     STATBEGSYS=(int*)malloc(sizeof(int)*SYMMAX);
1632     FACBEGSYS =(int*)malloc(sizeof(int)*SYMMAX);
1633     for(int j=0; j<SYMMAX; j++)
1634     {
1635         DECLBEGSYS[j]=0;
1636         STATBEGSYS[j]=0;
1637         FACBEGSYS[j] =0;
1638     }
1639     DECLBEGSYS[CONSTSYM]=1;
1640     DECLBEGSYS[VARSYM]=1;
1641     DECLBEGSYS[PROCSYM]=1;
1642     STATBEGSYS[BEGINSYM]=1;
1643     STATBEGSYS[CALLSYM]=1;
1644     STATBEGSYS[IFSYM]=1;
1645     STATBEGSYS[WHILESYM]=1;
1646     STATBEGSYS[WRITESYM]=1;
1647     FACBEGSYS[IDENT] =1;
1648     FACBEGSYS[NUMBER]=1;
1649     FACBEGSYS[LPAREN]=1;
1650 
1651     //首先加入初始化开始符号集：
1652     STATBEGSYS[DPLUS]=1;
1653     STATBEGSYS[DMINUS]=1;
1654     FACBEGSYS[DPLUS]=1;
1655     FACBEGSYS[DMINUS]=1;
1656 
1657     if ((FIN=fopen((Form1->EditName->Text+".PL0").c_str(),"r"))!=0)
1658     {
1659         FOUT=fopen((Form1->EditName->Text+".COD").c_str(),"w");
1660         Form1->printfs("=== COMPILE PL0 ===");
1661         fprintf(FOUT,"=== COMPILE PL0 ===\n");
1662         ERR=0;
1663         CC=0;
1664         CX=0;
1665         LL=0;
1666         CH=‘ ‘;
1667         GetSym();
1668         if (SYM!=PROGSYM) Error(0);
1669         else
1670         {
1671             GetSym();
1672             if (SYM!=IDENT) Error(0);
1673             else
1674             {
1675                 GetSym();
1676                 if (SYM!=SEMICOLON) Error(5);
1677                 else GetSym();
1678             }
1679         }
1680         Block(0,0,SymSetAdd(PERIOD,SymSetUnion(DECLBEGSYS,STATBEGSYS)));
1681         if (SYM!=PERIOD) Error(9);
1682         if (ERR==0) Interpret();
1683         else
1684         {
1685             Form1->printfs("ERROR IN PL/0 PROGRAM");
1686             fprintf(FOUT,"ERROR IN PL/0 PROGRAM");
1687         }
1688         fprintf(FOUT,"\n");
1689         fclose(FOUT);
1690     }
1691 }
1692 //---------------------------------------------------------------------------