精华内容
下载资源
问答
  • 致 Python 初学者

    万次阅读 多人点赞 2019-11-10 00:03:26
    3. 习惯使用IDLE,这是学习python最好的方式 解释型语言的优势,就是可以写一句执行一句,想到哪儿写到哪儿,不必像编译型语言那样得把程序全部写完,编译成功后才能运行。我特别喜欢使用python的IDLE,甚至拿它当...
    展开全文
  • 实验目的:对循环语句和条件判断语句编写词法分析编译程序,只能通过一扫描完成。(用c++实现) 实验要求: (1)关键字: for if then else while do 所有关键字都是小写。 (2)运算符和分隔符: : = + - * / ...
    实验目的:对循环语句和条件判断语句编写词法分析编译程序,只能通过一遍扫描完成。(用c++实现)
    实验要求: 
    (1)关键字: 
    for if then else while do 
    所有关键字都是小写。 
    (2)运算符和分隔符: 
    : = + - * / < > <= <> >= ; ( ) # 
    (3)其他标识符(ID)和整型常数(NUM),通过以下正规式定义: 
    ID=letter(letter | digit)* 
    NUM=digit digit* 
    (4)空格由空白、制表符和换行符组成。空格一般用来分隔ID、NUM、运算符、分隔符和关键字,词法分析阶段通常被忽略。 
    (5) 具有一定的出错处理功能。法单元对应的词法记号如下: 
    
    > 词法单元 词法记号 词法单元 词法记号  for 1 : 17  if 2 := 18  then 3 < 20  else 4 <> 21
    > while 5 <= 22  do 6 > 23  letter(letter+digit)* 10 >= 24  digit digit*
    > 11 = 25 
    > + 13 ; 26 
    > - 14 ( 27 
    > * 15 ) 28  / 16 # 0
    > 
    > 词法单元 词法记号 词法单元 词法记号  for 1 : 17  if 2 := 18  then 3 < 20  else 4 <> 21
    > while 5 <= 22  do 6 > 23  letter(letter+digit)* 10 >= 24  digit digit*
    > 11 = 25 
    > + 13 ; 26 
    > - 14 ( 27 
    > * 15 ) 28  / 16 # 0
    
    词法分析程序的功能 
    输入:源程序 
    输出:二元组(词法记号,属性值/其在符号表中的位置)构成的序列。
    
    例如:对源程序 
    x:=5; if (x>0) then x:=2*x+1/3; else x:=2/x; # 
    经词法分析后输出如下序列: 
    (10,’x’)(18, :=) (11,5) (26, ;) (2, if ) (27,( )……
    
    > 1.几点说明:  (1)关键字表的初值。  关键字作为特殊标识符处理,把它们预先安排在一张表格中(称为关键字表),当扫描程序识别出标识符,查关键字表。如能查到匹配的单词,则该单词的关键字,否则为一般标识符。关键表为一个字符串数组,其描述如下:
    > char *keyword[6]={”for”, ”if”, ”then” ,”else”,”while”, ”do” };
    > 
    > (2)程序中需要用到的主要变量为 token , id和num.  1)id用来存放构成词法单元的字符串; 
    > 2)num用来存放整数(可以扩展到浮点数和科学计数法表示);  3)token用来存放词法单元的词法记号。
    
    可以参考下面的do{ 
    lexical(); //将词法单元对应的记号保存到token中,属性值保存到num或者id中
    switch(token) { 
    case 11: printf ("(token, %d\n) ", num); break; 
    case -1: printf("error!\n");break; 
    default: printf("(%d,%s)\n", token, id); 
    } 
    }while (token!=0); 
    
    
    

    我的代码



    #include <iostream>
    #include<string>
    #include<map>
    #include<sstream>
    #include <fstream>
    #include <list>
    #define max 100
    using namespace std;
    static map<string ,int> dictionary;
    void init()
    {
        dictionary.insert(map<string,int>::value_type("for",1));
        dictionary.insert(map<string,int>::value_type("if",2));
        dictionary.insert(map<string,int>::value_type("then",3));
        dictionary.insert(map<string,int>::value_type("else",4));
        dictionary.insert(map<string,int>::value_type("while",5));
        dictionary.insert(map<string,int>::value_type("do",6));
        dictionary.insert(map<string,int>::value_type("var",10));
        dictionary.insert(map<string,int>::value_type("num",11));
        dictionary.insert(map<string,int>::value_type("+",13));
        dictionary.insert(map<string,int>::value_type("-",14));
        dictionary.insert(map<string,int>::value_type("*",15));
        dictionary.insert(map<string,int>::value_type("/",16));
        dictionary.insert(map<string,int>::value_type(":",17));
        dictionary.insert(map<string,int>::value_type(":=",18));
        dictionary.insert(map<string,int>::value_type("<",19));
        dictionary.insert(map<string,int>::value_type("<>",21));
        dictionary.insert(map<string,int>::value_type("<=",22));
        dictionary.insert(map<string,int>::value_type(">",23));
        dictionary.insert(map<string,int>::value_type(">=",24));
        dictionary.insert(map<string,int>::value_type("=",25));
        dictionary.insert(map<string,int>::value_type(";",26));
        dictionary.insert(map<string,int>::value_type("(",27));
        dictionary.insert(map<string,int>::value_type(")",28));
        dictionary.insert(map<string,int>::value_type("#",0));
    
    }
    int findbykey(string key)
    {
       map<string,int >::iterator l_it;;
       l_it=dictionary.find(key);
       if(l_it==dictionary.end())
                 return -1;
       else
        return l_it->second;
    }
    string keyword[6]={"for","if","then","else","while","do"};
    bool isletter(char a)
    {
        if((a>='a'&&a<='z')||(a>='A'&&a<='Z'))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool isdigit(char a)
    {
        if(a>='0'&&a<='9')
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool iskeyw(string keywords)
    {
        for(int i=0;i<6;i++)
        {
            if(keyword[i]==keywords)
            {
                return true;
            }
    
        }
    
            return false;
    
    }
    bool isvar(string var) //ID=letter(letter | digit)*
    {
           if(isletter(var[0]))
           {
               for(int i=0;i<var.length();i++)
               {
                   if(isletter(var[i])||isdigit(var[i]))
                   {
    
                   }
                   else
                   {
                       return false;
                   }
               }
               return true;
           }
           else
           {
               return false;
           }
    }
    bool isnum(string num)     //NUM=digit digit*   (xiaoshudian
    {
        if(isdigit(num[0]))
           {
               int flag1=1;
               int flag2=1;
               for(int i=0;i<num.length();i++)
               {
                   if(isdigit(num[i]))
                   {
    
                   }
                   else if(num[i]=='.'&&isdigit(num[i+1])&&flag1)
                           {
                               flag1=0;
                           }
                   else if (((num[i]=='E'||num[i]=='e')&&(num[i+1]=='+'||num[i+1]=='-'||isdigit(num[i+1]))&&flag2))
                   {
                       cout<<num[i]<<"dddd"<<endl;
                        flag2=0;
                   }
                   else if((num[i]=='+'||num[i]=='-')&&isdigit(num[i+1]))
                   {
    
                   }
                   else
                   {
                       return false;
                   }
               }
               return true;
           }
           else
           {
               return false;
           }
    }
    string to_String(int n)
    {
        string temp;
        stringstream ss;
        ss<<n;
       temp = ss.str();
    
        return temp;
    }
    string packet(string test,int type)
    {
           int a;
            if(type==0)
            {
                a=findbykey(test);
            }
            else if(type==1)
            {
             a=findbykey("var");
            }
            else if(type==2)
            {
             a=findbykey("num");
            }
    
             string req="";
             string aa;
             aa=to_String(a);
             req+="(" + aa;
             req+=",";
             req+=test;
             req+=") ";
             return req;
    }
    string texthandle(string test,int linenum)
    {
         if(iskeyw(test))
         {
              return packet(test,0);
         }
         else if(isvar(test))
         {
             return packet(test,1);
         }
         else if(isnum(test))
         {
             return packet(test,2);
         }
         else if(-1==findbykey(test))
         {
               string b="There are some errors in";
               string bb;
              bb= to_String(linenum);
               b+=bb;
               return  b;
         }
         else
         {
    
             return packet(test,0);
         }
    }
    
    void File_output(char* filename)
    {
         int linenum=0;
         string test;
         fstream file;
         string pice;
          string expression="";
         list<string> words;
         file.open(filename,ios_base::in|ios_base::out) ;
         if(!file)
         {
             cout<<"error"<<endl;
         }
         else
         {
              while(getline(file, test))
            {
                  linenum++;
                  //处理逻辑
               /*
                  划分单词,. 标点
    
               */
                string temp="";
               for(int i=0;i<test.length();i++)
               {
    
    
                   if( test[i] == ' ' )
                   {
    
                   }
                   else
                   {
    
                        temp+=test[i];
                        if(test[i+1]==' '||test[i+1]=='\0')
                        {
                            words.push_back(temp);
                            pice=texthandle(temp,linenum);
                            expression+="\n";
                            expression+=pice;
                            temp="";
                        }
                   }
    
               }
              }
              //对单词链表进行处理
    
             //list<string>::iterator i;
              //for (i = words.begin(); i != words.end(); ++i)
                     //测试
                  // cout<<*i<<endl;
            cout<<expression<<endl;
         }
    
    
    
    }
    int main()
    {
        init();
        File_output("a.txt");
       // int b =findbykey("for");
        //cout<<b<<endl;
        return 0;
    }

    “`

    展开全文
  • 该程序是用C语言对一个简单的子集编写一个一扫描的编译程序。程序任务是从字符串表示的源程序中识别出具有独立意义的单词符号。
  • PL/0语言编译程序分析

    千次阅读 2016-10-03 11:26:53
    PL/0语言编译程序采用以语法分析为核心、一扫描的编译方法。词法分析和代码生成作为独立的子程序供语法分析程序调用。语法分析的同时,提供了出错报告和出错恢复的功能。在源程序没有错误编译通过的情况下,调用

    PL/0语言是Pascal语言的一个子集,我们这里分析的PL/0的编译程序包括了对PL/0语言源程序进行分析处理、编译生成类PCODE代码,并在虚拟机上解释运行生成的类PCODE代码的功能。

    PL/0语言编译程序采用以语法分析为核心、一遍扫描的编译方法。词法分析和代码生成作为独立的子程序供语法分析程序调用。语法分析的同时,提供了出错报告和出错恢复的功能。在源程序没有错误编译通过的情况下,调用类PCODE解释程序解释执行生成的类PCODE代码。

    词法分析子程序分析:

    词法分析子程序名为getsym,功能是从源程序中读出一个单词符号(token),把它的信息放入全局变量sym、id和num中,语法分析器需要单词时,直接从这三个变量中获得。(注意!语法分析器每次用完这三个变量的值就立即调用getsym子程序获取新的单词供下一次使用。而不是在需要新单词时才调用getsym过程。)getsym过程通过反复调用getch子过程从源程序过获取字符,并把它们拼成单词。getch过程中使用了行缓冲区技术以提高程序运行效率。

    词法分析器的分析过程:调用getsym时,它通过getch过程从源程序中获得一个字符。如果这个字符是字母,则继续获取字符或数字,最终可以拼成一个单词,查保留字表,如果查到为保留字,则把sym变量赋成相应的保留字类型值;如果没有查到,则这个单词应是一个用户自定义的标识符(可能是变量名、常量名或是过程的名字),把sym置为ident,把这个单词存入id变量。查保留字表时使用了二分法查找以提高效率。如果getch获得的字符是数字,则继续用getch获取数字,并把它们拼成一个整数,然后把sym置为number,并把拼成的数值放入num变量。如果识别出其它合法的符号(比如:赋值号、大于号、小于等于号等),则把sym则成相应的类型。如果遇到不合法的字符,把sym置成nul。

    语法分析子程序分析:

    语法分析子程序采用了自顶向下的递归子程序法,语法分析同时也根据程序的语意生成相应的代码,并提供了出错处理的机制。语法分析主要由分程序分析过程(block)、常量定义分析过程(constdeclaration)、变量定义分析过程(vardeclaration)、语句分析过程(statement)、表达式处理过程(expression)、项处理过程(term)、因子处理过程(factor)和条件处理过程(condition)构成。这些过程在结构上构成一个嵌套的层次结构。除此之外,还有出错报告过程(error)、代码生成过程(gen)、测试单词合法性及出错恢复过程(test)、登录名字表过程(enter)、查询名字表函数(position)以及列出类PCODE代码过程(listcode)作过语法分析的辅助过程。

    由PL/0的语法图可知:一个完整的PL/0程序是由分程序和句号构成的。因此,本编译程序在运行的时候,通过主程序中调用分程序处理过程block来分析分程序部分(分程序分析过程中还可能会递归调用block过程),然后,判断最后读入的符号是否为句号。如果是句号且分程序分析中未出错,则是一个合法的PL/0程序,可以运行生成的代码,否则就说明源PL/0程序是不合法的,输出出错提示即可。

    下面按各语法单元分析PL/0编译程序的运行机制。

    分程序处理过程:

    语法分析开始后,首先调用分程序处理过程(block)处理分程序。过程入口参数置为:0层、符号表位置0、出错恢复单词集合为句号、声明符或语句开始符。进入block过程后,首先把局部数据段分配指针设为3,准备分配3个单元供运行期存放静态链SL、动态链DL和返回地址RA。然后用tx0记录下当前符号表位置并产生一条jmp指令,准备跳转到主程序的开始位置,由于当前还没有知到主程序究竟在何处开始,所以jmp的目标暂时填为0,稍后再改。同时在符号表的当前位置记录下这个jmp指令在代码段中的位置。在判断了嵌套层数没有超过规定的层数后,开始分析源程序。首先判断是否遇到了常量声明,如果遇到则开始常量定义,把常量存入符号表。接下去用同样的方法分析变量声明,变量定义过程中会用dx变量记录下局部数据段分配的空间个数。然后如果遇到procedure保留字则进行过程声明和定义,声明的方法是把过程的名字和所在的层次记入符号表,过程定义的方法就是通过递归调用block过程,因为每个过程都是一个分程序。由于这是分程序中的分程序,因此调用block时需把当前的层次号lev加一传递给block过程。分程序声明部分完成后,即将进入语句的处理,这时的代码分配指针cx的值正好指向语句的开始位置,这个位置正是前面的jmp指令需要跳转到的位置。于是通过前面记录下来的地址值,把这个jmp指令的跳转位置改成当前cx的位置。并在符号表中记录下当前的代码段分配地址和局部数据段要分配的大小(dx的值)。生成一条int指令,分配dx个空间,作为这个分程序段的第一条指令。下面就调用语句处理过程statement分析语句。分析完成后,生成操作数为0的opr指令,用于从分程序返回(对于0层的主程序来说,就是程序运行完成,退出)。

    常量定义过程:

    通过循环,反复获得标识符和对应的值,存入符号表。符号表中记录下标识符的名字和它对应的值。

    变量定义过程:

    与常量定义类似,通过循环,反复获得标识符,存入符号表。符号表中记录下标识符的名字、它所在的层及它在所在层中的偏移地址。

    语句处理过程:

    语句处理过程是一个嵌套子程序,通过调用表达式处理、项处理、因子处理等过程及递归调用自己来实现对语句的分析。语句处理过程可以识别的语句包括赋值语句、read语句、write语句、call语句、if语句、while语句。当遇到begin/end语句时,就递归调用自己来分析。分析的同时生成相应的类PCODE指令。

    赋值语句的处理:

    首先获取赋值号左边的标识符,从符号表中找到它的信息,并确认这个标识符确为变量名。然后通过调用表达式处理过程算得赋值号右部的表达式的值并生成相应的指令保证这个值放在运行期的数据栈顶。最后通过前面查到的左部变量的位置信息,生成相应的sto指令,把栈顶值存入指定的变量的空间,实现了赋值操作。

    read语句的处理:

    确定read语句语法合理的前提下(否则报错),生成相应的指令:第一条是16号操作的opr指令,实现从标准输入设备上读一个整数值,放在数据栈顶。第二条是sto指令,把栈顶的值存入read语句括号中的变量所在的单元。

    write语句的处理:

    与read语句相似。在语法正确的前提下,生成指令:通过循环调用表达式处理过程分析write语句括号中的每一个表达式,生成相应指令保证把表达式的值算出并放到数据栈顶并生成14号操作的opr指令,输出表达式的值。最后生成15号操作的opr指令输出一个换行。

    call语句的处理:

    从符号表中找到call语句右部的标识符,获得其所在层次和偏移地址。然后生成相应的cal指令。至于调用子过程所需的保护现场等工作是由类PCODE解释程序在解释执行cal指令时自动完成的。

    if语句的处理:

    按if语句的语法,首先调用逻辑表达式处理过程处理if语句的条件,把相应的真假值放到数据栈顶。接下去记录下代码段分配位置(即下面生成的jpc指令的位置),然后生成条件转移jpc指令(遇0或遇假转移),转移地址未知暂时填0。然后调用语句处理过程处理then语句后面的语句或语句块。then后的语句处理完后,当前代码段分配指针的位置就应该是上面的jpc指令的转移位置。通过前面记录下的jpc指令的位置,把它的跳转位置改成当前的代码段指针位置。

    begin/end语句的处理:

    通过循环遍历begin/end语句块中的每一个语句,通过递归调用语句分析过程分析并生成相应代码。

    while语句的处理:

    首先用cx1变量记下当前代码段分配位置,作为循环的开始位置。然后处理while语句中的条件表达式生成相应代码把结果放在数据栈顶,再用cx2变量记下当前位置,生成条件转移指令,转移位置未知,填0。通过递归调用语句分析过程分析do语句后的语句或语句块并生成相应代码。最后生成一条无条件跳转指令jmp,跳转到cx1所指位置,并把cx2所指的条件跳转指令的跳转位置改成当前代码段分配位置。

    表达式、项、因子处理:

    根据PL/0语法可知,表达式应该是由正负号或无符号开头、由若干个项以加减号连接而成。而项是由若干个因子以乘除号连接而成,因子则可能是一个标识符或一个数字,或是一个以括号括起来的子表达式。根据这样的结构,构造出相应的过程,递归调用就完成了表达式的处理。把项和因子独立开处理解决了加减号与乘除号的优先级问题。在这几个过程的反复调用中,始终传递fsys变量的值,保证可以在出错的情况下跳过出错的符号,使分析过程得以进行下去。

    逻辑表达式的处理:

    首先判断是否为一元逻辑表达式:判奇偶。如果是,则通过调用表达式处理过程分析计算表达式的值,然后生成判奇指令。如果不是,则肯定是二元逻辑运算符,通过调用表达式处理过程依次分析运算符左右两部分的值,放在栈顶的两个空间中,然后依不同的逻辑运算符,生成相应的逻辑判断指令,放入代码段。

    判断单词合法性与出错恢复过程分析:

    本过程有三个参数,s1、s2为两个符号集合,n为出错代码。本过程的功能是:测试当前符号(即sym变量中的值)是否在s1集合中,如果不在,就通过调用出错报告过程输出出错代码n,并放弃当前符号,通过词法分析过程获取一下单词,直到这个单词出现在s1或s2集合中为止。

    这个过程在实际使用中很灵活,主要有两个用法:

    在进入某个语法单位时,调用本过程,检查当前符号是否属于该语法单位的开始符号集合。若不属于,则滤去开始符号和后继符号集合外的所有符号。

    在语法单位分析结束时,调用本过程,检查当前符号是否属于调用该语法单位时应有的后继符号集合。若不属于,则滤去后继符号和开始符号集合外的所有符号。

    通过这样的机制,可以在源程序出现错误时,及时跳过出错的部分,保证语法分析可以继续下去。

    语法分析过程中调用的其它子过程相对比较简单,请参考源程序的注释。

    类PCODE代码解释执行过程分析

    这个过程模拟了一台可以运行类PCODE指令的栈式计算机。它拥有一个栈式数据段用于存放运行期数据、拥有一个代码段用于存放类PCODE程序代码。同时还拥用数据段分配指针、指令指针、指令寄存器、局部段基址指针等寄存器。

    解释执行类PCODE代码时,数据段存储分配方式如下:

    对于源程序的每一个过程(包括主程序),在被调用时,首先在数据段中开辟三个空间,存放静态链SL、动态链DL和返回地址RA。静态链记录了定义该过程的直接外过程(或主程序)运行时最新数据段的基地址。动态链记录调用该过程前正在运行的过程的数据段基址。返回地址记录了调用该过程时程序运行的断点位置。对于主程序来说,SL、DL和RA的值均置为0。静态链的功能是在一个子过程要引用它的直接或间接父过程(这里的父过程是按定义过程时的嵌套情况来定的,而不是按执行时的调用顺序定的)的变量时,可以通过静态链,跳过个数为层差的数据段,找到包含要引用的变量所在的数据段基址,然后通过偏移地址访问它。

    在过程返回时,解释程序通过返回地址恢复指令指针的值到调用前的地址,通过当前段基址恢复数据段分配指针,通过动态链恢复局部段基址指针。实现子过程的返回。对于主程序来说,解释程序会遇到返回地址为0的情况,这时就认为程序运行结束。

    解释程序过程中的base函数的功能,就是用于沿着静态链,向前查找相差指定层数的局部数据段基址。这在使用sto、lod等访问局部变量的指令中会经常用到。

    类PCODE代码解释执行的部分通过循环和简单的case判断不同的指令,做出相应的动作。当遇到主程序中的返回指令时,指令指针会指到0位置,把这样一个条件作为终至循环的条件,保证程序运行可以正常的结束。

    以下源程序是以清华大学出版社《编译原理》中的源代码为基础作了少量改动而成。

    程序在Turbo Pascal 7.0上编译运行通过。

    1. ************************************************************************************  
    2. program pl0(fa,fa1,fa2); (* PL/0编译程序与代码生成解释运行程序 *)  
    3. (* PL/0 compiler with code generation *)  
    4. label 99; (* 声明出错跳转标记 *)  
    5. (* 在Turbo Pascal 7.0中已不允许跨过程的GOTO转移,因此后面的GOTO语句均被我去除了,因此这里的label也没有意义了 *)  
    6. const (* 常量定义 *)  
    7.   norw = 13;     (* of reserved words *) (* 保留字的个数 *)  
    8.   txmax = 100;   (* length of identifier table *) (* 标识符表的长度(容量) *)  
    9.   nmax = 14;     (* max number of digits in numbers *) (* 数字允许的最长位数 *)  
    10.   al = 10;       (* length of identifiers *) (* 标识符最长长度 *)  
    11.   amax = 2047;   (* maximum address *) (* 寻址空间 *)  
    12.   levmax = 3;    (* max depth of block nesting *) (* 最大允许的块嵌套层数 *)  
    13.   cxmax = 200;   (* size of code array *) (* 类PCODE目标代码数组长度(可容纳代码行数) *)  
    14. type (* 类型定义 *)  
    15.   symbol = (nul, ident, number, plus, minus, times, slash, oddsym,  
    16.             eql, neq, lss, leq, gtr, geq, lparen, rparen, comma,  
    17.             semicolon, period, becomes, beginsym, endsym, ifsym,  
    18.             thensym, whilesym, writesym, readsym, dosym, callsym,  
    19.             constsym, varsym, procsym); (* symobl类型标识了不同类型的词汇 *)  
    20.   alfa = packed array[1..al] of char; (* alfa类型用于标识符 *)  
    21.   object1 = (constant, variable, procedur); (* object1为三种标识符的类型 *)  
    22.   (* 原程序在此使用object作为类型名称,在支持面向对象的Turbo Pascal 7.0中编译不能通过 *)  
    23.   (* wirth used the word "procedure" there, whick won't work! *)  
    24.   (* 上面一行是课本上的程序清单中的注释,说本程序的原作者Wirth在这里用了procedure这个词作为标识符类型,是不可以的。  
    25.      事实上Wirth原本在这里用的词是prozedure,是可以的。 *)  
    26.   symset = set of symbol; (* symset是symbol类型的一个集合类型,可用于存放一组symbol *)  
    27.   fct = (lit, opr, lod, sto, cal, int, jmp, jpc); (* fct类型分别标识类PCODE的各条指令 *)  
    28.   instruction = packed record  
    29.     f: fct;       (* function code *)  
    30.     l: 0..levmax; (* level *)  
    31.     a: 0..amax;   (* displacement addr *)  
    32.   end; (* 类PCODE指令类型,包含三个字段:指令f、层差l和另一个操作数a *)  
    33.   (*   
    34.      lit 0, a  load constant a  
    35.      opr 0, a  execute opr a  
    36.      lod l, a  load variable l, a  
    37.      sto l, a  store variable l, a  
    38.      cal l, a  call procedure a at level l  
    39.      int 0, a  increment t-register by a  
    40.      jmp 0, a  jump to a  
    41.      jpc 0, a  jump conditional to a   
    42.   *)  
    43. var (* 全局变量定义 *)  
    44.   fa: text; (* 文本文件fa用于列出源程序 *)  
    45.   fa1, fa2: text; (* 文本文件fa1用于列出类PCODE代码、fa2用于记录解释执行类PCODE代码的过程 *)  
    46.   listswitch: boolean; (* true set list object code *) (* 如果本变量置true,程序编译后将为列出类PCODE代码,  
    47.                                                           否则不列出类PCODE代码 *)  
    48.   ch: char; (* last char read *) (* 主要用于词法分析器,存放最近一次从文件中读出的字符 *)  
    49.   sym: symbol; (* last symbol read *) (* 词法分析器输出结果之用,存放最近一次识别出来的token的类型 *)  
    50.   id: alfa;  (* last identifier read *) (* 词法分析器输出结果之用,存放最近一次识别出来的标识符的名字 *)  
    51.   num: integer; (* last number read *) (* 词法分析器输出结果之用,存放最近一次识别出来的数字的值 *)  
    52.   cc: integer;  (* character count *) (* 行缓冲区指针 *)   
    53.   ll: integer;  (* line length *) (* 行缓冲区长度 *)  
    54.   kk: integer;  (* 引入此变量是出于程序性能考虑,见getsym过程注释 *)  
    55.   cx: integer;  (* code allocation index *) (* 代码分配指针,代码生成模块总在cx所指位置生成新的代码 *)  
    56.   line: array[1..81] of char; (* 行缓冲区,用于从文件读出一行,供词法分析获取单词时之用 *)  
    57.   a: alfa; (* 词法分析器中用于临时存放正在分析的词 *)  
    58.   code: array[0..cxmax] of instruction; (* 生成的类PCODE代码表,存放编译得到的类PCODE代码 *)  
    59.   word: array[1..norw] of alfa; (* 保留字表 *)  
    60.   wsym: array[1..norw] of symbol; (* 保留字表中每一个保留字对应的symbol类型 *)  
    61.   ssym: array[' '..'^'] of symbol; (* 一些符号对应的symbol类型表 *)  
    62.     (* wirth uses "array[char]" here *)  
    63.   mnemonic: array[fct] of packed array[1..5] of char;(* 类PCODE指令助记符表 *)  
    64.   declbegsys, statbegsys, facbegsys: symset; (* 声明开始、表达式开始和项开始符号集合 *)  
    65.   table: array[0..txmax] of record (* 符号表 *)  
    66.     name: alfa; (* 符号的名字 *)  
    67.     case kind: object1 of (* 符号的类型 *)  
    68.       constant: (* 如果是常量名 *)  
    69.         (val: integer); (* val中放常量的值 *)  
    70.       variable, procedur:  (* 如果是变量名或过程名 *)  
    71.         (level, adr, size: integer) (* 存放层差、偏移地址和大小 *)  
    72.         (* "size" lacking in orginal. I think it belons here *)  
    73.   end;  
    74.   fin, fout: text; (* fin文本文件用于指向输入的源程序文件,fout程序中没有用到 *)  
    75.   fname: string; (* 存放PL/0源程序文件的文件名 *)  
    76.   (* 我修改的代码:原程序在此处使用alfa类型,无法在Turbo Pascal 7.0中通过,readln函数的参数不能为alfa型 *)  
    77.   err: integer; (* 出错总次数 *)  
    78. (* 出错处理过程error *)  
    79. (* 参数:n:出错代码 *)  
    80. procedure error(n: integer);  
    81. begin  
    82.   writeln('****', ' ': cc-1, '!', n:2); (* 在屏幕cc-1位置显示!与出错代码提示,由于cc  
    83.                                            是行缓冲区指针,所以!所指位置即为出错位置 *)  
    84.   writeln(fa1, '****', ' ': cc-1, '!', n:2); (* 在文件cc-1位置输出!与出错代码提示 *)  
    85.   err := err + 1 (* 出错总次数加一 *)  
    86. end (* error *);  
    87. (* 词法分析过程getsym *)  
    88. procedure getsym;  
    89. var   
    90.   i, j, k: integer;  
    91.   (* 读取原程序中下一个字符过程getch *)  
    92.   procedure getch;  
    93.   begin  
    94.     if cc = ll then (* 如果行缓冲区指针指向行缓冲区最后一个字符就从文件读一行到行缓冲区 *)  
    95.     begin  
    96.       if eof(fin) then (* 如果到达文件末尾 *)  
    97.       begin  
    98.         write('Program incomplete'); (* 出错,退出程序 *)  
    99.         close(fa);  
    100.         close(fa1);  
    101.         close(fin);  
    102.         halt(0);          
    103.         {goto 99}  
    104.         (* 我修改的代码,由于Turbo Pascal 7.0中不允许跨过程的goto,就只能用上面的方法退出程序了。 *)  
    105.       end;  
    106.       ll := 0; (* 行缓冲区长度置0 *)  
    107.       cc := 0; (* 行缓冲区指针置行首 *)  
    108.       write(cx: 4, ' '); (* 输出cx值,宽度为4 *)  
    109.       write(fa1, cx: 4, ' '); (* 输出cx值,宽度为4到文件 *)  
    110.       while not eoln(fin) do (* 当未到行末时 *)  
    111.       begin  
    112.         ll := ll + 1; (* 行缓冲区长度加一 *)  
    113.         read(fin, ch); (* 从文件读入一个字符到 ch *)  
    114.         write(ch); (* 在屏幕输出ch *)  
    115.         write(fa1, ch); (* 把ch输出到文件 *)  
    116.         line[ll] := ch; (* 把读到的字符存入行缓冲区相应的位置 *)  
    117.       end;  
    118.       (* 可见,PL/0源程序要求每行的长度都小于81个字符 *)  
    119.       writeln;   
    120.       ll := ll + 1; (* 行缓冲区长度加一,用于容纳即将读入的回车符CR *)  
    121.       read(fin, line[ll]);(* 把#13(CR)读入行缓冲区尾部 *)  
    122.       read(fin, ch); (* 我添加的代码。由于PC上文本文件换行是以#13#10(CR+LF)表示的,  
    123.                         所以要把多余的LF从文件读出,这里放在ch变量中是由于ch变量的  
    124.                         值在下面即将被改变,把这个多余值放在ch中没有问题 *)  
    125.       writeln(fa1);   
    126.     end;  
    127.     cc := cc + 1; (* 行缓冲区指针加一,指向即将读到的字符 *)  
    128.     ch := line[cc] (* 读出字符,放入全局变量ch *)  
    129.   end (* getch *);   
    130. begin (* getsym *)  
    131.   while (ch = ' ') or (ch = #13) do (* 我修改的代码:这句原来是用于读一个有效的字符  
    132.                                        (跳过读出的字符中多余的空格),但实际上还要跳  
    133.                                        过多余的回车 *)  
    134.     getch;   
    135.   if ch in ['a'..'z'] then (* 如果读出的字符是一个字母,说明是保留字或标识符 *)  
    136.   begin  
    137.     k := 0; (* 标识符缓冲区指针置0 *)  
    138.     repeat (* 这个循环用于依次读出源文件中的字符构成标识符 *)  
    139.       if k < al then (* 如果标识符长度没有超过最大标识符长度(如果超过,就取前面一部分,把多余的抛弃) *)  
    140.       begin  
    141.         k := k + 1;   
    142.         a[k] := ch;  
    143.       end;  
    144.       getch (* 读下一个字符 *)  
    145.     until not (ch in ['a'..'z','0'..'9']); (* 直到读出的不是字母或数字,由此可知PL/0的标识符构成规则是:  
    146.                                               以字母开头,后面跟若干个字母或数字 *)  
    147.     if k >= kk then (* 如果当前获得的标识符长度大于等于kk *)  
    148.       kk := k (* 令kk为当前标识符长度 *)  
    149.     else  
    150.       repeat (* 这个循环用于把标识符缓冲后部没有填入相应字母或空格的空间用空格补足 *)  
    151.         a[kk] := ' ';  
    152.         kk := kk - 1  
    153.       until kk = k;  
    154.     (* 在第一次运行这个过程时,kk的值为al,即最大标识符长度,如果读到的标识符长度小于kk,  
    155.        就把a数组的后部没有字母的空间用空格补足。  
    156.        这时,kk的值就成为a数组前部非空格字符的个数。以后再运行getsym时,如果读到的标识符长度大于等于kk,  
    157.        就把kk的值变成当前标识符的长度。  
    158.        这时就不必在后面填空格了,因为它的后面肯定全是空格。反之如果最近读到的标识符长度小于kk,那就需要从kk位置向前,  
    159.        把超过当前标识长度的空间填满空格。  
    160.        以上的这样一个逻辑,完全是出于程序性能的上考虑。其实完全可以简单的把a数组中a[k]元素以后的空间不管三七二十一全填空格。   
    161.     *)  
    162.     (* 下面开始二分法查找看读出的标识符是不是保留字之一 *)  
    163.     id := a; (* 最后读出标识符等于a *)  
    164.     i := 1; (* i指向第一个保留字 *)  
    165.     j := norw; (* j指向最后一个保留字 *)  
    166.     repeat  
    167.       k := (i + j) div 2; (* k指向中间一个保留字 *)  
    168.       if id <= word[k] then (* 如果当前的标识符小于k所指的保留字 *)  
    169.         j := k - 1; (* 移动j指针 *)  
    170.       if id >= word[k] then (* 如果当前的标识符大于k所指的保留字 *)  
    171.         i := k + 1 (* 移动i指针 *)  
    172.     until i > j; (* 循环直到找完保留字表 *)  
    173.     if i - 1 > j then (* 如果i - 1 > j表明在保留字表中找到相应的项,id中存的是保留字 *)  
    174.       sym := wsym[k] (* 找到保留字,把sym置为相应的保留字值 *)  
    175.     else  
    176.       sym := ident (* 未找到保留字,把sym置为ident类型,表示是标识符 *)  
    177.   end(* 至此读出字符为字母即对保留字或标识符的处理结束 *)  
    178.   else (* 如果读出字符不是字母 *)  
    179.     if ch in ['0'..'9'] then (* 如果读出字符是数字 *)  
    180.     begin (* number *) (* 开始对数字进行处理 *)  
    181.       k := 0; (* 数字位数 *)  
    182.       num := 0; (* 数字置为0 *)  
    183.       sym := number; (* 置sym为number,表示这一次读到的是数字 *)  
    184.       repeat (* 这个循环依次从源文件中读出字符,组成数字 *)  
    185.         num := 10 * num + (ord(ch) - ord('0')); (* num * 10加上最近读出的字符ASCII减'0'的ASCII得到相应的数值 *)  
    186.         k := k + 1; (* 数字位数加一 *)  
    187.         getch  
    188.       until not (ch in ['0'..'9']); (* 直到读出的字符不是数字为止 *)  
    189.       if k > nmax then (* 如果组成的数字位数大于最大允许的数字位数 *)  
    190.         error(30) (* 发出30号错 *)  
    191.     end(* 至此对数字的识别处理结束 *)  
    192.     else  
    193.       if ch = ':' then (* 如果读出的不字母也不是数字而是冒号 *)  
    194.       begin  
    195.         getch; (* 再读一个字符 *)  
    196.         if ch = '=' then (* 如果读到的是等号,正好可以与冒号构成赋值号 *)  
    197.         begin  
    198.           sym := becomes; (* sym的类型设为赋值号becomes *)  
    199.           getch (* 再读出下一个字 *)  
    200.         end  
    201.         else  
    202.           sym := nul; (* 如果不是读到等号,那单独的一个冒号就什么也不是 *)  
    203.       end(* 以上完成对赋值号的处理 *)  
    204.     else (* 如果读到不是字母也不是数字也不是冒号 *)  
    205.       if ch = '<' then (* 如果读到小于号 *)  
    206.       begin  
    207.         getch; (* 再读一个字符 *)  
    208.         if ch = '=' then (* 如果读到等号 *)  
    209.         begin  
    210.           sym := leq; (* 购成一个小于等于号 *)  
    211.           getch (* 读一个字符 *)  
    212.         end  
    213.         else (* 如果小于号后不是跟的等号 *)  
    214.           sym := lss (* 那就是一个单独的小于号 *)  
    215.       end  
    216.       else (* 如果读到不是字母也不是数字也不是冒号也不是小于号 *)  
    217.         if ch = '>' then (* 如果读到大于号,处理过程类似于处理小于号 *)  
    218.         begin  
    219.           getch; (* 再读一个字符 *)  
    220.           if ch = '=' then (* 如果读到等号 *)  
    221.           begin  
    222.             sym := geq; (* 购成一个大于等于号 *)  
    223.             getch (* 读一个字符 *)  
    224.           end  
    225.           else (* 如果大于号后不是跟的等号 *)  
    226.             sym := gtr (* 那就是一个单独的大于号 *)  
    227.         end  
    228.         else(* 如果读到不是字母也不是数字也不是冒号也不是小于号也不是大于号 *)  
    229.         begin (* 那就说明它不是标识符/保留字,也不是复杂的双字节操作符,应该是一个普通的符号 *)  
    230.           sym := ssym[ch]; (* 直接成符号表中查到它的类型,赋给sym *)  
    231.           getch (* 读下一个字符 *)  
    232.         end   
    233.   (* 整个if语句判断结束 *)  
    234. end (* getsym *);  
    235. (* 词法分析过程getsym总结:从源文件中读出若干有效字符,组成一个token串,识别它的类型  
    236.    为保留字/标识符/数字或是其它符号。如果是保留字,把sym置成相应的保留字类型,如果是  
    237.    标识符,把sym置成ident表示是标识符,于此同时,id变量中存放的即为保留字字符串或标识  
    238.    符名字。如果是数字,把sym置为number,同时num变量中存放该数字的值。如果是其它的操作符,  
    239.    则直接把sym置成相应类型。经过本过程后ch变量中存放的是下一个即将被识别的字符 *)  
    240. (* 目标代码生成过程gen *)  
    241. (* 参数:x:要生成的一行代码的助记符 *)  
    242. (*       y, z:代码的两个操作数 *)  
    243. (* 本过程用于把生成的目标代码写入目标代码数组,供后面的解释器解释执行 *)  
    244. procedure gen(x: fct; y, z: integer);  
    245. begin  
    246.   if cx > cxmax then (* 如果cx>cxmax表示当前生成的代码行号大于允许的最大代码行数 *)  
    247.   begin  
    248.     write('program too long'); (* 输出"程序太长",退出 *)  
    249.     close(fa);  
    250.     close(fa1);  
    251.     close(fin);  
    252.     halt(0)         
    253.     {goto 99}  
    254.     (* 我修改的代码,由于Turbo Pascal 7.0中不允许跨过程的goto,就只能用上面的方法退出程序了。 *)  
    255.   end;  
    256.   with code[cx] do (* 把代码写入目标代码数组的当前cx所指位置 *)  
    257.   begin  
    258.     f := x;  
    259.     l := y;  
    260.     a := z;  
    261.   end;  
    262.   cx := cx + 1 (* 移动cx指针指向下一个空位 *)  
    263. end (* gen *);  
    264. (* 测试当前单词是否合法过程test *)  
    265. (* 参数:s1:当语法分析进入或退出某一语法单元时当前单词符合应属于的集合 *)  
    266. (*       s2:在某一出错状态下,可恢复语法分析正常工作的补充单词集合 *)  
    267. (*       n:出错信息编号,当当前符号不属于合法的s1集合时发出的出错信息 *)  
    268. procedure test(s1, s2: symset; n: integer);  
    269. begin  
    270.   if not (sym in s1) then (* 如果当前符号不在s1中 *)  
    271.   begin  
    272.     error(n); (* 发出n号错误 *)  
    273.     s1 := s1 + s2; (* 把s2集合补充进s1集合 *)  
    274.     while not (sym in s1) do (* 通过循环找到下一个合法的符号,以恢复语法分析工作 *)  
    275.       getsym  
    276.   end  
    277. end (* test *);  
    278. (* 语法分析过程block *)  
    279. (* 参数:lev:这一次语法分析所在的层次 *)  
    280. (*       tx:符号表指针 *)  
    281. (*       fsys:用于出错恢复的单词集合 *)  
    282. procedure block(lev, tx: integer; fsys: symset);  
    283. var   
    284.   dx: integer; (* data allocation index *) (* 数据段内存分配指针,指向下一个被分配空间在数据段中的偏移位置 *)  
    285.   tx0: integer;  (* initial table index *) (* 记录本层开始时符号表位置 *)  
    286.   cx0: integer;  (* initial code index *) (* 记录本层开始时代码段分配位置 *)  
    287.   (* 登陆符号表过程enter *)  
    288.   (* 参数:k:欲登陆到符号表的符号类型 *)  
    289.   procedure enter(k: object1);  
    290.   begin (* enter object into table *)  
    291.     tx := tx + 1; (* 符号表指针指向一个新的空位 *)  
    292.     with table[tx] do (* 开始登录 *)  
    293.     begin  
    294.       name := id; (* name是符号的名字,对于标识符,这里就是标识符的名字 *)  
    295.       kind := k; (* 符号类型,可能是常量、变量或过程名 *)  
    296.       case k of (* 根据不同的类型进行不同的操作 *)  
    297.         constant: (* 如果是常量名 *)  
    298.         begin  
    299.           if num > amax then (* 在常量的数值大于允许的最大值的情况下 *)  
    300.           begin  
    301.             error(31); (* 抛出31号错误 *)  
    302.             num := 0; (* 实际登陆的数字以0代替 *)  
    303.           end;  
    304.           val := num (* 如是合法的数值,就登陆到符号表 *)  
    305.         end;  
    306.         variable: (* 如果是变量名 *)  
    307.         begin  
    308.           level := lev; (* 记下它所属的层次号 *)  
    309.           adr := dx; (* 记下它在当前层中的偏移量 *)  
    310.           dx := dx+1; (* 偏移量自增一,为下一次做好准备 *)  
    311.         end;  
    312.         procedur: (* 如果要登陆的是过程名 *)  
    313.           level := lev (* 记录下这个过程所在层次 *)  
    314.       end  
    315.     end  
    316.   end (* enter *);  
    317.   (* 登录符号过程没有考虑到重复的定义的问题。如果出现重复定义,则以最后一次的定义为准。 *)  
    318.     
    319.   (* 在符号表中查找指定符号所在位置的函数position *)  
    320.   (* 参数:id:要找的符号 *)  
    321.   (* 返回值:要找的符号在符号表中的位置,如果找不到就返回0 *)  
    322.   function position (id: alfa): integer;  
    323.   var   
    324.     i: integer;  
    325.   begin (* find identifier in table *)  
    326.     table[0].name := id; (* 先把id放入符号表0号位置 *)  
    327.     i := tx; (* 从符号表中当前位置也即最后一个符号开始找 *)  
    328.     while table[i].name <> id do (* 如果当前的符号与要找的不一致 *)  
    329.       i := i - 1; (* 找前面一个 *)  
    330.     position := i (* 返回找到的位置号,如果没找到则一定正好为0 *)  
    331.   end(* position *);  
    332.   (* 常量声明处理过程constdeclaration *)  
    333.   procedure constdeclaration;  
    334.   begin  
    335.     if sym = ident then (* 常量声明过程开始遇到的第一个符号必然应为标识符 *)  
    336.     begin  
    337.       getsym; (* 获取下一个token *)  
    338.       if sym in [eql, becomes] then (* 如果是等号或赋值号 *)  
    339.       begin  
    340.         if sym = becomes then (* 如果是赋值号(常量生明中应该是等号) *)  
    341.           error(1); (* 抛出1号错误 *)  
    342.         (* 这里其实自动进行了错误纠正使编译继续进行,把赋值号当作等号处理 *)  
    343.         getsym; (* 获取下一个token,等号或赋值号后应接上数字 *)  
    344.         if sym = number then (* 如果的确是数字 *)   
    345.         begin  
    346.           enter(constant); (* 把这个常量登陆到符号表 *)  
    347.           getsym (* 获取下一个token,为后面作准备 *)  
    348.         end  
    349.         else  
    350.           error(2) (* 如果等号后接的不是数字,抛出2号错误 *)  
    351.       end  
    352.       else  
    353.         error(3) (* 如果常量标识符后接的不是等号或赋值号,抛出3号错误 *)  
    354.     end  
    355.     else  
    356.       error(4) (* 如果常量声明过程遇到的第一个符号不为标识符,抛出4号错误 *)  
    357.   end(* constdeclaration *);  
    358.   (* 变量声明过程vardeclaration *)    
    359.   procedure vardeclaration;  
    360.   begin  
    361.     if sym = ident then (* 变量声明过程开始遇到的第一个符号必然应为标识符 *)  
    362.     begin  
    363.       enter(variable); (* 将标识符登陆到符号表中 *)  
    364.       getsym (* 获取下一个token,为后面作准备 *)  
    365.     end  
    366.     else  
    367.       error(4) (* 如果变量声明过程遇到的第一个符号不是标识符,抛出4号错误 *)  
    368.   end(* vardeclaration *);  
    369.   (* 列出当前一层类PCODE目标代码过程listcode *)   
    370.   procedure listcode;  
    371.   var   
    372.     i: integer;  
    373.   begin (* list code generated for this block *)  
    374.     if listswitch then (* 如果用户选择是要列出代码的情况下才列出代码 *)  
    375.     begin  
    376.       for i := cx0 to cx - 1 do (* 从当前层代码开始位置到当前代码位置-1处,即为本分程序块 *)  
    377.         with code[i] do  
    378.         begin  
    379.           writeln(i: 4, mnemonic[f]: 5, l: 3, a: 5); (* 显示出第i行代码的助记符和L与A操作数 *)  
    380.           (* 我修改的代码:原程序此处在输出i时,没有指定占4个字符宽度,不美观也与下面一句不配套。 *)  
    381.           writeln(fa, i: 4, mnemonic[f]: 5, l: 3, a: 5) (* 同时把屏显打印到文件 *)  
    382.         end;  
    383.     end  
    384.   end(* listcode *);  
    385.   (* 语句处理过程statement *)  
    386.   (* 参数说明:fsys: 如果出错可用来恢复语法分析的符号集合 *)  
    387.   procedure statement(fsys: symset);  
    388.   var   
    389.     i, cx1, cx2: integer;  
    390.     (* 表达式处理过程expression *)  
    391.     (* 参数说明:fsys: 如果出错可用来恢复语法分析的符号集合 *)  
    392.     procedure expression(fsys: symset);  
    393.     var   
    394.       addop: symbol;  
    395.       (* 项处理过程term *)  
    396.       (* 参数说明:fsys: 如果出错可用来恢复语法分析的符号集合 *)  
    397.       procedure term(fsys: symset);  
    398.       var   
    399.         mulop: symbol;  
    400.         (* 因子处理过程factor *)  
    401.         (* 参数说明:fsys: 如果出错可用来恢复语法分析的符号集合 *)  
    402.         procedure factor(fsys: symset);  
    403.         var   
    404.           i: integer;  
    405.         begin  
    406.           test(facbegsys, fsys, 24); (* 开始因子处理前,先检查当前token是否在facbegsys集合中。 *)  
    407.                                      (* 如果不是合法的token,抛24号错误,并通过fsys集恢复使语法处理可以继续进行 *)           
    408.           while sym in facbegsys do (* 循环处理因子 *)  
    409.           begin  
    410.             if sym = ident then (* 如果遇到的是标识符 *)  
    411.             begin  
    412.               i := position(id); (* 查符号表,找到当前标识符在符号表中的位置 *)  
    413.               if i = 0 then (* 如果查符号表返回为0,表示没有找到标识符 *)  
    414.                 error(11) (* 抛出11号错误 *)  
    415.               else  
    416.                 with table[i] do (* 如果在符号表中找到了当前标识符的位置,开始生成相应代码 *)  
    417.                   case kind of  
    418.                     constant: gen(lit, 0, val); (* 如果这个标识符对应的是常量,值为val,生成lit指令,把val放到栈顶 *)  
    419.                     variable: gen(lod, lev - level, adr); (* 如果标识符是变量名,生成lod指令, *)  
    420.                                                           (* 把位于距离当前层level的层的偏移地址为adr的变量放到栈顶 *)  
    421.                     procedur: error(21) (* 如果在因子处理中遇到的标识符是过程名,出错了,抛21号错 *)  
    422.                   end;  
    423.               getsym (* 获取下一token,继续循环处理 *)  
    424.             end  
    425.             else  
    426.               if sym = number then (* 如果因子处理时遇到数字 *)  
    427.               begin  
    428.                 if num > amax then (* 如果数字的大小超过允许最大值amax *)  
    429.                 begin  
    430.                   error(31); (* 抛出31号错 *)  
    431.                   num := 0 (* 把数字按0值处理 *)  
    432.                 end;  
    433.                 gen(lit, 0, num); (* 生成lit指令,把这个数值字面常量放到栈顶 *)  
    434.                 getsym (* 获取下一token *)  
    435.               end  
    436.               else  
    437.                 if sym = lparen then (* 如果遇到的是左括号 *)  
    438.                 begin  
    439.                   getsym; (* 获取一个token *)  
    440.                   expression( [rparen] + fsys ); (* 递归调用expression子程序分析一个子表达式 *)  
    441.                   if sym = rparen then (* 子表达式分析完后,应遇到右括号 *)  
    442.                     getsym (* 如果的确遇到右括号,读取下一个token *)  
    443.                   else  
    444.                     error(22) (* 否则抛出22号错误 *)  
    445.                 end;  
    446.             test(fsys, facbegsys, 23) (* 一个因子处理完毕,遇到的token应在fsys集合中 *)  
    447.                                       (* 如果不是,抛23号错,并找到下一个因子的开始,使语法分析可以继续运行下去 *)  
    448.           end  
    449.         end(* factor *);  
    450.       begin (* term *)  
    451.         factor([times, slash] + fsys); (* 每一个项都应该由因子开始,因此调用factor子程序分析因子 *)  
    452.         while sym in [times, slash] do (* 一个因子后应当遇到乘号或除号 *)  
    453.         begin  
    454.           mulop := sym; (* 保存当前运算符 *)  
    455.           getsym; (* 获取下一个token *)  
    456.           factor(fsys + [times, slash]); (* 运算符后应是一个因子,故调factor子程序分析因子 *)  
    457.           if mulop = times then (* 如果刚才遇到乘号 *)  
    458.             gen(opr, 0, 4) (* 生成乘法指令 *)  
    459.           else  
    460.             gen(opr, 0, 5) (* 不是乘号一定是除号,生成除法指令 *)  
    461.         end  
    462.       end (* term *);  
    463.     begin (* expression *)  
    464.       if sym in [plus, minus] then (* 一个表达式可能会由加号或减号开始,表示正负号 *)  
    465.       begin  
    466.         addop := sym; (* 把当前的正号或负号保存起来,以便下面生成相应代码 *)  
    467.         getsym; (* 获取一个token *)  
    468.         term(fsys + [plus, minus]); (* 正负号后面应该是一个项,调term子程序分析 *)  
    469.         if addop = minus then (* 如果保存下来的符号是负号 *)  
    470.           gen(opr, 0, 1) (* 生成一条1号操作指令:取反运算 *)  
    471.         (* 如果不是负号就是正号,不需生成相应的指令 *)  
    472.       end  
    473.       else (* 如果不是由正负号开头,就应是一个项开头 *)  
    474.         term(fsys + [plus, minus]); (* 调用term子程序分析项 *)   
    475.       while sym in [plus, minus] do (* 项后应是加运算或减运算 *)  
    476.       begin  
    477.         addop := sym; (* 把运算符保存下来 *)  
    478.         getsym; (* 获取下一个token,加减运算符后应跟的是一个项 *)  
    479.         term(fsys + [plus, minus]); (* 调term子程序分析项 *)  
    480.         if addop = plus then (* 如果项与项之间的运算符是加号 *)  
    481.           gen(opr, 0, 2) (* 生成2号操作指令:加法 *)  
    482.         else (* 否则是减法 *)  
    483.           gen(opr, 0, 3) (* 生成3号操作指令:减法 *)  
    484.       end  
    485.     end (* expression *);  
    486.     (* 条件处理过程condition *)  
    487.     (* 参数说明:fsys: 如果出错可用来恢复语法分析的符号集合 *)  
    488.     procedure condition(fsys: symset);  
    489.     var   
    490.       relop: symbol; (* 用于临时记录token(这里一定是一个二元逻辑运算符)的内容 *)  
    491.     begin  
    492.       if sym = oddsym then (* 如果是odd运算符(一元) *)  
    493.       begin  
    494.         getsym; (* 获取下一个token *)  
    495.         expression(fsys); (* 对odd的表达式进行处理计算 *)  
    496.         gen(opr, 0, 6); (* 生成6号操作指令:奇偶判断运算 *)  
    497.       end  
    498.       else (* 如果不是odd运算符(那就一定是二元逻辑运算符) *)  
    499.       begin  
    500.         expression([eql, neq, lss, leq, gtr, geq] + fsys); (* 对表达式左部进行处理计算 *)  
    501.         if not (sym in [eql, neq, lss, leq, gtr, geq]) then (* 如果token不是逻辑运算符中的一个 *)  
    502.           error(20) (* 抛出20号错误 *)  
    503.         else  
    504.         begin  
    505.           relop := sym; (* 记录下当前的逻辑运算符 *)  
    506.           getsym; (* 获取下一个token *)  
    507.           expression(fsys); (* 对表达式右部进行处理计算 *)  
    508.           case relop of (* 如果刚才的运算符是下面的一种 *)  
    509.             eql: gen(opr, 0, 8); (* 等号:产生8号判等指令 *)  
    510.             neq: gen(opr, 0, 9); (* 不等号:产生9号判不等指令 *)  
    511.             lss: gen(opr, 0, 10); (* 小于号:产生10号判小指令 *)  
    512.             geq: gen(opr, 0, 11); (* 大于等号号:产生11号判不小于指令 *)  
    513.             gtr: gen(opr, 0, 12); (* 大于号:产生12号判大于指令 *)  
    514.             leq: gen(opr, 0, 13); (* 小于等于号:产生13号判不大于指令 *)  
    515.           end  
    516.         end  
    517.       end  
    518.     end (* condition *);  
    519.   begin (* statement *)  
    520.     if sym = ident then (* 所谓"语句"可能是赋值语句,以标识符开头 *)  
    521.     begin  
    522.       i := position(id); (* 在符号表中查到该标识符所在位置 *)  
    523.       if i = 0 then (* 如果没找到 *)  
    524.         error(11) (* 抛出11号错误 *)  
    525.       else  
    526.         if table[i].kind <> variable then (* 如果在符号表中找到该标识符,但该标识符不是变量名 *)   
    527.         begin  
    528.           error(12); (* 抛出12号错误 *)  
    529.           i := 0 (* i置0作为错误标志 *)  
    530.         end;  
    531.       getsym; (* 获得下一个token,正常应为赋值号 *)  
    532.       if sym = becomes then (* 如果的确为赋值号 *)  
    533.         getsym (* 获取下一个token,正常应为一个表达式 *)  
    534.       else  
    535.         error(13); (* 如果赋值语句的左部标识符号后所接不是赋值号,抛出13号错误 *)  
    536.       expression(fsys); (* 处理表达式 *)  
    537.       if i <> 0 then (* 如果不曾出错,i将不为0,i所指为当前语名左部标识符在符号表中的位置 *)  
    538.         with table[i] do  
    539.           gen(sto, lev - level, adr) (* 产生一行把表达式值写往指定内存的sto目标代码 *)  
    540.     end  
    541.     else  
    542.       if sym = readsym then (* 如果不是赋值语句,而是遇到了read语句 *)  
    543.       begin  
    544.         getsym; (* 获得下一token,正常情况下应为左括号 *)  
    545.         if sym <> lparen then (* 如果read语句后跟的不是左括号 *)  
    546.           error(34) (* 抛出34号错误 *)  
    547.         else  
    548.           repeat (* 循环得到read语句括号中的参数表,依次产生相应的“从键盘读入”目标代码 *)  
    549.             getsym; (* 获得一个token,正常应是一个变量名 *)  
    550.             if sym = ident then (* 如果确为一个标识符 *)   
    551.             (* 这里略有问题,还应判断一下这个标识符是不是变量名,如果是常量名或过程名应出错 *)  
    552.               i := position(id) (* 查符号表,找到它所在位置给i,找不到时i会为0 *)  
    553.             else  
    554.               i := 0; (* 不是标识符则有问题,i置0作为出错标志 *)  
    555.             if i = 0 then (* 如果有错误 *)  
    556.               error(35) (* 抛出35号错误 *)  
    557.             else (* 否则生成相应的目标代码 *)  
    558.               with table[i] do  
    559.               begin  
    560.                 gen(opr, 0, 16); (* 生成16号操作指令:从键盘读入数字 *)  
    561.                 gen(sto, lev - level, adr) (* 生成sto指令,把读入的值存入指定变量所在的空间 *)  
    562.               end;  
    563.             getsym (* 获取下一个token,如果是逗号,则read语还没完,否则应当是右括号 *)  
    564.           until sym <> comma; (* 不断生成代码直到read语句的参数表中的变量遍历完为止,这里遇到不是逗号,应为右括号 *)  
    565.         if sym <> rparen then (* 如果不是我们预想中的右括号 *)  
    566.         begin  
    567.           error(33); (* 抛出33号错误 *)  
    568.           while not (sym in fsys) do (* 依靠fsys集,找到下一个合法的token,恢复语法分析 *)  
    569.             getsym  
    570.         end  
    571.         else  
    572.           getsym (* 如果read语句正常结束,得到下一个token,一般为分号或end *)  
    573.       end  
    574.       else  
    575.         if sym = writesym then (* 如果遇到了write语句 *)  
    576.         begin  
    577.           getsym; (* 获取下一token,应为左括号 *)  
    578.           if sym = lparen then (* 如确为左括号 *)  
    579.           begin  
    580.             repeat (* 依次获取括号中的每一个值,进行输出 *)  
    581.               getsym; (* 获得一个token,这里应是一个标识符 *)  
    582.               expression([rparen, comma] + fsys); (* 调用expression过程分析表达式,用于出错恢复的集合中加上右括号和逗号 *)  
    583.               gen(opr, 0, 14) (* 生成14号指令:向屏幕输出 *)  
    584.             until sym <> comma; (* 循环直到遇到的不再是逗号,这时应是右括号 *)  
    585.             if sym <> rparen then (* 如果不是右括号 *)  
    586.               error(33) (* 抛出33号错误 *)  
    587.             else  
    588.               getsym (* 正常情况下要获取下一个token,为后面准备好 *)  
    589.           end;  
    590.           gen(opr, 0, 15) (* 生成一个15号操作的目标代码,功能是输出一个换行 *)  
    591.           (* 由此可知PL/0中的write语句与Pascal中的writeln语句类似,是带有输出换行的 *)  
    592.         end  
    593.         else  
    594.           if sym = callsym then (* 如果是call语句 *)  
    595.           begin  
    596.             getsym; (* 获取token,应是过程名型标识符 *)  
    597.             if sym <> ident then (* 如果call后跟的不是标识符 *)  
    598.               error(14) (* 抛出14号错误 *)  
    599.             else  
    600.             begin  
    601.               i := position(id); (* 从符号表中找出相应的标识符 *)  
    602.               if i = 0 then (* 如果没找到 *)  
    603.                 error(11) (* 抛出11号错误 *)  
    604.               else  
    605.                 with table[i] do (* 如果找到标识符位于符号表第i位置 *)  
    606.                   if kind = procedur then (* 如果这个标识符为一个过程名 *)  
    607.                     gen(cal,lev-level,adr) (* 生成cal目标代码,呼叫这个过程 *)  
    608.                   else  
    609.                     error(15); (* 如果call后跟的不是过程名,抛出15号错误 *)  
    610.               getsym (* 获取下一token,为后面作准备 *)  
    611.             end  
    612.           end  
    613.         else  
    614.           if sym = ifsym then (* 如果是if语句 *)  
    615.           begin  
    616.             getsym; (* 获取一token应是一个逻辑表达式 *)  
    617.             condition([thensym, dosym] + fsys); (* 对逻辑表达式进行分析计算,出错恢复集中加入then和do语句 *)  
    618.             if sym = thensym then (* 表达式后应遇到then语句 *)  
    619.               getsym (* 获取then后的token,应是一语句 *)  
    620.             else  
    621.               error(16); (* 如果if后没有then,抛出16号错误 *)  
    622.             cx1 := cx; (* 记下当前代码分配指针位置 *)  
    623.             gen(jpc, 0, 0); (* 生成条件跳转指令,跳转位置暂时填0,分析完语句后再填写 *)  
    624.             statement(fsys); (* 分析then后的语句 *)  
    625.             code[cx1].a:=cx (* 上一行指令(cx1所指的)的跳转位置应为当前cx所指位置 *)  
    626.           end  
    627.           else  
    628.             if sym = beginsym then (* 如果遇到begin *)  
    629.             begin  
    630.               getsym; (* 获取下一个token *)  
    631.               statement([semicolon, endsym] + fsys);(* 对begin与end之间的语句进行分析处理 *)  
    632.               while sym in [semicolon] + statbegsys do (* 如果分析完一句后遇到分号或语句开始符循环分析下一句语句 *)  
    633.               begin  
    634.                 if sym = semicolon then (* 如果语句是分号(可能是空语句) *)  
    635.                   getsym (* 获取下一token继续分析 *)  
    636.                 else  
    637.                   error(10); (* 如果语句与语句间没有分号,出10号错 *)  
    638.                 statement([semicolon, endsym] + fsys) (* 分析一个语句 *)  
    639.               end;  
    640.               if sym = endsym then (* 如果语句全分析完了,应该遇到end *)  
    641.                 getsym (* 的确是end,读下一token *)  
    642.               else  
    643.                 error(17) (* 如果不是end,抛出17号错 *)  
    644.             end  
    645.             else  
    646.               if sym = whilesym then (* 如果遇到while语句 *)  
    647.               begin  
    648.                 cx1 := cx; (* 记下当前代码分配位置,这是while循环的开始位置 *)  
    649.                 getsym; (* 获取下一token,应为一逻辑表达式 *)  
    650.                 condition([dosym] + fsys); (* 对这个逻辑表达式进行分析计算 *)  
    651.                 cx2 := cx; (* 记下当前代码分配位置,这是while的do中的语句的开始位置 *)  
    652.                 gen(jpc, 0, 0); (* 生成条件跳转指令,跳转位置暂时填0 *)  
    653.                 if sym = dosym then (* 逻辑表达式后应为do语句 *)  
    654.                   getsym (* 获取下一token *)  
    655.                 else  
    656.                   error(18); (* if后缺少then,抛出18号错误 *)  
    657.                 statement(fsys); (* 分析do后的语句块 *)  
    658.                 gen(jmp, 0, cx1); (* 循环跳转到cx1位置,即再次进行逻辑判断 *)  
    659.                 code[cx2].a := cx (* 把刚才填0的跳转位置改成当前位置,完成while语句的处理 *)  
    660.               end;  
    661.     test(fsys, [], 19) (* 至此一个语句处理完成,一定会遇到fsys集中的符号,如果没有遇到,就抛19号错 *)  
    662.   end(* statement *);  
    663. begin (* block *)  
    664.   dx := 3; (* 地址指示器给出每层局部量当前已分配到的相对位置。  
    665.               置初始值为3的原因是:每一层最开始的位置有三个空间用于存放静态链SL、动态链DL和返回地址RA *)  
    666.   tx0 := tx; (* 初始符号表指针指向当前层的符号在符号表中的开始位置 *)  
    667.   table[tx].adr := cx; (* 符号表当前位置记下当前层代码的开始位置 *)  
    668.   gen(jmp, 0, 0); (* 产生一行跳转指令,跳转位置暂时未知填0 *)  
    669.   if lev > levmax then (* 如果当前过程嵌套层数大于最大允许的套层数 *)  
    670.     error(32); (* 发出32号错误 *)  
    671.   repeat (* 开始循环处理源程序中所有的声明部分 *)  
    672.     if sym = constsym then (* 如果当前token是const保留字,开始进行常量声明 *)  
    673.     begin  
    674.       getsym; (* 获取下一个token,正常应为用作常量名的标识符 *)  
    675.       repeat (* 反复进行常量声明 *)  
    676.         constdeclaration; (* 声明以当前token为标识符的常量 *)  
    677.         while sym = comma do (* 如果遇到了逗号则反复声明下一个常量 *)  
    678.         begin  
    679.           getsym; (* 获取下一个token,这里正好应该是标识符 *)  
    680.           constdeclaration (* 声明以当前token为标识符的常量 *)  
    681.         end;  
    682.         if sym = semicolon then (* 如果常量声明结束,应遇到分号 *)  
    683.           getsym (* 获取下一个token,为下一轮循环做好准备 *)  
    684.         else  
    685.           error(5) (* 如果常量声明语句结束后没有遇到分号则发出5号错误 *)  
    686.       until sym <> ident (* 如果遇到非标识符,则常量声明结束 *)  
    687.     end;  
    688.     (* 此处的常量声明的语法与课本上的EBNF范式有不同之处:  
    689.        它可以接受像下面的声明方法,而根据课本上的EBNF范式不可得出下面的语法:  
    690.        const a = 3, b = 3; c = 6; d = 7, e = 8;   
    691.        即它可以接受分号或逗号隔开的常量声明,而根据EBNF范式只可接受用逗号隔开的声明 *)  
    692.     if sym = varsym then (* 如果当前token是var保留字,开始进行变量声明,与常量声明类似 *)  
    693.     begin  
    694.       getsym; (* 获取下一个token,此处正常应为用作变量名的一个标识符 *)  
    695.       repeat (* 反复进行变量声明 *)  
    696.         vardeclaration; (* 以当前token为标识符声明一个变量 *)  
    697.         while sym = comma do (* 如果遇到了逗号则反复声明下一个变量 *)  
    698.         begin  
    699.           getsym; (* 获取下一个token,这里正好应该是标识符 *)  
    700.           vardeclaration; (* 声明以当前token为标识符的变量 *)  
    701.         end;  
    702.         if sym = semicolon then (* 如果变量声明结束,应遇到分号 *)  
    703.           getsym (* 获取下一个token,为下一轮循环做好准备 *)  
    704.         else  
    705.           error(5) (* 如果变量声明语句结束后没有遇到分号则发出5号错误 *)  
    706.       until sym <> ident; (* 如果遇到非标识符,则变量声明结束 *)  
    707.       (* 这里也存在与上面的常量声明一样的毛病:与PL/0的语法规范有冲突。 *)  
    708.     end;  
    709.     while sym = procsym do (* 循环声明各子过程 *)  
    710.     begin  
    711.       getsym; (* 获取下一个token,此处正常应为作为过程名的标识符 *)  
    712.       if sym = ident then (* 如果token确为标识符 *)  
    713.       begin  
    714.         enter(procedur); (* 把这个过程登录到名字表中 *)  
    715.         getsym (* 获取下一个token,正常情况应为分号 *)  
    716.       end  
    717.       else  
    718.         error(4); (* 否则抛出4号错误 *)  
    719.       if sym = semicolon then (* 如果当前token为分号 *)  
    720.         getsym (* 获取下一个token,准备进行语法分析的递归调用 *)  
    721.       else  
    722.         error(5); (* 否则抛出5号错误 *)  
    723.       block(lev + 1, tx, [semicolon] + fsys); (* 递归调用语法分析过程,当前层次加一,同时传递表头索引、合法单词符 *)  
    724.       if sym = semicolon then (* 递归返回后当前token应为递归调用时的最后一个end后的分号 *)  
    725.       begin  
    726.         getsym; (* 获取下一个token *)  
    727.         test(statbegsys + [ident, procsym], fsys, 6); (* 检查当前token是否合法,不合法则用fsys恢复语法分析同时抛6号错 *)  
    728.       end  
    729.       else  
    730.         error(5) (* 如果过程声明后的符号不是分号,抛出5号错误 *)  
    731.     end;  
    732.     test(statbegsys + [ident], declbegsys, 7) (* 检查当前状态是否合法,不合法则用声明开始符号作出错恢复、抛7号错 *)  
    733.   until not (sym in declbegsys); (* 直到声明性的源程序分析完毕,继续向下执行,分析主程序 *)  
    734.   code[table[tx0].adr].a := cx; (* 把前面生成的跳转语句的跳转位置改成当前位置 *)  
    735.   with table[tx0] do (* 在符号表中记录 *)  
    736.   begin  
    737.     adr := cx; (* 地址为当前代码分配地址 *)  
    738.     size := dx; (* 长度为当前数据代分配位置 *)  
    739.   end;  
    740.   cx0 := cx; (* 记下当前代码分配位置 *)  
    741.   gen(int, 0, dx); (* 生成分配空间指令,分配dx个空间 *)  
    742.   statement([semicolon, endsym] + fsys); (* 处理当前遇到的语句或语句块 *)  
    743.   gen(opr, 0, 0); (* 生成从子程序返回操作指令 *)  
    744.   test(fsys, [], 8); (* 用fsys检查当前状态是否合法,不合法则抛8号错 *)  
    745.   listcode (* 列出本层的类PCODE代码 *)  
    746. end(* block *);  
    747. (* PL/0编译器产生的类PCODE目标代码解释运行过程interpret *)  
    748. procedure interpret;  
    749. const   
    750.   stacksize = 500; (* 常量定义,假想的栈式计算机有500个栈单元 *)  
    751. var   
    752.   p, b, t: integer; (* program base topstack registers *)   
    753.   (* p为程序指令指针,指向下一条要运行的代码 *)  
    754.   (* b为基址指针,指向每个过程被调用时数据区中分配给它的局部变量数据段基址 *)  
    755.   (* t为栈顶寄存器,类PCODE是在一种假想的栈式计算上运行的,这个变量记录这个计算机的当前栈顶位置 *)  
    756.   i: instruction; (* i变量中存放当前在运行的指令 *)  
    757.   s: array[1..stacksize] of integer; (* datastore *) (* s为栈式计算机的数据内存区 *)  
    758.   (* 通过静态链求出数据区基地址的函数base *)  
    759.   (* 参数说明:l:要求的数据区所在层与当前层的层差 *)  
    760.   (* 返回值:要求的数据区基址 *)  
    761.   function base(l: integer): integer;  
    762.   var   
    763.     b1: integer;  
    764.   begin  
    765.     b1 := b; (* find base 1 level down *) (* 首先从当前层开始 *)  
    766.     while l > 0 do (* 如果l大于0,循环通过静态链往前找需要的数据区基址 *)  
    767.     begin  
    768.       b1 := s[b1]; (* 用当前层数据区基址中的内容(正好是静态链SL数据,为上一层的基址)的作为新的当前层,即向上找了一层 *)  
    769.       l := l - 1 (* 向上了一层,l减一 *)  
    770.     end;  
    771.     base := b1 (* 把找到的要求的数据区基址返回 *)  
    772.   end(* base *);  
    773. begin  
    774.   writeln('start pl0'); (* PL/0程序开始运行 *)  
    775.   t := 0; (* 程序开始运行时栈顶寄存器置0 *)  
    776.   b := 1; (* 数据段基址为1 *)  
    777.   p := 0; (* 从0号代码开始执行程序 *)  
    778.   s[1] := 0;   
    779.   s[2] := 0;  
    780.   s[3] := 0; (* 数据内存中为SL,DL,RA三个单元均为0,标识为主程序 *)  
    781.   repeat (* 开始依次运行程序目标代码 *)  
    782.     i := code[p]; (* 获取一行目标代码 *)  
    783.     p := p + 1; (* 指令指针加一,指向下一条代码 *)  
    784.     with i do   
    785.       case f of (* 如果i的f,即指令助记符是下面的某种情况,执行不同的功能 *)  
    786.         lit: (* 如果是lit指令 *)  
    787.         begin  
    788.           t := t + 1; (* 栈顶指针上移,在栈中分配了一个单元 *)  
    789.           s[t] := a (* 该单元的内容存放i指令的a操作数,即实现了把常量值放到运行栈栈顶 *)  
    790.         end;  
    791.         opr: (* 如果是opr指令 *)  
    792.           case a of (* operator *) (* 根据a操作数不同,执行不同的操作 *)  
    793.             0: (* 0号操作为从子过程返回操作 *)  
    794.             begin (* return *)  
    795.               t := b - 1; (* 释放这段子过程占用的数据内存空间 *)  
    796.               p := s[t + 3]; (* 把指令指针取到RA的值,指向的是返回地址 *)  
    797.               b := s[t + 2] (* 把数据段基址取到DL的值,指向调用前子过程的数据段基址 *)  
    798.             end;  
    799.             1: (* 1号操作为栈顶数据取反操作 *)  
    800.               s[t] := -s[t]; (* 对栈顶数据进行取反 *)  
    801.             2: (* 2号操作为栈顶两个数据加法操作 *)  
    802.             begin  
    803.               t := t - 1; (* 栈顶指针下移 *)   
    804.               s[t] := s[t] + s[t + 1] (* 把两单元数据相加存入栈顶 *)  
    805.             end;  
    806.             3: (* 3号操作为栈顶两个数据减法操作 *)  
    807.             begin  
    808.               t := t - 1; (* 栈顶指针下移 *)   
    809.               s[t] := s[t] - s[t + 1] (* 把两单元数据相减存入栈顶 *)  
    810.             end;  
    811.             4: (* 4号操作为栈顶两个数据乘法操作 *)  
    812.             begin  
    813.               t := t - 1; (* 栈顶指针下移 *)  
    814.               s[t] := s[t] * s[t + 1] (* 把两单元数据相乘存入栈顶 *)  
    815.             end;  
    816.             5: (* 5号操作为栈顶两个数据除法操作 *)  
    817.             begin  
    818.               t := t - 1; (* 栈顶指针下移 *)  
    819.               s[t] := s[t] div s[t + 1] (* 把两单元数据相整除存入栈顶 *)  
    820.             end;  
    821.             6: (* 6号操作为判奇操作 *)  
    822.               s[t] := ord(odd(s[t])); (* 数据栈顶的值是奇数则把栈顶值置1,否则置0 *)  
    823.             8: (* 8号操作为栈顶两个数据判等操作 *)  
    824.             begin  
    825.               t := t - 1; (* 栈顶指针下移 *)  
    826.               s[t] := ord(s[t] = s[t + 1]) (* 判等,相等栈顶置1,不等置0 *)  
    827.             end;  
    828.             9: (* 9号操作为栈顶两个数据判不等操作 *)  
    829.             begin  
    830.               t := t - 1; (* 栈顶指针下移 *)  
    831.               s[t] := ord(s[t] <> s[t + 1]) (* 判不等,不等栈顶置1,相等置0 *)  
    832.             end;  
    833.             10: (* 10号操作为栈顶两个数据判小于操作 *)  
    834.             begin  
    835.               t := t - 1; (* 栈顶指针下移 *)  
    836.               s[t] := ord(s[t] < s[t + 1]) (* 判小于,如果下面的值小于上面的值,栈顶置1,否则置0 *)  
    837.             end;  
    838.             11: (* 11号操作为栈顶两个数据判大于等于操作 *)  
    839.             begin  
    840.               t := t - 1; (* 栈顶指针下移 *)  
    841.               s[t] := ord(s[t] >= s[t + 1]) (* 判大于等于,如果下面的值大于等于上面的值,栈顶置1,否则置0 *)  
    842.             end;  
    843.             12: (* 12号操作为栈顶两个数据判大于操作 *)  
    844.             begin  
    845.               t := t - 1; (* 栈顶指针下移 *)  
    846.               s[t] := ord(s[t] > s[t + 1]) (* 判大于,如果下面的值大于上面的值,栈顶置1,否则置0 *)  
    847.             end;  
    848.             13: (* 13号操作为栈顶两个数据判小于等于操作 *)  
    849.             begin  
    850.               t := t - 1; (* 栈顶指针下移 *)  
    851.               s[t] := ord(s[t] <= s[t + 1]) (* 判小于等于,如果下面的值小于等于上面的值,栈顶置1,否则置0 *)  
    852.             end;  
    853.             14: (* 14号操作为输出栈顶值操作 *)  
    854.             begin  
    855.               write(s[t]); (* 输出栈顶值 *)  
    856.               write(fa2, s[t]); (* 同时打印到文件 *)  
    857.               t := t - 1 (* 栈顶下移 *)  
    858.             end;  
    859.             15: (* 15号操作为输出换行操作 *)  
    860.             begin  
    861.               writeln; (* 输出换行 *)  
    862.               writeln(fa2) (* 同时输出到文件 *)  
    863.             end;  
    864.             16: (* 16号操作是接受键盘值输入到栈顶 *)  
    865.             begin  
    866.               t := t + 1; (* 栈顶上移,分配空间 *)  
    867.               write('?'); (* 屏显问号 *)  
    868.               write(fa2, '?'); (* 同时输出到文件 *)  
    869.               readln(s[t]); (* 获得输入 *)  
    870.               writeln(fa2, s[t]); (* 把用户输入值打印到文件 *)  
    871.             end;  
    872.           end; (* opr指令分析运行结束 *)  
    873.         lod: (* 如果是lod指令:将变量放到栈顶 *)  
    874.         begin  
    875.           t := t + 1; (* 栈顶上移,开辟空间 *)  
    876.           s[t] := s[base(l) + a] (* 通过数据区层差l和偏移地址a找到变量的数据,存入上面开辟的新空间(即栈顶) *)  
    877.         end;  
    878.         sto: (* 如果是sto指令 *)  
    879.         begin  
    880.           s[base(l) + a] := s[t]; (* 把栈顶的值存入位置在数据区层差l偏移地址a的变量内存 *)  
    881.           t := t - 1 (* 栈项下移,释放空间 *)  
    882.         end;  
    883.         cal: (* 如果是cal指令 *)  
    884.         begin (* generat new block mark *)  
    885.           s[t + 1] := base(l); (* 在栈顶压入静态链SL *)  
    886.           s[t + 2] := b; (* 然后压入当前数据区基址,作为动态链DL *)  
    887.           s[t + 3] := p; (* 最后压入当前的断点,作为返回地址RA *)  
    888.           (* 以上的工作即为过程调用前的保护现场 *)  
    889.           b := t + 1; (* 把当前数据区基址指向SL所在位置 *)  
    890.           p := a; (* 从a所指位置开始继续执行指令,即实现了程序执行的跳转 *)  
    891.         end;  
    892.         int: (* 如果是int指令 *)  
    893.           t := t + a; (* 栈顶上移a个空间,即开辟a个新的内存单元 *)  
    894.         jmp: (* 如果是jmp指令 *)  
    895.           p := a; (* 把jmp指令操作数a的值作为下一次要执行的指令地址,实现无条件跳转 *)  
    896.         jpc: (* 如果是jpc指令 *)  
    897.         begin  
    898.           if s[t] = 0 then (* 判断栈顶值 *)  
    899.             p := a; (* 如果是0就跳转,否则不跳转 *)  
    900.           t := t - 1 (* 释放栈顶空间 *)  
    901.         end;  
    902.       end(* with,case *)  
    903.   until p = 0; (* 如果p等于0,意味着在主程序运行时遇到了从子程序返回指令,也就是整个程序运行的结束 *)  
    904.   close(fa2) (* 关闭用于记录屏幕输入输出的fa2文件 *)  
    905.   (* PCODE代码的解释执行过程结束 *)  
    906. end(* interpret *);  
    907. begin (* main *)  
    908.   for ch := ' ' to '!' do (* 这个循环把ssym数组全部填nul *)  
    909.     ssym[ch] := nul;  
    910.   (* changed because of different character set  
    911.   note the typos below in the original where  
    912.   the alfas were not given the correct space *)  
    913.   (* 下面初始化保留字表,保留字长度不到10个字符的,多余位置用空格填充,便于词法分析时以二分法来查找保留字 *)  
    914.   word[1] := 'begin     ';  
    915.   word[2] := 'call      ';  
    916.   word[3] := 'const     ';  
    917.   word[4] := 'do        ';  
    918.   word[5] := 'end       ';  
    919.   word[6] := 'if        ';  
    920.   word[7] := 'odd       ';  
    921.   word[8] := 'procedure ';  
    922.   word[9] := 'read      ';  
    923.   word[10] := 'then      ';  
    924.   word[11] := 'var       ';  
    925.   word[12] := 'while     ';  
    926.   word[13] := 'write     ';  
    927.   (* 保留字符号列表,在上面的保留字表中找到保留字后可以本表中相应位置该保留字的类型 *)  
    928.   wsym[1] := beginsym;  
    929.   wsym[2] := callsym;  
    930.   wsym[3] := constsym;  
    931.   wsym[4] := dosym;  
    932.   wsym[5] := endsym;  
    933.   wsym[6] := ifsym;  
    934.   wsym[7] := oddsym;  
    935.   wsym[8] := procsym;  
    936.   wsym[9] := readsym;  
    937.   wsym[10] := thensym;  
    938.   wsym[11] := varsym;  
    939.   wsym[12] := whilesym;  
    940.   wsym[13] := writesym;  
    941.   (* 初始化符号表,把可能出现的符号赋上相应的类型,其余符号由于开始处的循环所赋的类型均为nul *)  
    942.   ssym['+'] := plus;  
    943.   ssym['-'] := minus;  
    944.   ssym['*'] := times;  
    945.   ssym['/'] := slash;  
    946.   ssym['('] := lparen;  
    947.   ssym[')'] := rparen;  
    948.   ssym['='] := eql;  
    949.   ssym[','] := comma;  
    950.   ssym['.'] := period;  
    951.   ssym['#'] := neq;  
    952.   ssym[';'] := semicolon;  
    953.   (* 初始化类PCODE助记符表,这个表主要供输出类PCODE代码之用 *)  
    954.   mnemonic[lit] := ' lit ';  
    955.   mnemonic[opr] := ' opr ';  
    956.   mnemonic[lod] := ' lod ';  
    957.   mnemonic[sto] := ' sto ';  
    958.   mnemonic[cal] := ' cal ';  
    959.   mnemonic[int] := ' int ';  
    960.   mnemonic[jmp] := ' jmp ';  
    961.   mnemonic[jpc] := ' jpc ';  
    962.   (* 我修改的代码:书上此处均为'xxx  '形式,即助记符后两个空格,通过上网查询原版程序确认为助词符前后各一空格。 *)  
    963.   (* 这样改的目的是使后面的输出结果比较美观 *)  
    964.   declbegsys := [constsym, varsym, procsym];  
    965.   statbegsys := [beginsym, callsym, ifsym, whilesym];  
    966.   facbegsys := [ident, number, lparen];  
    967.   (* page(output) *)  
    968.   (* 由于Turbo Pascal 7.0的文本文件处理方法与源程序中使用的方法有很大不同,因此下面的有关文件处理的代码进行了不少更改。 *)  
    969.   assign(fa1, 'fa1.txt'); (* 把文本文件fa1与fa1.txt文件关联起来,用于输出生成的类PCODE代码 *)  
    970.   rewrite(fa1); (* 建立并打开fa1.txt文件 *)  
    971.   write('input file?  '); (* 提示输入PL/0源程序名 *)  
    972.   write(fa1, 'input file? '); (* 同样的提示输出到fa1.txt文件 *)  
    973.   readln(fname); (* 获得键盘输入的文件名 *)  
    974.   writeln(fa1, fname); (* 把键盘输入打印到fa1.txt文件 *)  
    975.   {openf(fin,fname,'r');}  
    976.   assign(fin, fname); (* 把PL/0的源程序文件与fin关联 *)  
    977.   reset(fin); (* 打开fin所关联的PL/0源程序文件 *)   
    978.   write('list object code ?'); (* 提示是否要列出类PCODE代码 *)  
    979.   readln(fname); (* 获得用户输入 *)  
    980.   write(fa1, 'list object code ?'); (* 同样的提示写到fa1.txt文件中 *)  
    981.   listswitch := (fname[1] = 'y'); (* 如果输入'y'开头的字符串,把listswitch标志置true,否则为false *)  
    982.   err := 0; (* 出错次数置0 *)  
    983.   cc := 0; (* 词法分析行缓冲区指针置0 *)  
    984.   cx := 0; (* 类PCODE代码表指针置0 *)  
    985.   ll := 0; (* 词法分析行缓冲区长度置0 *)  
    986.   ch := ' '; (* 词法分析当前字符为空格 *)  
    987.   kk := al; (* 置kk的值为允许的标识符的最长长度,具体用意见getsym过程注释 *)  
    988.   assign(fa, 'fa.txt'); (* 把fa.txt与fa关联。fa用于输出源程序 *)  
    989.   rewrite(fa); (* 建立并打开fa.txt *)  
    990.   getsym; (* 首次调用词法分析子程序,获取源程序的第一个词(token) *)  
    991.   block(0, 0, [period] + declbegsys + statbegsys); (* 开始进行主程序(也就是第一个分程序)的语法分析 *)  
    992.   (* 主程序所在层为0层,符号表暂时为空,符号表指针指0号位置 *)  
    993.   close(fa); (* 关闭文件 *)  
    994.   close(fa1); (* 关闭文件 *)  
    995.   if sym <> period then (* 主程序分析结束,应遇到表明程序结束的句号 *)  
    996.     error(9); (* 如果不是句号,出现9号错误 *)  
    997.   (* 以上可知,一个合法的PL/0源程序应由分程序和句号构成。 *)  
    998.   if err = 0 then (* 如果出错次数为0,可以开始解释执行编译产生的代码 *)  
    999.   begin  
    1000.     assign(fa2, 'fa2.txt'); (* 把文本文件fa2与fa2.txt文件关联起来,用于输出类PCODE代码运行结果 *)  
    1001.     rewrite(fa2); (* 建立并打开fa2文件 *)  
    1002.     interpret (* 开始解释执行类PCODE代码 *)  
    1003.   end  
    1004.   else  
    1005.     write('errors in pl/0 program'); (* 如果有错误,提示程序有错误 *)  
    1006.   99: (* 这个标号原来是用于退出程序的,由于Turbo Pascal不支持跨过程的跳转,因此这里这个标号也没用了。 *)  
    1007.   {closef(fin);}  
    1008.   close(fin); (* 关闭源程序文件 *)  
    1009.   writeln  
    1010. end.  
    1011. ************************************************************************  

    (转至 : http://www.freemindworld.com/blog/2002/020815_pl0_analysis.shtml)

    展开全文
  • 编译概述与引论

    千次阅读 2016-07-20 20:02:08
    本博文中,介绍编译程序的基本概念,概述编译过程和编译程序结构,编译程序和程序设计环境以及编译程序的生成过程和构造工具知识。什么叫编译程序通常,我们所说的翻译程序是指这样的一个程序,它能够把某一种语言...

    本博文中,介绍编译程序的基本概念,概述编译过程和编译程序结构,编译程序和程序设计环境以及编译程序的生成过程和构造工具知识。

    什么叫编译程序

    通常,我们所说的翻译程序是指这样的一个程序,它能够把某一种语言程序(称为源语言程序)转换成另一种语言程序(称为目标语言程序),而后者与前者在逻辑上是等价的。如果源语言是诸如FORTRAN、Pascal、C、Ada、Smalltalk或Java这样的“高级语言”,而目标语言是诸如汇编语言或机器语言之类的“低级语言”,这样的一个翻译程序就称为编译程序

    高级语言程序除了像上面所说的先编译后执行外,有时也可“解释”执行。一个源语言的解释程序是这样的程序,它以该语言写的源程序作为输入,但不产生目标程序,而是边解释边执行源程序本身。实际上,许多编译程序的构造与实现技术同样适用于解释程序。

    根据不同的用途和侧重,编译程序还可进一步分类。专门用于帮助程序开发和调试的编译程序称为诊断编译程序(Diagnostic Compiler),着重于提高目标代码效率的编译程序叫优化编译程序(Optimizing Compiler)。现在很多编译程序同时提供了调试、优化等多种功能,用户可以通过“开关”进行选择。运行编译程序的计算机称宿主机,运行编译程序所产生目标代码的计算机称目标机。如果一个编译程序产生不同于其宿主机的机器代码,则称它为交叉编译程序(Cross Compiler)。如果不需重写编译程序中与机器无关的部分就能改变目标机,则称该编译程序为可变目标编译程序(Retargetable Compiler)

    世界上第一个编译程序—FORTRAN编译程序是20世纪50年代中期研制成功的。当时,人们普遍认为设计和实现编译程序是一件十分困难、令人生畏的事情。经过40年的努力,编译理论与技术得到迅速发展,到目前为止,现在已形成了一套比较成熟的、系统化的理论与方法,并且开发出了一些好的编译程序的实现语言、环境与工具。在此基础上设计并实现一个编译程序不再是高不可攀的事情。

    编译过程概述

    编译程序的工作,从输入源程序开始到输出目标程序为止的整个过程,是非常复杂的。但就其过程而言,它与人们进行自然语言之间的翻译有许多相近之处。当我们把一种文字翻译为另一种文字,例如把一段英文翻译为中文时,通常需经下列步骤:

    1. 识别出句子中的一个个单词;
    2. 分析句子的语法结构;
    3. 根据句子的含义进行初步翻译;
    4. 对译文进行修饰;
    5. 写出最后的译文。

    类似地,编译程序的工作过程一般也可以划分为五个阶段:词法分析、语法分析、语义分析及中间代码生成、优化、目标代码生成

    第一阶段,词法分析。 词法分析的任务是:输入源程序,对构成源程序的字符串进行扫描和分解,识别出一个个的单词(亦称单词符号或简称符号),如基本字(begin、end、if、for、while等),标识符、常数、算符和界符(标点符号、左右括号等等)。单词符号是语言的基本组成成分,是人们理解和编写程序的基本要素。识别和理解这些要素无疑也是翻译的基础。如同将英文翻译成中文的情形一样,如果你对英语单词不理解,那就谈不上进行正确的翻译。在词法分析阶段的工作中所依循的是语言的词法规则(或称构词规则)。描述词法规则的有效工具是正规式和有限自动机。

    第二阶段,语法分析。 语法分析的任务是:在词法分析的基础上,根据语言的语法规则,把单词符号串分解成各类语法单位(语法范畴),如“短语”、“子句”、“句子”(“语句”)、“程序段”和“程序”等。通过语法分析,确定整个输入串是否构成语法上正确的“程序”。语法分析所依循的是语言的语法规则。语法规则通常用上下文无关文法描述。词法分析是一种线性分析,而语法分析是一种层次结构分析。

    第三阶段,语义分析与中间代码产生。 这一阶段的任务是:对语法分析所识别出的各类语法范畴,分析其含义,并进行初步翻译(产生中间代码)。这一阶段通常包括两个方面的工作。首先,对每种语法范畴进行静态语义检查,例如,变量是否定义、类型是否正确等等。如果语义正确,则进行另一方面工作,即进行中间代码的翻译。这一阶段所依循的是语言的语义规则。通常使用属性文法描述语义规则。

    “翻译”仅仅在这里才开始涉及到。所谓“中间代码”是一种含义明确、便于处理的记号系统,它通常独立于具体的硬件。这种记号系统或者与现代计算机的指令形式有某种程度的接近,或者能够比较容易地把它变换成现代计算机的机器指令。一般而言,中间代码是一种独立于具体硬件的记号系统。常用的中间代码,除了四元式之外,还有三元式、间接三元式、逆波兰记号和树形表示等等。

    第四阶段,优化。 优化的任务在于对前段产生的中间代码进行加工变换,以期在最后阶段能产生出更为高效(省时间和空间)的目标代码。优化的主要方面有:公共子表达式的提取、循环优化、删除无用代码等等。有时,为了便于“并行运算”,还可以对代码进行并行化处理。优化所依循的原则是程序的等价变换规则。

    第五阶段,目标代码生成。这一阶段的的任务是:把中间代码(或经优化处理之后)变换成特定机器上的低级语言代码。这阶段实现了最后的翻译,它的工作有赖于硬件系统结构和机器指令含义。这阶段工作非常复杂,涉及到硬件系统功能部件的运用,机器指令的选择,各种数据类型变量的存储空间分配,以及寄存器和后援寄存器的调度,等等。如何产生出足以充分发挥硬件效率的目标代码是一件非常不容易的事情。

    目标代码的形式可以是绝对指令代码或可重定位的指令代码或汇编指令代码。如目标代码是绝对指令代码,则这种目标代码可立即执行。如果目标代码是汇编指令代码,则需汇编器汇编之后才能运行。必须指出,现代多数实用编译程序所产生的目标代码都是一种可重定位的指令代码。这种目标代码在运行前必须借助于一个连接装配程序把各个目标模块(包括系统提供的库模块)连接在一起,确定程序变量(或常数)在主存中的位置,装入内存中指定的起始地址,使之成为一个可以运行的绝对指令代码程序。

    上述编译过程的五个阶段是一种典型的分法。事实上,并非所有编译程序都分成这五阶段。有些编译程序对优化没有什么要求,优化阶段就可省去。在某些情况下,为了加快编译速度,中间代码生成阶段也可以去掉。有些最简单的编译程序是在语法分析的同时产生目标代码。但是,多数实用编译程序的工作过程大致都像上面所说的那五个阶段。

    编译程序的结构

    编译程序总框

    上述编译过程的五个阶段是编译程序工作时的动态特征。编译程序的结构可以按照这五阶段的任务分模块进行设计。

    词法分析器,又称扫描器,输入源程序,进行词法分析,输出单词符号。

    语法分析器,简称分析器,对单词符号串进行语法分析(根据语法规则进行推导或归约),识别出各类语法单位,最终判断输入串是否构成语法上正确的“程序”。

    语义分析及中间代码产生器,按照语义规则对语法分析器归约出(或推导出)的语法单位进行语义分析并把它们翻译成一定形式的中间代码。有的编译程序在识别出各类语法单位后,构造并输出一棵表示语法结构的语法树,然后,根据语法树进行语义分析和中间代码产生。还有许多编译程序在识别出语法单位后并不真正构造语法树,而是调用相应的语义子程序。在这种编译程序中,扫描器、分析器和中间代码生成器三者并非是截然分开的,而是相互穿插的。

    优化器,对中间代码进行优化处理。

    目标代码生成器,把中间代码翻译成目标程序。

    除了上述五个功能模块外,一个完整的编译程序还应包括“表格管理”和“出错处理”两部分。

    表格与表格管理

    编译程序在工作过程中需要保持一系列的表格,以登记源程序的各类信息和编译各阶段的进展状况。合理地设计和使用表格是编译程序构造的一个重要问题。在编译程序使用的表格中,最重要的是符号表。它用来登记源程序中出现的每个名字以及名字的各种属性,例如,一个名字是常量名、变量名,还是过程名等等;如果是变量名,它的类型是什么、所占内存是多大、地址是什么等等。通常,编译程序在处理到名字的定义性出现时,要把名字的各种属性填入到符号表中;当处理到名字的使用性出现时,要对名字的属性进行查证。

    当扫描器识别出一个名字(标识符)后,它把该名字填入到符号表中。但这时不能完全确定名字的属性,它的各种属性要在后续的各阶段才能填入。例如,名字的类型等要在语义分析时才能确定,而名字的地址可能要到目标代码生成才能确定。

    由此可见,编译各阶段都涉及到构造、查找、或更新有关的表格。

    出错处理

    一个编译程序不仅应能对书写正确的程序进行翻译,而且应能对出现在源程序中的错误进行处理。如果源程序有错误,编译程序应设法发现错误,把有关错误信息报告给用户。这部分工作是由专门的一组程序(叫做出错处理程序)完成的。一个好的编译程序应能最大限度地发现源程序中的各种错误,准确地指出错误的性质和发生错误的地点,并且能将错误所造成的影响限制在尽可能小的范围内,使得源程序的其余部分能继续被编译下去,以便进一步发现其他可能的错误。如果不仅能够发现错误,而且还能自动校正错误,那当然就更好了。但是,自动校正错误的代价是非常高的。

    编译过程的每一阶段都可能检测出错误,其中,绝大多数错误可以在编译的前三阶段检测出来。源程序中的错误通常分为语法错误和语义错误两大类语法错误是指源程序中不符合语法(或词法)规则的错误,它们可在词法分析或语法分析时检测出来。例如,词法分析阶段能够检测出“非法字符”之类的错误;语法分析阶段能够检测出诸如“括号不匹配”、“缺少 ;”之类的错误。语义错误是指源程序中不符合语义规则的错误,这些错误一般在语义分析时检测出来,有的语义错误要在运行时才能检测出来。语义错误通常包括:说明错误、作用域错误、类型不一致等等。

    遍pass

    在前面己经介绍了编译过程的五个阶段仅仅是逻辑功能上的一种划分。具体实现时,受不同源语言、设计要求、使用对象和计算机条件(如主存容量)的限制,往往将编译程序组织为若干遍(pass)。所谓“遍”就是对源程序或源程序的中间结果从头到尾扫描一次,并作有关的加工处理,生成新的中间结果或目标程序。通常,每遍的工作由从外存上获得的前一遍的中间结果开始(对于第一遍而言,从外存上获得源程序),完成它所含的有关工作之后,再把结果记录于外存。既可以将几个不同阶段合为一遍,也可以把一个阶段的工作分为若干遍。例如,词法分析这一阶段可以单独作为一遍,但更多的时候是把它与语法分析合并为一遍;为了便于处理,语法分析和语义分析及中间代码生成又常常合为一遍。在优化要求很高时,往往还可把优化阶段分为若干遍来实现。

    当一遍中包含若干阶段时,各阶段的工作是穿插进行的。例如,我们可以把词法分析、语法分析及语义分析与中间代码生成这三阶段安排成一遍。这时,语法分析器处于核心位置,当它在识别语法结构而需要下一单词符号时,它就调用词法分析器,一旦识别出一个语法单位时,它就调用中间代码生成器,完成相应的语义分析并产生相应的中间代码。

    一个编译程序究竟应分成几遍,如何划分,是与源语言、设计要求、硬件设备等诸因素有关的,因此难于统一划定。遍数多一点有个好处,即整个编译程序的逻辑结构可能清晰一点。但遍数多势必增加输入/输出所消耗的时间。因此,在主存可能的前提下,一般还是遍数尽可能少一点为好。应当注意的是,并不是每种语言都可以用单遍编译程序实现。

    编译前端与后端

    概念上,我们有时把编译程序划分为编译前端和编译后端前端主要由与源语言有关但与目标机无关的那些部分组成。这些部分通常包括词法分析、语法分析、语义分析及中间代码生成,有的代码优化工作也可包括在前端。后端包括编译程序中与目标机有关的那些部分,如与目标机有关的代码优化和目标代码生成等。通常,后端不依赖于源语言而仅仅依赖于中间语言。

    可以取编译程序的前端,改写其后端以生成不同目标机上的相同语言的编译程序。如果后端的设计是经过精心考虑的,那么后端的改写将用不了太大工作量,这样就可实现编译程序的目标机改变。也可以设想将几种源语言编译成相同的中间语言,然后为不同的前端配上相同的后端,这样就可为同一台机器生成不同语言的编译程序。然而,由于不同语言存在某些微妙的区别,因此在这方面所取得的成果还非常有限。

    为了实现编译程序可改变目标机,通常需要有一种定义良好的中间语言支持。例如,在著名的Ada程序设计环境APSE中,使用的是一种称为Diana的树形结构的中间语言。一个Ada源程序通过前端编译转换为Diana中间代码,由编译后端把Diana中间代码转换为目标代码。编译前端与不同的编译后端以Diana为界面,实现编译程序的目标机改变。

    又如,在Java语言环境中,为了使编译后的程序从一个平台移到另一个平台执行,Java定义一种虚拟机代码—Bytecode。只要实际使用的操作平台上实现了执行Bytecode的Java解释器,这个操作平台就可以执行各种Java程序。这就是所谓Java语言的操作平台无关性。

    编译程序与程序设计环境

    编译程序无疑是实现高级语言的一个最重要的工具。但支持程序设计人员进行程序开发通常还需要一些其他的工具;如编辑程序、连接程序,调试工具等等。编译程序与这些程序设计工具一起构成所谓的程序设计环境。

    在高级语言发展的早期,这些程序设计工具往往是独立的,缺乏整体性,而且也缺乏对软件开发全生命周期的支持 。随着软件技术的不断发展,现在人们越来越倾向于构造集成化的程序设计环境。一个集成化的程序设计环境的特点是,它将相互独立的程序设计工具集成起来,以便为程序员提供完整的、一体化的支持,从而进一步提高程序开发效率,改善程序质量。

    在一个好的集成化程序设计环境中,不仅包含丰富的程序设计工具,而且还支持程序设计方法学,支持程序开发的全生命周期。有代表性的集成化程序设计环境有Ada语言程序设计环境APSE、LISP语言程序设计环境INTERLISP等。广大读者所熟悉的Turbo Pascal、Turbo C、Visual C++等语言环境也都可认为是集成化的程序设计环境。

    在一个程序设计环境中,编译程序起着中心的作用。连接程序、调试程序、程序分析等工具的工作直接依赖于编译程序所产生的结果,而其他工具的构造也常常要用到编译的原理、方法和技术

    编译程序的生成

    以前人们构造编译程序大多是用机器语言或汇编语言作工具的。为了充分发挥各种不同硬件系统的效率,为了满足各种不同的具体要求,现在许多人仍然采用这种工具来构造编译程序(或编译程序的“核心”部分)。但是,越来越多的人已经使用高级语言作工具来编译程序。因为,这样可以大大节省程序设计时间,而且所构造出来的编译程序易于阅读、维护和移植。

    如果A机器上已有一个用A机器代码实现的某高级语言L1的编译程序,则我们可以用L1语言编写另一种高级L2的编译程序,把写好的L2编译程序经过L1编译程序编译后就可得到A机器代码实现的L2编译程序。

    采用一种所谓的“移植”方法,我们可以利用A机器上已有的高级语言L编写一个能够在B机器上运行的高级语言L的编译程序。做法是,先用L语言编写出在A机器上运行的产生B机器代码的L编译程序源程序,然后把该源程序经过A机器上的L编译程序编译后得到能在A机器上运行的产生B机器代码的编译程序,用这个编译程序再一次编译上述编译程序源程序就得到了能在B机器上运行的产生B机器代码的编译程序。

    还可以采用“自编译方式”产生编译程序方法是,先对语言的核心部分构造一个小小的编译程序(可用低级语言实现),再以它为工具构造一个能够编译更多语言成分的较大编译程序。如此扩展下去,就像滚雪球一样,越滚越大,最后形成人们所期望的整个编译程序。这种通过一系列自展途径而形成编译程序的过程叫做自编译过程。

    现在人们已建立了多种编制部分编译程序或整个编译程序的有效工具。有些能用于自动产生扫描器(如LEX),有些可用于自动产生语法分析器(如YACC),有些甚至可用来自动产生整个的编译程序。这些构造编译程序的工具称为编译程序-编译程序、编译程序产生器或翻译程序书写系统,它们是按对源程序和目标语言(或机器)的形式描述(作为输入数据)而自动产生编译程序的。

    参考文献及资源

    1. 陈火旺等,程序设计语言编译原理.国防工业出版社,2000年
    2. Compilers Principles, Techniques and Tools,A.V. Aho,Addison-Wesley,1986年
    3. Donald E. Knuth. The Art of Computer Programming, Volume 1/Fundamental Algorithms. Addison_Wesley, Reading, Massachusetts, Second Edition, 1973.
    4. Donald E. Knuth. The Art of Computer Programming, Volume 2/Seminumberical Algorithms. Addison_Wesley, Reading, Massachusetts, Second Edition, 1981.
    5. 郭浩志. PASCAL语言结构程序设计. 国防科技大学出版社,1988.
    6. 郭浩志. 程序设计语言概论. 国防科技大学出版社,1989.
    7. 易文韬,陈颖平. Java手册. 科学出版社,1997.

    关于编译原理博文更多讨论与交流,敬请关注本博客新浪微博songzi_tea.

    展开全文
  • 词法分析程序又称词法分析器或扫描器,是编译程序的基本子过程之一。 3.1 词法分析程序的功能及实现方案 词法分析程序的功能是:扫描源程序字符,按语言的词法规则识别出各类单词符号(Token),并将有关字符组合...
  • 编译原理】引论

    千次阅读 2020-02-18 20:59:54
    文章目录编译原理引论(一)认识编译程序(二)编译过程概述1、阶段划分2、编译程序的结构3、编译程序的生成 编译原理引论 (一)认识编译程序 什么是编译程序? 这要从翻译程序、解释程序以及编译程序的联系与区别...
  • vscode安装使用教程

    万次阅读 多人点赞 2018-12-11 19:18:48
    如果重启后还是英文的,那么在商店查看已安装的插件,把中文插件Chinese(simplified) 重新安装一,然后重启软件即可。 汉化成功: 五、几个常用命令说明 注意 1.Ctrl+shift+F 在文件中查找,可以...
  • 从源代码生成可执行文件的各个阶段为: C源程序(.c)->编译预处理(.i)->编译(.s)->优化程序->汇编程序(.o)->链接程序->可执行文件(.exe) ...预处理过程在编译时处理包含其他源文件、定义宏、根据条
  • C/C++程序编译过程详解

    万次阅读 多人点赞 2017-11-13 14:51:06
    C/C++程序编译过程详解 C语言的编译链接过程要把我们编写的一个c程序(源代码)转换成可以在硬件上运行的程序(可执行代码),需要进行编译和链接。编译就是把文本形式源代码翻译为机器语言形式的目标文件...
  • 编译原理的基本概念(一)

    千次阅读 2020-05-19 20:05:28
    编译原理的基本概念(一) 1.词法分析 词法分析程序又称为扫描程序。进行词法分析时,依次读入源程序中的每个字符,依据语言的构词规则,识别出一个个具有独立意义的最小语法单位,即“单词”,并用某个单词符号来...
  • 程序到可执行程序编译过程

    千次阅读 2019-09-19 22:49:47
    一份源代码,从开始产生到成为可执行程序的过程:预处理——编译——汇编——链接。 1、预处理 预处理又叫预编译,主要解释源文件中所有的预处理指令,包括头文件的展开和宏定义的替换,形成.i文件;具体细节...
  • C源程序头文件-->预编译处理(cpp)-->编译程序本身-->优化程序-->汇编程序-->链接程序-->可执行文件 编译,编译程序读取源程序(字符流),对之进行词法和语法的分析,将高级语言指令转换为功能等效的...
  • JAVA表白小程序

    千次阅读 多人点赞 2020-03-07 21:32:24
    如题,微信表白小程序 分析 3.7号,我们是女生节,班级准备给女生点礼物,我的直男想法就想到了抖音那种表白小程序,感觉或许挺好玩的,就开始制作了 制作前先想想用什么语言写比较好.备选项有Python,JAVA,Androidc,c++...
  • 所谓预处理是指进行编译的第一扫描(词法扫描和语法分析)之前所做的工作。系统会自动将’#'开头的预处理部分做进行处理,处理完毕后进行进入源程序编译阶段。 C语言中提供多种预处理功能,如宏定义、文件包含、...
  • 在eclipse中移植程序的过程中,遇到一个奇葩的问题,就是编译器报.c文件中的宏定义找不到的错误,但是包含该宏定义的头文件已经在开头的时候include了,clean整个工程重新编译还是不行,万般无奈之下把包含BSP...
  • 程序编译与执行过程

    万次阅读 2018-02-25 23:36:43
    本文以C程序为例。... 这一步处理 头文件、条件编译指令和宏定义。 第二步,编译. 将第一步产生的文件连同其他源文件一起编译成汇编代码。 第三步,汇编。将第二步产生的汇编源码转换为 object fi...
  • (1)理解词法分析在编译程序中的作用 (2)加深对有穷自动机模型的理解 (3)掌握词法分析程序的实现方法和技术 实验要求 (1)待分析的简单语言的词法 关键字 begin if then while do end 运算符和...
  • PSCAD快速上手和常见问题解决办法

    万次阅读 多人点赞 2019-08-13 20:55:04
    PSCAD快速上手和常见问题解决办法PSCAD文件编译过程如何新建一个项目?如何添加元件到case里?如何新建元件?PSCAD模型常见问题及解决办法1. 缺少Gfortran编译器2.扩展的库文件链接地址错误3.库文件重复定义4.缺少...
  • 编译原理(1):绪论

    千次阅读 2017-09-17 11:33:10
    本文内容:介绍什么是编译程序,编译过程和编译程序的结构,解释程序和一些软件工具,程序设计语言范型。
  • 软件测试入门知识了解

    万次阅读 多人点赞 2018-09-05 14:59:58
    需求评审和设计评审是验证软件产品的需求定义和设计实现,验证所定义的产品特性是否符合客户的期望、系统的设计是否合理、是否具有可测试性以及满足非功能质量特性的要求。这个阶段主要通过对需求文档、设计文档等...
  • 编译原理_pl0程序分析及注释

    万次阅读 多人点赞 2017-06-04 13:38:24
    作者:love冥天 ...   PL/0语言是Pascal语言的一个子集,我们这里分析的PL/0的编译程序包括了对PL/0语言源...PL/0语言编译程序采用以语法分析为核心、一扫描的编译方法。词法分析和代码生成作为独立的子程序供语
  • 编译原理实验四:语法分析程序

    千次阅读 2019-01-29 20:59:53
    学习已有编译器的经典语法分析源程序。 实验任务 阅读已有编译器的经典语法分析源程序,并测试语法分析器的输出。 实验内容 (1)选择一个编译器,如:TINY,其它编译器也可(需自备源代码)。 (2)阅读...
  • C/C++程序编译链接过程详解

    千次阅读 2020-08-15 15:08:16
    编译,编译程序读取源程序(字符流),对之进行词法和语法的分析,将高级语言指令转换为功能等效的汇编代码,再由汇编程序转换为机器语言,并且按照操作系统对可执行文件格式的要求链接生成可执行程序。 C源程序...
  • 今天写程序,碰到了一个头疼的问题,一直给我讲multiply defination of。。。很烦,我检查了好多,我明明有加#ifndef... 我定义的全局变量还是有重复定义的报错,百度了之后终于清楚了,大家不妨也看看,以后...
  • verilog 综合注意事项

    万次阅读 多人点赞 2016-07-29 15:46:40
    *看了5本书,居然没有一本书讲到能否综合,所以设计出来的程序完全不能用~~~ * *而且,书中都是讲语句的具体使用办法,例如always @(),但是什么时候用always,几个always之间、时序电路、逻辑电路、任务与函数...
  • 部分代码如下:  #include  #include  main() { double x = 1.0; double ans; ans = sqrt(x); printf("\nans is %lf\n", ans);...编译: [root@Xecho mycode]# gcc -o 1 1.c /tmp/ccdzoSZq.o(.text+0x9
  • 编译原理(一、引论)

    千次阅读 2018-03-06 18:58:21
    前言:最近学习编译原理,遂参照教材作以记录。各位读者若对本文所述有质疑,欢迎...现代计算机系统一般都含有不止一个的高级语言编译程序,对于有些高级语言甚至配置了几个不同性能的编译程序,供用户按不同需要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 80,560
精华内容 32,224
关键字:

编译程序的遍定义