unit1.~cpp

我在三做的课程

/*** PL0 COMPILER WITH CODE GENERATION ***/
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
const  AL    =  10;  /* LENGTH OF IDENTIFIERS 标识符长度 */  
const  NORW  =  20;  //14改为20，加四个保留字  /* # OF RESERVED WORDS 保留字个数*/
const  TXMAX = 100;  /* LENGTH OF IDENTIFIER TABLE 标识符表长度*/
const  NMAX  =  14;  /* MAX NUMBER OF DEGITS IN NUMBERS 数中数字的最大个数*/
const  AMAX  =2047;  /* MAXIMUM ADDRESS 最大地址*/
const  RMAX  =32767;
const  LEVMAX=   3;  /* MAX DEPTH OF BLOCK NESTING 分程序嵌套的最大深度*/
const  CXMAX = 200;  /* SIZE OF CODE ARRAY 目标代码数组的大小*/

typedef enum  { NUL, IDENT, NUMBER, PLUS, MINUS, TIMES,
	            SLASH, ODDSYM, EQL, NEQ, LSS, LEQ, GTR, GEQ,
	            LPAREN, RPAREN, COMMA, SEMICOLON, PERIOD,
	            BECOMES, BEGINSYM, ENDSYM, IFSYM, THENSYM,
	            WHILESYM, WRITESYM, READSYM, DOSYM, CALLSYM,
	            CONSTSYM, VARSYM, PROCSYM, PROGSYM

                    //以下是增加的保留字

                    ,ELSESYM,FORSYM,TOSYM,DOWNTOSYM,REALSYM,CHARSYM
                    ,REALS,CHARS

                    //以下是增加+=，-=，++，-- ,<>,[,],~

                    ,PLEQ,MIEQ,PLPL,MIMI,LSQUARE,RSQUARE,MIDD
        } SYMBOL;
char *SYMOUT[] = {"NUL", "IDENT", "NUMBER", "PLUS", "MINUS", "TIMES",
	    "SLASH", "ODDSYM", "EQL", "NEQ", "LSS", "LEQ", "GTR", "GEQ",
	    "LPAREN", "RPAREN", "COMMA", "SEMICOLON", "PERIOD",
	    "BECOMES", "BEGINSYM", "ENDSYM", "IFSYM", "THENSYM",
	    "WHILESYM", "WRITESYM", "READSYM", "DOSYM", "CALLSYM",
	    "CONSTSYM", "VARSYM", "PROCSYM", "PROGSYM"

            //以下是增加的保留字

            ,"ELSESYM","FORSYM","TOSYM","DOWNTOSYM","CHARSYM","REALSYM"
            ,"REALS","CHARS"

            //以下是增加+=，-=，++，--,<>,[,],~

            ,"PLEQ","MIEQ","PLPL","MIMI","LSQUARE","RSQUARE","MIDD"


            };

typedef  int *SYMSET; // SET OF SYMBOL;
typedef  char ALFA[11];
typedef  enum { CONSTANT, VARIABLE, PROCEDUR, CHARCON, REALCON } OBJECTS ;
typedef  enum { LIT, OPR, LOD, STO, CAL, INI, JMP, JPC } FCT;
typedef struct {
	 FCT F;     /*FUNCTION CODE*/
	 int L; 	/*0..LEVMAX  LEVEL*/
	 float A;     /*0..AMAX    DISPLACEMENT ADDR*/
} INSTRUCTION;
	  /* LIT O A -- LOAD CONSTANT A             */
	  /* OPR 0 A -- EXECUTE OPR A               */
	  /* LOD L A -- LOAD VARIABLE L,A           */
	  /* STO L A -- STORE VARIABLE L,A          */
	  /* CAL L A -- CALL PROCEDURE A AT LEVEL L */
	  /* INI 0 A -- INCREMET T-REGISTER BY A    */
	  /* JMP 0 A -- JUMP TO A                   */
	  /* JPC 0 A -- JUMP CONDITIONAL TO A       */
char   CH;  /*LAST CHAR READ*/
SYMBOL SYM; /*LAST SYMBOL READ*/
ALFA   ID;  /*LAST IDENTIFIER READ*/
float    NUM; /*LAST NUMBER READ*/
int    CC;  /*CHARACTER COUNT*/
int    LL;  /*LINE LENGTH*/
int    CX;  /*CODE ALLOCATION INDEX*/
int    FTE=0;/*数组的长度*/
char   LINE[81];
INSTRUCTION  CODE[CXMAX];
ALFA    KWORD[NORW+1];
SYMBOL  WSYM[NORW+1];
SYMBOL  SSYM['^'+1];
ALFA    MNEMONIC[9];
SYMSET  DECLBEGSYS, STATBEGSYS, FACBEGSYS;

struct {
  ALFA NAME;
  OBJECTS KIND;
  union {
    int VAL;   /*CONSTANT*/
    struct { int LEVEL,ADR,SIZE; } vp;  /*VARIABLE,PROCEDUR:*/
  };
} TABLE[TXMAX];

FILE *FIN,*FOUT;
int ERR;
int aa;

void EXPRESSION(SYMSET FSYS, int LEV, int &TX);
void TERM(SYMSET FSYS, int LEV, int &TX);
//---------------------------------------------------------------------------
int SymIn(SYMBOL SYM, SYMSET S1) {
  return S1[SYM];
}
//---------------------------------------------------------------------------
SYMSET SymSetUnion(SYMSET S1, SYMSET S2) {
  SYMSET S=(SYMSET)malloc(sizeof(int)*46);
  for (int i=0; i<46; i++)
	if (S1[i] || S2[i]) S[i]=1;
	else S[i]=0;
  return S;
}
//---------------------------------------------------------------------------
SYMSET SymSetAdd(SYMBOL SY, SYMSET S) {
  SYMSET S1;
  S1=(SYMSET)malloc(sizeof(int)*46);
  for (int i=0; i<46; i++) S1[i]=S[i];
  S1[SY]=1;
  return S1;
}
//---------------------------------------------------------------------------
SYMSET SymSetNew(SYMBOL a) {
  SYMSET S; int i,k;
  S=(SYMSET)malloc(sizeof(int)*46);
  for (i=0; i<46; i++) S[i]=0;
  S[a]=1;
  return S;
}
//---------------------------------------------------------------------------
SYMSET SymSetNew(SYMBOL a, SYMBOL b) {
  SYMSET S; int i,k;
  S=(SYMSET)malloc(sizeof(int)*46);
  for (i=0; i<46; i++) S[i]=0;
  S[a]=1;  S[b]=1;
  return S;
}
//---------------------------------------------------------------------------
SYMSET SymSetNew(SYMBOL a, SYMBOL b, SYMBOL c) {
  SYMSET S; int i,k;
  S=(SYMSET)malloc(sizeof(int)*46);
  for (i=0; i<46; i++) S[i]=0;
  S[a]=1;  S[b]=1; S[c]=1;
  return S;
}
//---------------------------------------------------------------------------
SYMSET SymSetNew(SYMBOL a, SYMBOL b, SYMBOL c, SYMBOL d) {
  SYMSET S; int i,k;
  S=(SYMSET)malloc(sizeof(int)*46);
  for (i=0; i<46; i++) S[i]=0;
  S[a]=1;  S[b]=1; S[c]=1; S[d]=1;
  return S;
}
//---------------------------------------------------------------------------
SYMSET SymSetNew(SYMBOL a, SYMBOL b, SYMBOL c, SYMBOL d,SYMBOL e) {
  SYMSET S; int i,k;
  S=(SYMSET)malloc(sizeof(int)*46);
  for (i=0; i<46; i++) S[i]=0;
  S[a]=1;  S[b]=1; S[c]=1; S[d]=1; S[e]=1;
  return S;
}
//---------------------------------------------------------------------------
SYMSET SymSetNew(SYMBOL a, SYMBOL b, SYMBOL c, SYMBOL d,SYMBOL e, SYMBOL f) {
  SYMSET S; int i,k;
  S=(SYMSET)malloc(sizeof(int)*46);
  for (i=0; i<46; i++) S[i]=0;
  S[a]=1;  S[b]=1; S[c]=1; S[d]=1; S[e]=1; S[f]=1;
  return S;
}
//---------------------------------------------------------------------------
SYMSET SymSetNULL() {
  SYMSET S; int i,n,k;
  S=(SYMSET)malloc(sizeof(int)*46);
  for (i=0; i<46; i++) S[i]=0;
  return S;
}
//---------------------------------------------------------------------------
void Error(int n) {
  String s = "***"+AnsiString::StringOfChar(' ', CC-1)+"^";
  Form1->printls(s.c_str(),n);   fprintf(FOUT,"%s%d\n", s.c_str(), n);
  ERR++;
} /*Error*/
//---------------------------------------------------------------------------
void GetCh() {
  if (CC==LL) {
    if (feof(FIN)) {
	  Form1->printfs("PROGRAM INCOMPLETE");
	  fprintf(FOUT,"PROGRAM INCOMPLETE\n");
	  fclose(FOUT);
	  exit(0);
	}
	LL=0; CC=0;
	CH=' ';
	while (!feof(FIN) && CH!=10)
      { CH=fgetc(FIN);  LINE[LL++]=CH; }
	LINE[LL-1]=' ';  LINE[LL]=0;
    String s=IntToStr(CX);
    while(s.Length()<3) s=" "+s;
    s=s+" "+LINE;
	Form1->printfs(s.c_str());
    fprintf(FOUT,"%s\n",s);
  }
  CH=LINE[CC++];
} /*GetCh()*/

//---------------------------------------------------------------------------
void GetSym() {
  int i,J,K;   ALFA  A;
  while (CH<=' ') GetCh();
  if (CH>='A' && CH<='Z') { /*ID OR RESERVED WORD*/
    K=0;
	do {
	  if (K<AL) A[K++]=CH;
	  GetCh();
	}while((CH>='A' && CH<='Z')||(CH>='0' && CH<='9'));
	A[K]='\0';
	strcpy(ID,A); i=1; J=NORW;
	do {
	  K=(i+J) / 2;
	  if (strcmp(ID,KWORD[K])<=0) J=K-1;
	  if (strcmp(ID,KWORD[K])>=0) i=K+1;
	}while(i<=J);
	if (i-1 > J) SYM=WSYM[K];
	else SYM=IDENT;
  }
  else
    if (CH>='0' && CH<='9') { /*NUMBER*/
    K=0; NUM=0; SYM=NUMBER;  float count=0.1;
    do
      {
        if(CH=='.')
        {
                GetCh();
                SYM=REALS;
                while(CH>='0' && CH<='9')
                {
                        NUM=NUM+(CH-'0')*count;
                        K++;
                        count*=0.1;
                        GetCh();
                }
                break;
        }
        else
        {
                NUM=10*NUM+(CH-'0');
                K++;
                GetCh();
        }
      }while((CH>='0' && CH<='9')||CH=='.');
	  if (K>NMAX) Error(30);
    }

  else
    //----------------------------加入字符类型 只接受 'a' 里面的一个字母
      if((int)CH==39)
      {
         GetCh();
         if((CH>='A' && CH<='Z')||(CH>='a' && CH<='z'))
         {
            NUM=(int)CH;
            GetCh();
            if((int)CH==39)
              SYM=CHARS;
            else { NUM=0;SYM=NUL;Error(39);}  //类型错误
         }
         else Error(39); //类型不匹配
         GetCh();
      }
    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(); }

      //增加<>

      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=PLEQ;GetCh();}
                else if(CH=='+'){SYM=PLPL;GetCh();}
                else SYM=PLUS;
       }

  else
    if(CH=='-')
      {
                GetCh();
                if(CH=='='){SYM=MIEQ;GetCh();}
                else if(CH=='-'){SYM=MIMI;GetCh();}
                else SYM=MINUS;
      }

else { SYM=SSYM[CH]; GetCh(); }
} /*GetSym()*/
//---------------------------------------------------------------------------
void GEN(FCT X, int Y, float 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 CHARCON:
	       TABLE[TX].vp.LEVEL=LEV; TABLE[TX].vp.ADR=DX; DX++;
	       break;
        case REALCON:
	       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) {
    int num1,k,m; // 变量说明处理
  if (SYM==IDENT) { ENTER(VARIABLE,LEV,TX,DX); GetSym(); }
  else Error(4);
   if(SYM==LSQUARE)   //如果标识符为‘[’，进行数组变量说明处理       
 {                
        GetSym();
        if(SYM==NUMBER)
           {
 		num1=NUM;      //如果数组下界为数字，则把数值赋给num1                 
                GetSym();
		if(SYM==MIDD)     //如果下界的下一个标识符为‘~’，则再取下一个                  
		GetSym();
		else Error(2);     //否则出错
	if(SYM==NUMBER)
	{     //如果数组的上界为数字，计算数组的长度并留出空间                  
 		DX=DX+NUM-num1+1;// 移动指针                 
                       GetSym();                   
             }        
	else   
	{        //数组的上界为标识符时                
		m=POSITION(ID,TX); //查找标识符的位置              
		 if(m==0) Error(11);                
		 else if(TABLE[m].KIND==CONSTANT)  //如果标识符为常量                    
		 k=TABLE[m].VAL;              //则把其值赋给k                 
   		 else {Error(41);m=0;}         //否则出错并致m为0                    
 		DX=DX+k-num1+1;    // 计算数组的长度并留出空间，移动指针                       
   		 GetSym();         
	}       
     }
    else 
    {  //如果数组的下界为标识符
	m=POSITION(ID,TX);  //查找标识符的位置         
            if(m==0) Error(11);           
	else if(TABLE[m].KIND==CONSTANT) //如果标识符为常量