runtime.h

一个Pascal子集语言的编译器

//RunTime.h


//inputfile:  words.txt, sentence.txt, wordtable2.txt
//outputfile: runtime.txt

#ifndef RUNTIME_H_
#define RUNTIME_H_

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;

/*****************************************************************************************
    运行时刻环境 
     
    功能要求：
     
      1。首先读取sentence.txt文件，判断各个变量是否在其作用域内出现。 
      2。从words.txt文件中将各个模块分别读取出，并分别保存在各组变量里。 
      3。从程序的入口点进入程序，按顺序输出到目标文件，并在函数调用时判断此段函数代码是否
         写过，如果没写过则将其写到当前位置，如果写过则转移到以前写过的位置。 
    
    
    步骤：
        
      1。首先判断各个变量是否出现在其作用域内，并返回正确或错误信息
      2。分析words.txt文件，并将其分段落存入字符串组中去
      
        比如下面一段代码：
        
        program example(input,output);
        var x,y:integer;

        procedure gcd(m,n:integer);
        var n:integer;
        begin
              n:=m ;
        end;
        
        begin
          read(x,y);
          write(gcd(x))
        end.
        
        将其存到数组中： 
        
        Word[0][0]="var" Word[0][1]="id" Word[0][2]="," Word[0][3]="id" Word[0][4]=":" 
        ...
        ..
        
        Word[1][0]="var" Word[1][1]="id" Word[1][2]=":" Word[1][3]="def" Word[1][4]=";" 
        Word[1][5]="begin" Word[1][6]="ids" Word[1][7]=":" Word[1][8]="ids" Word[1][9]=";" 
        Word[1][10]="end" Word[1][11]=";"
        
        并记录信息：
        
        Segment[1]=0;   //记录此变量的段落编号 
                        //以及各个参数信息 
        ParamentCount[0]=2  Parament[0][1]="input" Parament[0][2]="output"
        
        Segment[6]=1;
        
        ParamentCount[1]=2  Parament[1][1]="m" Parament[1][2]="n"
        
     3。将分析好的代码按照执行时的顺序写到文件中去，如果遇到函数调用，则在其所在语句前加一
        个变量，使变量的值为此函数。 
        
        例如下面这段代码：
        
        program example(input,output);
        var x,y:integer;

        procedure gcd(m,n:integer);
        var n:integer;
        begin
              n:=m ;
        end;
        
        begin
          read(x,y);
          write(gcd(x))
        end.
        
        将被转换为：
          
        var x,y:integer;
        read(x,y);
        gcd:
        write(gcd(x))
        
        
******************************************************************************************/
class runTime
{
    private:
    
        ifstream fin1;                //定义文件读取指针 
        ifstream fin2;                //定义文件读取指针 
        ifstream fintable;            //读取变量表的指针
        ofstream fout;                //将各个模块按照执行顺序写入到目标文件中去 
        
         
        int CurrentLine;
        int Paraments; 
        int VariantIndex;
        int VariantCount;
        int VariantKind[100];
        int VariantType[100];
        int VariantHave[100];
        int VariantBelong[100];
        char VariantName[100][256];   //定义变量信息 
    
        char Temp[256];
    
    
        char Errors[20][256];         //保存了各种错误代码信息 
        int Error_Count;              //记录错误个数   
        char ErrorWord[256];          //记录错误信息  
    
        char Word[10][100][256];      //记录下每个模块中每个词的信息 
        int WordCount[10];            //记录每个模块里的单词个数  
        double Value[10][100];        //记录下每个词的变量属性 
        int Segment[100];             //返回每个模块的编号值 
        int Segment2[100];            //设置一个模块编号值的反查函数 
        int SegmentIndex;               
        int SegmentCount;
        
        int ParamentCount[100];       //记录参数个数
        char Parament[100][10][256];  //记录每个参数的名称 
        
        int RunLayer;
        int RunCount;                 //记录运行时刻调用函数的位置
                                      //包括层号和索引号  
        
        int Used[10];                 //在进行写操作时判断此模块是否被写过 
        int Begin;                    //每写一段的开始位置 
        int Index[10];                //记录每个段所写到的位置 
        
        int Layer;                    //段落层信息，遇到begin进栈，遇到end出栈 
        
        
    protected:
    
        void Initialize();            //初始化各个参数和变量 
        int CheckWords();             //第一步：检查所有的词是否在自己的作用域内出现  
       
        void DefineError();
        void CatchError(int num);     //对错误的处理  
        
        void GetWords();              //从文件中读取单词 
        
    public:
    
        int Compile();
        void InitialWrite();                    //初始化 
        void CreatCode(char* filename);         //将代码写入文件 
        void ChangeWords(int num,int i);        //将单词进行回写 
        void Write(int num);                    //将每个模块的代码写入文件
};

void runTime::DefineError()               //定义错误类型 
{
    strcpy(Errors[0]," not in it's active field ");
    
}

void runTime::InitialWrite()              //对写文件进行初始化，此段代码在CreateCode部分 
{
    RunLayer=0;
    RunCount=0;
    for(int i=0;i<10;i++)   Used[i]=0;

};


void runTime::CatchError(int num)         //将错误信息直接输出 
{
    Error_Count++;
    cout<<"Error ("<<Error_Count<<"): \""<<ErrorWord<<"\" "<<Errors[num]<<" at line: "<<CurrentLine<<endl;
    
        
                
}

void runTime::Initialize()
{
    
    fintable.open("wordtable2.txt");        //打开单词表文件 
    Error_Count=0;                          //将各个变量进行初始化 
    DefineError();
    
    while(fintable>>VariantIndex)
          fintable>>VariantKind[VariantIndex]
                  >>VariantType[VariantIndex]
                  >>VariantName[VariantIndex]
                  >>VariantHave[VariantIndex]
                  >>VariantBelong[VariantIndex];
                                            //将变量信息从单词表中读取出 
    

}

int runTime::CheckWords()
{
    int Value;
    //int state=0;
    fin1.open("sentence.txt");
    
    while(fin1>>CurrentLine>>Paraments)
    {
        while(fin1>>Temp)
        {
            if(strcmp(Temp,";")==0) break;
            
            if(strcmp(Temp,"ids")==0)
            {
                fin1>>Value;
                
                if((VariantBelong[Value]!=0)&&(VariantBelong[Value]/100!=0)&&(VariantBelong[Value]/100!=Paraments))
                                            //它的声明既不在主程序中也不在此模块内，说明调用错误 
                {
                    /*
                        输出错误信息 
                    */
                    strcpy(ErrorWord,VariantName[Value]);
                    CatchError(0);
                    
                }
            }
        }
    }
    if(Error_Count==0)