typecheck.h

一个Pascal子集语言的编译器

//TypeCheck.h


//inputfile:  sentence.txt, wordtable2.txt
//outputfile: typecheck.txt

#ifndef TYPECHECK_H_
#define TYPECHECK_H_

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

/*****************************************************************************************
    类型检查器
     
    所实现功能：
     
    1。根据语法分析器所提供的每个语句，及标识符表进行分析，并显示出错误信息。 
    2。类型检查的内容包括：
            （1）判断等式两边是否类型相同或相容
            （2）判断赋值表达式两边是否类型相同或相容
            （3）判断函数与过程使用时的参数个数及类型是否正确 
    3。类型代码如下：
             
             整数       101
             浮点数     102
             布尔型     103 
             
    4。所需要分析的语句如下：
            
            ids ;
            ids ( ids_list ) ;
            ids assignop simple ;
            simple relop simple ;
            write ( simple_list ) ; 
            
            
       simple_list   -> simple
                        | 
                        simple , simple_list
                        
       id_list       -> id
                        |
                        id , id_list   
                                                    
       simple        -> factor                                        
                        | 
                        factor op simple                               
                        
       factor        -> ids                                             
                        |
                        number                                       
                        |
                        not factor                                   
                        |
                        true                                          
                        |
                        false                                         
                        |
                        ( simple )                                    
                    
     
     
      
******************************************************************************************/
class typeCheck
{
    private:
    
        int CurrentLine;              //记录当前的行号信息，此信息是从语法分析结果中得到的 
        int Parament;                 //记录当前语句所在的函数段
    
        int VariantIndex;
        int VariantCount;
        int VariantKind[100];
        int VariantType[100];
        int VariantHave[100];
        int VariantBelong[100];
        char VariantName[100][256];   //定义变量信息 
    
        ifstream fin;
        ifstream fin1;
        ifstream fin2;
        ifstream fintable;
        ofstream fout;                //文件指针的定义  
        
        char Errors[20][256];         //保存了各种错误代码信息 
        int Error_Count;              //记录错误信息   
        
        char Word[100][256];          //用于记录当前所读到的单词 
        int State;                    //记录当前状态 
        int Count;                    //记录一个语句中的单词数 
        int Index;                    //扫描各个单词的指针 
        double Value[100];          //记录各个变量的编号信息及数字的真实值 
        
        char SimpleWord[100][256];
        double SimpleValue[100];
        int SimpleCount;
        
        int LeftType;
        int RightType;                //记录左右两边的类型 
    
    protected:
    
        void Initialize();            //初始化
        int Check();                  //对信息进行检查 
        void CatchError(int num);     //输出错误信息 
        void DefineError();           //定义各种错误信息
        void Prepare();               //首先将输入文件进行转化 
        int simpleCheck();            //对简单表达式进行检查  
        void TestVariant();           //判断是否有重复变量  
              
    public:
    
        int Compile(char* filename);
    
};

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

void typeCheck::TestVariant()
{
    for(int i=1;i<VariantCount;i++)
        for(int j=i+1;j<=VariantCount;j++)
        if(strcmp(VariantName[i],VariantName[j])==0)
            if(VariantBelong[i]/100==VariantBelong[j]/100)  //如果变量所属于的位置都一样则输出错误信息 
            {
                Value[1]=i;
                CatchError(3);
                
            }
    
    
}

void typeCheck::DefineError()                           //定义错误类型 
{
    strcpy(Errors[0]," is not a procedure. ");
    strcpy(Errors[1]," parament number not matched. ");
    strcpy(Errors[2]," assignment not adapt. ");
    strcpy(Errors[3]," redeclared variant ");           //重复定义变量，或是一个名称变量有双重意义 
    strcpy(Errors[6]," Equation can't match. ");        //等式左右的变量类型不相同 
    strcpy(Errors[10]," information may missing. ");    //warning信息 
    
}



void typeCheck::CatchError(int num)         //将错误信息直接输出 
{
    if(num<6)
    {
    Error_Count++;
    cout<<"Error ("<<Error_Count<<"): \""<<VariantName[int(Value[1])]<<"\" "<<Errors[num]<<" at line: "<<CurrentLine<<endl;
    }
    else if(num==6)
    {
    Error_Count++;
    cout<<"Error ("<<Error_Count<<"): \"=\" "<<Errors[num]<<" at line: "<<CurrentLine<<endl;
    
    }
    else
    {
    cout<<"Warning : \""<<VariantName[int(Value[1])]<<"\" "<<Errors[num]<<" at line: "<<CurrentLine<<endl;
    
    }
    
}



int typeCheck::simpleCheck()                //返回一个表达式的值 
{
    int state=101;
    int value;
    for(int i=0;i<=SimpleCount;i++)
    {
        if(strcmp(SimpleWord[i],"ids")==0)          //如果是变量则将其返回值 
        {
            value=VariantType[int(SimpleValue[i])];
            value=value%100+100;
        }
        else if(strcmp(SimpleWord[i],"number")==0)
        {
            if(SimpleValue[i]==int(SimpleValue[i])) //说明读进来的 number是整数 
                value=101;
            else                                    //否则是浮点数
                value=102;
        }
        else if(strcmp(SimpleWord[i],"op")==0)
        {
            if(SimpleValue[i]==4)                   //是除法
                value=102; 
            else
                value=101;    
        }
        
        switch(state)
        {
            case 101:if(value==102) state=102;
                     break;
            case 102:break;
            case 103:if(value==102) state=102;
                     if(value==101) state=101;
                     break;
            default:break;
        }
        
    }
    return state;
}

void typeCheck::Prepare()                   
    //此函数的主要作用是将带有函数和过程名的代码提取出来，单独作为一行 
{
    fin1.open("sentence.txt");               //打开输入文件 
    fout.open("temp2.txt");                 //打开输出文件 
    
    int state=0;                            //利用状态表示当前是在写入还是在记录 
    double TempValue;                          //记录变量的属性 
    int TempCount;
    char NowWord[256],NextWord[256];        //记录当前词和下一个词 
    
    while(fin1>>NextWord)
    {
    if((strcmp(NextWord,"ids")==0)||(strcmp(NextWord,"number")==0))
        fin1>>TempValue;
        
        if(state==0)                             //当前为写入状态 
        {