unit1.~cpp

1）增加单词：保留字 ELSE

    }
  else if (CH==':') {
	    GetCh();
	    if (CH=='=') { SYM=BECOMES; GetCh(); }
	    else SYM=NUL;
      }
   else /* THE FOLLOWING TWO CHECK WERE ADDED
	         BECAUSE ASCII DOES NOT HAVE A SINGLE CHARACTER FOR <= OR >= */
   if (CH=='<') {
	  GetCh();
	  if (CH=='=') { SYM=LEQ; GetCh(); }
          else if (CH=='>') { SYM=NEQ;GetCh(); }   //增加<>为不等于号；
  	  else SYM=LSS;
   }
    else if(CH=='>') {
	GetCh();
	if (CH=='=') { SYM=GEQ; GetCh(); }
	else SYM=GTR;
    }
    else if(CH=='+'){    //增加++和+=
      GetCh();
      if(CH=='+'){
       SYM=INC; GetCh();
       }
      else if(CH=='='){
        SYM=PLUSBK; GetCh();
        }
       else SYM=PLUS;
     }
    else if(CH=='-'){ //增加--和-=
       GetCh();
       if(CH=='-'){
         SYM=DEC; GetCh();
       }
       else if(CH=='='){
              SYM=MINUSBK; GetCh();
       }
        else SYM=MINUS;
     }
    else { SYM=SSYM[CH]; GetCh(); }
} /*GetSym()*/
//---------------------------------------------------------------------------
void GEN(FCT X, int Y, int Z) {
  if (CX>CXMAX) {
    Form1->printfs("PROGRAM TOO LONG");
	fprintf(FOUT,"PROGRAM TOO LONG\n");
	fclose(FOUT);
    exit(0);
  }
  CODE[CX].F=X; CODE[CX].L=Y; CODE[CX].A=Z;
  CX++;
} /*GEN*/
//---------------------------------------------------------------------------
void TEST(SYMSET S1, SYMSET S2, int N) {
  if (!SymIn(SYM,S1)) {
    Error(N);
	while (!SymIn(SYM,SymSetUnion(S1,S2))) GetSym();
  }
} /*TEST*/
//---------------------------------------------------------------------------
void ENTER(OBJECTS K, int LEV, int &TX, int &DX) { /*ENTER OBJECT INTO TABLE*/
  TX++;
  strcpy(TABLE[TX].NAME,ID); TABLE[TX].KIND=K;
  switch (K) {
	case CONSTANT:
	       if (NUM>AMAX) { Error(31); NUM=0; }
	       TABLE[TX].VAL=NUM;
	       break;
    case VARIABLE:
	       TABLE[TX].vp.LEVEL=LEV; TABLE[TX].vp.ADR=DX; DX++;
	       break;
	case PROCEDUR:
	       TABLE[TX].vp.LEVEL=LEV;
	       break;
  }
} /*ENTER*/
//---------------------------------------------------------------------------
int POSITION(ALFA ID, int TX) { /*FIND IDENTIFIER IN TABLE*/
  int i=TX;
  strcpy(TABLE[0].NAME,ID);
  while (strcmp(TABLE[i].NAME,ID)!=0) i--;
  return i;
} /*POSITION*/
//---------------------------------------------------------------------------
void ConstDeclaration(int LEV,int &TX,int &DX) {
  if (SYM==IDENT) {
    GetSym();
    if (SYM==EQL||SYM==BECOMES) {
	  if (SYM==BECOMES) Error(1);
	  GetSym();
	  if (SYM==NUMBER) { ENTER(CONSTANT,LEV,TX,DX); GetSym(); }
	  else Error(2);
    }
    else Error(3);
  }
  else Error(4);
} /*ConstDeclaration()*/
//---------------------------------------------------------------------------
void VarDeclaration(int LEV,int &TX,int &DX) {
  if (SYM==IDENT) { ENTER(VARIABLE,LEV,TX,DX); GetSym(); }
  else Error(4);
} /*VarDeclaration()*/
//---------------------------------------------------------------------------
void ListCode(int CX0) {  /*LIST CODE GENERATED FOR THIS Block*/
  if (Form1->ListSwitch->ItemIndex==0)
    for (int i=CX0; i<CX; i++) {
      String s=IntToStr(i);
      while(s.Length()<3)s=" "+s;
      s=s+" "+MNEMONIC[CODE[i].F]+" "+IntToStr(CODE[i].L)+" "+IntToStr(CODE[i].A);
	  Form1->printfs(s.c_str());
	  fprintf(FOUT,"%3d%5s%4d%4d\n",i,MNEMONIC[CODE[i].F],CODE[i].L,CODE[i].A);
    }
} /*ListCode()*/;
//---------------------------------------------------------------------------
void FACTOR(SYMSET FSYS, int LEV, int &TX) {
  int i;
  TEST(FACBEGSYS,FSYS,24);
  while (SymIn(SYM,FACBEGSYS)) {
	if (SYM==IDENT) {
	  i=POSITION(ID,TX);
	  if (i==0) Error(11);
	  else
		switch (TABLE[i].KIND) {
		  case CONSTANT: GEN(LIT,0,TABLE[i].VAL);GetSym(); break;
		  case VARIABLE: GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
                                   GetSym();
                                   if(SYM==INC||SYM==DEC){ //因子中的++和--运算
                                   GEN(LIT,0,1);
                                   if(SYM==INC) GEN(OPR,0,2);
                                   else GEN(OPR,0,3);
                                   GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
                                   GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
                                   GetSym();
                                  }
                                  break;
		  case PROCEDUR: Error(21); break;
		}

	}
	else
	  if (SYM==NUMBER) {
		if (NUM>AMAX) { Error(31); NUM=0; }
		GEN(LIT,0,NUM); GetSym();
	  }
	  else if (SYM==LPAREN) {
		  GetSym(); EXPRESSION(SymSetAdd(RPAREN,FSYS),LEV,TX);
		  if (SYM==RPAREN) GetSym();
		  else Error(22);
		}
	  TEST(FSYS,FACBEGSYS,23);
  }
}/*FACTOR*/
//---------------------------------------------------------------------------
void TERM(SYMSET FSYS, int LEV, int &TX) {  /*TERM*/
  SYMBOL MULOP;
  FACTOR(SymSetUnion(FSYS,SymSetNew(TIMES,SLASH)), LEV,TX);
  while (SYM==TIMES || SYM==SLASH) {
	MULOP=SYM;  GetSym();
	FACTOR(SymSetUnion(FSYS,SymSetNew(TIMES,SLASH)),LEV,TX);
	if (MULOP==TIMES) GEN(OPR,0,4);
	else GEN(OPR,0,5);
  }
} /*TERM*/;
//---------------------------------------------------------------------------
void EXPRESSION(SYMSET FSYS, int LEV, int &TX) {
  SYMBOL ADDOP;
  if (SYM==PLUS || SYM==MINUS) {
    ADDOP=SYM; GetSym();
    TERM(SymSetUnion(FSYS,SymSetNew(PLUS,MINUS)),LEV,TX);
    if (ADDOP==MINUS) GEN(OPR,0,1);
  }
  else TERM(SymSetUnion(FSYS,SymSetNew(PLUS,MINUS)),LEV,TX);
  while (SYM==PLUS || SYM==MINUS) {
    ADDOP=SYM; GetSym();
    TERM(SymSetUnion(FSYS,SymSetNew(PLUS,MINUS)),LEV,TX);
    if (ADDOP==PLUS) GEN(OPR,0,2);
    else GEN(OPR,0,3);
  }
} /*EXPRESSION*/
//---------------------------------------------------------------------------
void CONDITION(SYMSET FSYS,int LEV,int &TX) {
  SYMBOL RELOP;
  if (SYM==ODDSYM) { GetSym(); EXPRESSION(FSYS,LEV,TX); GEN(OPR,0,6); }
  else {
	EXPRESSION(SymSetUnion(SymSetNew(EQL,NEQ,LSS,LEQ,GTR,GEQ),FSYS),LEV,TX);
	if (!SymIn(SYM,SymSetNew(EQL,NEQ,LSS,LEQ,GTR,GEQ))) Error(20);
	else {
	  RELOP=SYM; GetSym(); EXPRESSION(FSYS,LEV,TX);
	  switch (RELOP) {
	    case EQL: GEN(OPR,0,8);  break;
	    case NEQ: GEN(OPR,0,9);  break;
	    case LSS: GEN(OPR,0,10); break;
	    case GEQ: GEN(OPR,0,11); break;
	    case GTR: GEN(OPR,0,12); break;
	    case LEQ: GEN(OPR,0,13); break;
	  }
	}
  }
} /*CONDITION*/
//---------------------------------------------------------------------------
void STATEMENT(SYMSET FSYS,int LEV,int &TX) {   /*STATEMENT*/
  int i,CX1,CX2;
  switch (SYM) {
	case IDENT:
		i=POSITION(ID,TX);
		if (i==0) Error(11);
		else
		  if (TABLE[i].KIND!=VARIABLE) { /*ASSIGNMENT TO NON-VARIABLE*/
			Error(12); i=0;
		  }
                GetSym();
		if (SYM==BECOMES) {
                  GetSym();
                  EXPRESSION(FSYS,LEV,TX);//语句处理
		  if (i!=0) GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);   //
                }

                else if (SYM==INC){ //语句中的++运算
                          if (i!=0) GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); //ident->栈顶
                          GEN(LIT,0,1);
                          GEN(OPR,0,2);  //栈顶 次栈加
                          if (i!=0) GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); //栈顶->ident
                          GetSym();
                }
                else if (SYM==DEC){ //语句中的--运算
                         if (i!=0) GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
                         GEN(LIT,0,1);
                         GEN(OPR,0,3);  //次栈减栈顶
                         if (i!=0) GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
                         GetSym();
                }
                else if (SYM==PLUSBK){ //增加运算符+=
                         if (i!=0) GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
                         GetSym();
                         EXPRESSION(FSYS,LEV,TX);
                         GEN(OPR,0,2);
                         if (i!=0) GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
                 }
                 else if (SYM==MINUSBK) { //增加运算符-=
                   if (i!=0) GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
                   GetSym();
                   EXPRESSION(FSYS,LEV,TX);
                   GEN(OPR,0,3);
                   if (i!=0) GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
                 }
		else Error(13);

		break;
        case INC: //前++
           GetSym();
           if( SYM == IDENT ){
              i=POSITION(ID,TX);
	     if (i==0) Error(11);
	     else if (TABLE[i].KIND!=VARIABLE) { /*ASSIGNMENT TO NON-VARIABLE*/
			Error(12); i=0;
             }
              if (i!=0) GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); //ident->栈顶
                          GEN(LIT,0,1);
                          GEN(OPR,0,2);  //栈顶 次栈加
              if (i!=0) GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); //栈顶->ident
              GetSym();

           }
           else Error(8);
           break;
        case DEC://前--
           GetSym();
           if( SYM == IDENT ){
              i=POSITION(ID,TX);
	     if (i==0) Error(11);
	     else if (TABLE[i].KIND!=VARIABLE) { /*ASSIGNMENT TO NON-VARIABLE*/
			Error(12); i=0;
             }
              if (i!=0) GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); //ident->栈顶
                          GEN(LIT,0,1);
                          GEN(OPR,0,3);  //栈顶 次栈 -
              if (i!=0) GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); //栈顶->ident
              GetSym();

           }
           else Error(8);
           break;
        case FORSYM:   //添加FOR语句。
             GetSym();

             /*后跟ident*/
             if (SYM!=IDENT) Error(36); //  FOR语句后跟符号错误
             else  i=POSITION(ID,TX);  //查找表示符号在名字表的位置
             if (i==0) Error(11);     //表示符未说明
             else
             if (TABLE[i].KIND!=VARIABLE) {// /*ASSIGNMENT TO NON-VARIABLE*/
                 Error(12); i=0;/*变量*/
             }

             GetSym();

             if (SYM==BECOMES)   /* := */
                 GetSym();
             else Error(13);    //

             /*表达式*/
             EXPRESSION(SymSetUnion(SymSetNew(TOSYM,DOWNTOSYM),FSYS),LEV,TX);


             if(i!=0)  GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
                   //栈顶 ->ident

             if (SYM==TOSYM){//TO

                 CX1=CX;/*记录地址*/

                 GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
                   //生成代码 ident->栈顶

                 GetSym();

                 /*表达式*/
                 EXPRESSION(SymSetUnion(SymSetNew(DOSYM),FSYS),LEV,TX);

                 GEN(OPR,0,13);//生成代码   次栈是否小于等于栈顶，退两个栈，结果->栈顶

                 CX2=CX;      //记录

                 GEN(JPC,0,0);    //

                 //加一
                 GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);
                 GEN(LIT,0,1);
                 GEN(OPR,0,2);
                 GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);

                 if(SYM==DOSYM){
                   GetSym();
                   STATEMENT(FSYS,LEV,TX);
                 }

                 else Error(36);     //FOR语句后跟符错误

                 GEN(JMP,0,CX1);     //

                 CODE[CX2].A=CX;       //回填
             }
             else if (SYM==DOWNTOSYM){    //