编译原理实践教程解读

上机内容：词法分析部分（2.1节），其余部分不用做。后文代码供参

考，也可使用自己熟悉的语言另外编写代码。

上机地点：C205教室

上机时间：六月八号（周一）第四大节

序言 .......................................................................................................................................................... 2 第一部分 PL/0语言及其编译器 ........................................................................................................... 3 1. PL/0语言介绍 ................................................................................................................................. 3 1.1 PL/0语言的语法图 ................................................................................................................. 4 2. PL/0语言编译器 ............................................................................................................................. 7 2.1 词法分析 .................................................................................................................................. 8 2.2 语法分析 ................................................................................................................................... 8 2.3 语义分析 ................................................................................................................................. 10

2.4 代码生成 ................................................................................................................................ 10 2.5 代码执行 ................................................................................................................................. 12 2.6 错误诊断处理 ......................................................................................................................... 14 2.7 符号表管理 ............................................................................................................................. 16 2.8 其他 ........................................................................................................................................ 17

第二部分 上机实践要求 ...................................................................................... 错误！未定义书签。 第三部分 PL/0语言编译器源程序 ..................................................................................................... 18 1．一个例子 ...................................................................................................................................... 18 1.1 PL/0语言源程序 .................................................................................................................... 18 1.2 生成的代码（片段） ............................................................................................................ 20 2. PL/0语言编译器源程序 ............................................................................................................... 20

1

编译原理实践教程

序言

《编译原理和技术》的课程实践至少有两种可能的安排。其一，为配合编译课程教学，而安排多次小型实践，分别支持编译程序的各个阶段。其二，针对某一规模适中的语言来设计和实现一个相对完整、独立编译器。

《编译原理实践教程》作为《编译原理和技术》课程的延伸，其目的是让大家动手设计和实现某一规模适中的语言的编译器，该编译器不仅涉及编译程序的各个阶段，而且也强调了编译的总体设计、各个阶段的接口安排等等。

通过上机实践，来设计这个相对完整的编译器，一方面可以使学生增加对编译程序的整体认识和了解——巩固《编译原理和技术》课程所学知识，另一方面，通过上机练习，学生也可以学到很多程序调试技巧和设计大型程序一般的原则，如模块接口的协调，数据结构的合理选择等等。

为了使学生能尽早动手实践，我们建议把实践分成三部分，首先阅读本教程第一部分，在这部分就PL/0语言的语法及其编译程序的各个阶段作了简单介绍，以便对PL/0编译程序有个初步的印象。其次要认真阅读理解第三部分所给出的PL/0编译器源程序，使上一阶段的初步印象得以加深、具体化。最后按照第二部分的实验要求扩充PL/0语言的功能并加以实现。

2

第一部分 PL/0语言及其编译器

1. PL/0语言介绍

PL/0程序设计语言是一个较简单的语言，它以赋值语句为基础，构造概念有顺序、条件和重复（循环）三种。PL/0有子程序概念，包括过程定义（可以嵌套）与调用且有局部变量说明。PL/0中唯一的数据类型是整型，可以用来说明该类型的常量和变量。当然PL/0也具有通常的算术运算和关系运算。具体的PL/0语法图如下。

3

1.1 PL/0语言的语法图

程序

程序体

语句序列 程序体 . const , ; var , ident = number ident ; procedure ident ; ; 程序体 语句 语句 ; 4

语句 条件 表达式 ident := 表达式 call ident begin 语句序列 end if 条件 then 语句 while 条件 do 语句 odd 表达式 表达式 = <> < > <= >= 表达式 + 项 - + - 项 5

项 因子

因子 * / 因子 ident number ( 表达式 ) 6

2. PL/0语言编译器

本书所提供的PL/0语言编译器的基本工作流程如图1-1所示：

源程序

词法分析 语法分析 符号表管理语义分析 错误诊断处理 代码生成 代码执行 执行结果

图1-1 PL/0编译器基本工作流程

7

2.1 词法分析

PL/0的语言的词法分析器将要完成以下工作： （1） 跳过分隔符（如空格，回车，制表符）；

（2） 识别诸如begin，end，if，while等保留字； （3） 识别非保留字的一般标识符，此标识符值（字符序列）赋给全局量id，

而全局量sym赋值为SYM_IDENTIFIER。

（4） 识别数字序列，当前值赋给全局量NUM，sym则置为SYM_NUMBER； （5） 识别:=，<=，>=之类的特殊符号，全局量sym则分别被赋值为

SYM_BECOMES，SYM_LEQ，SYM_GEQ等。

相关过程（函数）有getsym()，getch()，其中getch()为获取单个字符的过程，除此之外，它还完成：

（1） 识别且跳过行结束符；

（2） 将输入源文件复写到输出文件；

（3） 产生一份程序列表，输出相应行号或指令计数器的值。

2.2 语法分析

我们采用递归下降的方法来设计PL/0编译器。以下我们给出该语言的FIRST和FOLLOW集合。

非终结符（S） FIRST(S) 程序体 const var procedure ident call if begin while 语句 ident call begin if while 条件 odd + - ( ident number 表达式 + - ( ident number 项 ident number ( 因子 ident number ( FOLLOW(S) . ; . ; end then do . ; ) R end then do . ; ) R + - end then do . ; ) R + - * / end then do 注：表中R代表六个关系运算符。 不难证明，PL/0语言属于LL（1）文法。（证明从略。） 以下是我们给出如何结合语法图编写（递归下降）语法分析程序的一般方法。假定图S所对应的程序段为T（S），则：

（1） 用合适的替换将语法约化成尽可能少的单个图；

（2） 将每一个图按下面的规则（3）-（7）翻译成一个过程说明； （3） 顺序图对应复合语句：

S1 S2 Sn

对应：begin T(S1); T(S2); ...; T(Sn) end

（4） 选择：

8

S1 S2 S3

对应：case语句或者条件语句：

case ch of if ch in L1 then T(S1) else L1: T(S1); if ch in L2 then T(S2) else L2: T(S2); 或 ...

... if ch in Ln then T(Sn) else Ln: T(Sn); error

其中Li∈FIRST（Si），ch为当前输入符号。（下同） （5） 循环

S 对应：while ch in L do T(S)

（6） 表示另一个图A的图：

A 对应：过程调用A。

（7） 表示终结符的单元图：

x 对应：if ch == x then read(ch) else error

相关过程有：

block(), constdeclaration(), vardeclaration(), statement(), condition(), expression(), term(), factor()等。 它们之间依赖关系如图1-2：

9

程序 程序体 语句 条件 表达式 项 因子 图1-2 语法分析过程依赖关系

2.3 语义分析

PL/0的语义分析主要进行以下检查：

（1） 是否存在标识符先引用未声明的情况； （2） 是否存在己声明的标识符的错误引用； （3） 是否存在一般标识符的多重声明。

2.4 代码生成

PL/0编译程序不仅完成通常的词法分析、语法分析，而且还产生中间代码和“目标”代码。最终我们要“运行”该目标码。为了使我们的编译程序保持适当简单的水平，不致陷入与本课程无关的实际机器的特有性质的考虑中去，我们假想有台适合PL/0程序运行的计算机，我们称之为PL/0处理机。PL/0处理机顺序解释生成的目标代码，我们称之为解释程序。注意：这里的假设与我们的编译概念并不矛盾，在本课程中我们写的只是一个示范性的编译程序，它的后端无法

10

完整地实现，因而只能在一个解释性的环境下予以模拟。从另一个角度上讲，把解释程序就看成是PL/0机硬件，把解释执行看成是PL/0的硬件执行，那么我们所做的工作：由PL/0源语言程序到PL/0机器指令的变换，就是一个完整的编译程序。

PL/0处理机有两类存贮，目标代码放在一个固定的存贮数组code中，而所需数据组织成一个栈形式存放。

PL/0处理机的指令集根据PL/0语言的要求而设计，它包括以下的指令： （1）LIT /* 将常数置于栈顶 */ （2）LOD /* 将变量值置于栈顶 */ （3）STO /* 将栈顶的值赋与某变量 */ （4）CAL /* 用于过程调用的指令 */

（5）INT /* 在数据栈中分配存贮空间 */ （6）JMP, JPC /* 用于if, while语句的条件或无条件控制转移指令 */ （7）OPR /* 一组算术或逻辑运算指令 */

上述指令的格式由三部分组成：

F L A 其中，f, l, a的含义见下表：

F INT LIT LOD STO CAL JMP JPC OPR L ——— ——— 层次差 层次差 层次差 ——— ——— ——— a 常 量 常 量 数据地址 数据地址 程序地址 程序地址 程序地址 运算类别

表2-1 PL/0 处理机指令

上表中，层次差为变量名或过程名引用和声明之间的静态层次差别，程序地址为目标数组code的下标，数据地址为变量在局部存贮中的相对地址。

PL/0的编译程序为每一条PL/0源程序的可执行语句生成后缀式目标代码。这种代码生成方式对于表达式、赋值语句、过程调用等的翻译较简单。 如赋值语句X := Y op Z（op为某个运算符），将被翻译成下面的目标代码序列：（设指令计数从第100号开始）

No. f L a 100 101 102 103

LOD LOD OPR STO Level_diff_Y Level_diff_Z —————— Level_diff_X 11

Addr_Y Addr_Z op Addr_X

而对if和while语句稍繁琐一点，因为此时要生成一些跳转指令，而跳转的目标地址大都是未知的。为解决这一问题，我们在PL/0编译程序中采用了回填技术，即产生跳转目标地址不明确的指令时，先保留这些指令的地址（code数组的下标），等到目标地址明确后再回过来将该跳转指令的目标地址补上，使其成为完整的指令。下表是if、while语句目标代码生成的模式。（L1，L2是代码地址）

if C then S While C do S 条件C的目标代码 L1: 条件C的目标代码 JPC -- L1 JPC – L2 语句S的目标代码 语句S的目标代码 L1: ... JMP L1 L2: ... 表2-2 if-while语句目标代码生成模式

相关过程（函数）有：gen()，其任务是把三个参数f、l、a组装成一条目标指令并存放于code数组中，增加CX的值，CX表示下一条即将生成的目标指令的地址。

2.5 代码执行

为了简单起见，我们假设有一个PL/0处理机，它能够解释执行PL/0编译程序所生成的目标代码。这个PL/0处理机有两类存贮、一个指令寄存器和三个地址寄存器组成。程序（目标代码）存贮称为code，由编译程序装入，在目标代码执行过程中保持不变，因此它可被看成是“只读”存贮器。数据存贮S组织成为一个栈，所有的算术运算均对栈顶元和次栈顶元进行（一元运算仅作用于栈顶元），并用结果值代替原来的运算对象。栈顶元的地址（下标）记在栈顶寄存器T中，指令寄存器I包含着当前正在解释执行的指令，程序地址寄存器P指向下一条将取出的指令。

PL/0的每一个过程可能包含着局部变量，因为这些过程可以被递归地调用，故在实际调用前，无法为这些局部变量分配存贮地址。各个过程的数据区在存贮栈S内顺序叠起来，每个过程，除用户定义的变量外，还应当有它自己的内部信息，即调用它的程序段地址（返回地址）和它的调用者的数据区地址。在过程终止后，为了恢复原来程序的执行，这两个地址都是必须的。我们可将这两个内部值作为位于该过程数据区的内部式隐式局部变量。我们把它们分别称为返回地址（return address）RA和动态链（dynamic link）DL。动态链的头，即最新分配的数据区的地址，保存在某地址寄存器B内。

因为实际的存贮分配是运行（解释）时进行的，编译程序不能为其生成的代码提供绝对地址，它只能确定变量在数据区内的位置，因此它只能提供相对地址。为了正确地存取数据，解释程序需将某个修正量加到相应的数据区的基地址上去。若变量是局部于当前正在解释的过程，则此基地址由寄存器B给出，否则，就需要顺着数据区的链逐层上去找。然而遗憾的是，编译程序只能知道存取路线

12

的表的长度，同时动态链保存的则是过程活动的动态历史，而这两条存取路线并不总是一样。

例如，假定有过程A，B，C，其中过程C的说明局部于过程B，而过程B的说明局部于过程A，程序运行时，过程A调用过程B，过程B则调用过程C，过程C又调用过程B，如下图所示：

A

A

B

BA

C B

C

图2-1 过程说明嵌套图 过程调用图 表示A调用B

从静态的角度我们可以说A是在第一层说明的，B是在第二层说明的，C则是在第三层说明的。若在B中存取A中说明的变量a，由于编译程序只知道A，B间的静态层差为1，如果这时沿着动态链下降一步，将导致对C的局部变量的操作。为防止这种情况发生，有必要设置第二条链，它以编译程序能明了的方式将各个数据区连接起来。我们称之为静态链（static link）SL。这样，编译程序所生成的代码地址是一对数，指示着静态层差和数据区的相对修正量。下面我们给出的是过程A、B和C运行时刻的数据区图示：

DL RA SL A的变量 B的变量 C的变量 B的变量

13

有了以上认识，我们就不难明白PL/0源程序的目标代码是如何被解释执行的。以语句X ：= Y op Z为例，（该语句的目标代码序列我们己在2.4节给出），PL/0处理机解释该指令的“步骤”如下： step 1,

S[++T] ← S[base(level_diff_Y) + addr_Y]; // 将变量Y的值放在栈顶 step 2,

S[++T] ← S[base(level_diff_Z) + addr_Z];

// 将变量Z的值放在栈顶，此栈顶元为变量Y的值 step 3, T--;

// 栈顶指针指向次栈顶元，即存放结果的单元 step 4,

S[T] ← S[T] op S[T + 1];

// 变量Y和变量Z之间进行“op”操作 step 5,

S[base(level_diff_X) + addr_X] ← S[T]; // 将栈顶的值存放到变量X所在的单元 step 6, T--;

// 栈顶指针减一

相关过程：base()，interpret()。其中base()的功能是根据层次差并从当前数据区沿着静态链查找，以便获取变量实际所在的数据区其地址；interpret()则完成各种指令的执行工作。

2.6 错误诊断处理

一个编译程序，在多数情况下，所接受的源程序正文都是有错误的。发现错误，并给出合适的诊断信息且继续编译下去从而发现更多的错误，对于编译程序而言是完全必要的。一个好的编译器，其特征在于： ? 任何输入序列都不会引起编译程序的崩溃。

? 一切按语言定义为非法的结构，都能被发现和标志出来。 ? 经常出现的错误，程序员的粗心或误解造成的错误能被正确地诊断出来，而不致引起进一步的株连错误。

根据这样的要求，我们为PL/0编译程序制定了以下两条规则：

（1） 关键字规则；程序员在写程序时，可能会因为粗心而漏掉语句的分隔

符——“;”，但他决不会漏掉算术运算符“+”，对于编译程序而言，不论是分隔符号类的符号还是关键字符号类的符号，它们都具有同等重要的地位。基于这样的特点，我们可以采用不易出错的部分来作为恢复正常步调的标记。每当遇到错误时，分析程序跳过后面的某些部分，直到出现所期望的符号为止。对于程序设计语言来说，这种符号

14

（称为同步符号）的最好选择就是关键字。PL/0的每一种构造语句以begin、if或while开头；每种说明则以var、const或procedure开头。每遇到错误时，编译程序便可跳过一段程序，直到遇到这类符号为止，而继续编译。

（2） 镇定规则；自顶向下分析的特点在于目标对分成一些子目标，分程序

则用别的分析程序来处理其子目标。镇定规则是说一个分析程序发现了错误，它不应该消极地停止前进，仅仅向调用它的程序报告发生的错误；而应该自己继续向前扫描，找到似乎可以使正常的分析得以恢复的地方。这一规则在程序设计上的含义就是任一分析程序除了正常终止外，没有其它出口。

对于镇定规则，一个可能的严格解释为：一旦发现非法结构，即跳过后面的输入正文，直到下一个可以正确地跟随当前正在分析的句子结构的符号为止。这意味着每一分析程序需知道其当前活动结点的后继符号集合。

为了找到这个后继符号集合，我们给对应语法图的每一个分析过程提供一个显式参数，set，它指明可能的后继集合。不过在任何条件下，如果都跳到输入正文中下一个这种后继符号出现的地方，未免太短视了。程序中所含的错误可能只不过是漏掉了一个符号（如“;”）而己，由此而忽略去源程序的符号集合中，再凑加一些关键字，它们用于标记那些不容忽略的结构的开始符，因此，作为参数传递给分析过程的那些符号就不仅是后继符号了。 对于这样的符号集，我们采用这样的计算策略：先用一些明显的关键符号给它赋初值，然后随着分析子目标的层次深入，逐步补充别的合法符号。为了灵活起见，我们引入test子程序来实现所说的验证工作。 test过程有三个参数：

（1） 可允许的下一个符号集合S1，如果当前符号不在此集合中，当即

得到一个错误号；

（2） 另加的停止符号集合S2，有些符号的出现，虽然无疑是错的，但

它们绝对不应被忽略而跳过； （3） 整数n，表示有关错误的诊断号： void test(symset s1, symset s2, int n) {

symset s;

if (! inset(sym, s1)) {

error(n);

s = uniteset(s1, s2); while(! inset(sym, s)) getsym(); destroyset(s); } }

我们前面提出的方案，具有这样的性质：试图通过略过输入正文中的一个或多个符号来恢复分析的正常步调。在错误仅为漏掉一个符号所引起的情况下，它都是不适宜的策略。经验表明，这类错误基本上限于那种仅有语法作用，而不代

15

表动作的符号（如“;”）。把一些关键字加到后继符号集合中去可使分析程序不再盲目地跳过后面的符号，好象漏掉的已经补上去一样。下面程序段就是PL/0分析程序中复合语句分析的一小段。它的效果等于关键字前插入漏掉的分号。statbegsys集合是“语句”这个结构的首符号集。

if (sym == SYM_BEGIN) { getsym();

set1 = createset(SYM_SEMICOLON, SYM_END, SYM_NULL); set = uniteset(set1, fsys); statement(set);

while (sym == SYM_SEMICOLON || inset(sym, statbegsys)) {

if (sym == SYM_SEMICOLON) {

getsym(); } else {

error(10); }

statement(set); } // while

destroyset(set1); destroyset(set); if (sym == SYM_END) {

getsym(); } else {

error(17); // ';' or 'end' expected. } }

相关过程：test(), inset(), createset, uniteset(), error().

2.7 符号表管理

为了组成一条指令，编译程序必须知道其操作码及其参数（数或地址）。这些值是由编译程序本身联系到相应标识符上去的。这种联系是在处理常数、变量和过程说明完成的。为此，标识符表应包含每一标识符所联系的属性；如果标识符被说明为常数，其属性值为常数值；如果标识符被说明成变量，其属性就是由层次和修正量（偏移量）组成的地址；如果标识符被说明为过程，其属性就是过程的入口地址及层次。

常数的值由程序正文提供，编译的任务就是确定存放该值的地址。我们选择

16

顺序分配变量和代码的方法；每遇到一个变量说明，就将数据单元的下标加一（PL/0机中，每个变量占一个存贮单元）。开始编译一个过程时，要对数据单元的下标dx赋初值，表示新开辟一个数据区。dx的初值为3，因为每个数据区包含三个内部变量RA，DL和SL。

相关过程：enter()，该函数用于向符号表添加新的符号，并确定标识符的有关属性。

2.8 其他

本教程所提供的PL/0编译程序包括词法分析、语法分析、错误诊断、代码生成、解释执行等几部分。关于这几个程序，我们做如下说明：

（1） 每一个分程序（过程）被编译结束后，将列出该部分PL/0程序代码。

这个工作由过程listcode()完成。注意，每个分程序（过程）的第一条指令未被列出。该指令是跳转指令。其作用是绕过该分程序的说明部分所产生的代码（含过程说明所产生的代码）。

（2） 解释程序作为PL/0编译程序的一个过程，若被编译的源代码没有错

误，则编译结束时调用这个过程。

（3） PL/0语言没有输出语句。解释程序按执行次序，每遇到对变量的赋值

就输出其值。

17

第三部分 PL/0语言编译器源程序

1．一个例子

1.1 PL/0语言源程序

下面我们给出一个PL/0语言写的二数相乘、除并求最大公约数的算法：

const m = 7, n = 85; var x, y, z, q, r;

procedure multiply; var a, b; begin

a := x; b := y; z := 0; while b > 0 do begin

if odd b then z := z + a; a := 2 * a; b := b / 2; end end;

procedure divide; var w; begin

r := x; q := 0; w := y; while w > y do begin

q := 2 * q; w := w / 2; if w <= r then begin

r := r - w; q := q + 1; end; end end;

procedure gcd;

18

var f, g; begin

f := x; g := y;

while f <> g do begin

if f < g then g := g – f; if g < f then f := f – g; end end;

begin

x := m; y := n; call multiply; x := 25; y := 3; call divide; x := 34; y := 36; call gcd; end.

19

1.2 生成的代码（片段）

前面我们给出了PL/0语言写的一段程序，其中乘法过程经过编译程序产生以下代码：

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

INT LOD 1 STO LOD 1 STO LIT STO LOD 0 LIT OPR JPC LOD 0 OPR JPC LOD 1 LOD 0 OPR STO LIT LOD 0 OPR STO LOD 0 LIT OPR STO JMP OPR

0 3 0 4 0 0 1 4 0 0 0 4 0 0 5 3 0 1 0 3 0 0 4 0 0 0 0 0

5 -- 3 -- 4 0 5 -- 0 12 29 -- 6 20 -- -- 2 5 2 -- 4 3 -- 2 2 4 9 0

-- x -- y -- -- -- b -- -- -- b -- -- z a -- -- -- a -- -- b -- -- -- -- --

allocate storage a b 0 z

a := x b := y z := 0

b > 0 0

>

if b <= 0 then goto 29 odd

if not(odd(b)) goto 20

if

+ z 2 * a

z := z + a

while

odd(b)

a := 2 * a

2

b := b / 2

/ b

goto 9 return

上述代码采用助记符形式，“--”后面是为了便于理解而额外加上的注释，大括号右边为左部代码序列对应的源程序中的语句或表达式。

2. PL/0语言编译器源程序

PL/0语言编译器源程序包括如下C程序文件，PL0.h、PL0.c、set.h和set.c。

20

/************ PL0.h *************/

#include

#define NRW 11 // number of reserved words #define TXMAX 500 // length of identifier table

#define MAXNUMLEN 14 // maximum number of digits in numbers

#define NSYM 10 // maximum number of symbols in array ssym and csym #define MAXIDLEN 10 // length of identifiers

#define MAXADDRESS 32767 // maximum address

#define MAXLEVEL 32 // maximum depth of nesting block #define CXMAX 500 // size of code array

#define MAXSYM 30 // maximum number of symbols

#define STACKSIZE 1000 // maximum storage

enum symtype {

SYM_NULL,

SYM_IDENTIFIER, SYM_NUMBER, SYM_PLUS, SYM_MINUS, SYM_TIMES, SYM_SLASH, SYM_ODD, SYM_EQU, SYM_NEQ, SYM_LES, SYM_LEQ, SYM_GTR, SYM_GEQ, SYM_LPAREN, SYM_RPAREN, SYM_COMMA, SYM_SEMICOLON, SYM_PERIOD, SYM_BECOMES, SYM_BEGIN, SYM_END, SYM_IF, SYM_THEN,

21

SYM_WHILE, SYM_DO, SYM_CALL, SYM_CONST, SYM_VAR,

SYM_PROCEDURE };

enum idtype {

ID_CONSTANT, ID_VARIABLE, ID_PROCEDURE };

enum opcode {

LIT, OPR, LOD, STO, CAL, INT, JMP, JPC };

enum oprcode {

OPR_RET, OPR_NEG, OPR_ADD, OPR_MIN, OPR_MUL, OPR_DIV, OPR_ODD, OPR_EQU, OPR_NEQ, OPR_LES, OPR_LEQ, OPR_GTR, OPR_GEQ };

typedef struct {

int f; // function code int l; // level

int a; // displacement address } instruction;

////////////////////////////////////////////////////////////////////// char* err_msg[] = {

/* 0 */ \

/* 1 */ \

/* 2 */ \

/* 3 */ \/* 4 */ \must be an identifier to follow 'const', 'var', or 'procedure'.\/* 5 */ \

/* 6 */ \

22

/* 7 */ \

/* 8 */ \/* 9 */ \/* 10 */ \

/* 11 */ \/* 12 */ \/* 13 */ \

/* 14 */ \/* 15 */ \/* 16 */ \

/* 17 */ \/* 18 */ \/* 19 */ \

/* 20 */ \

/* 21 */ \/* 22 */ \

/* 23 */ \

/* 24 */ \/* 25 */ \/* 26 */ \/* 27 */ \/* 28 */ \/* 29 */ \/* 30 */ \/* 31 */ \

/* 32 */ \};

////////////////////////////////////////////////////////////////////// char ch; // last character read int sym; // last symbol read

char id[MAXIDLEN + 1]; // last identifier read int num; // last number read int cc; // character count int ll; // line length int kk; int err;

int cx; // index of current instruction to be generated. int level = 0; int tx = 0;

char line[80];

instruction code[CXMAX];

23

char* word[NRW + 1] = {

\

\ \};

int wsym[NRW + 1] = {

SYM_NULL, SYM_BEGIN, SYM_CALL, SYM_CONST, SYM_DO, SYM_END, SYM_IF, SYM_ODD, SYM_PROCEDURE, SYM_THEN, SYM_VAR, SYM_WHILE };

int ssym[NSYM + 1] = {

SYM_NULL, SYM_PLUS, SYM_MINUS, SYM_TIMES, SYM_SLASH,

SYM_LPAREN, SYM_RPAREN, SYM_EQU, SYM_COMMA, SYM_PERIOD, SYM_SEMICOLON };

char csym[NSYM + 1] = {

' ', '+', '-', '*', '/', '(', ')', '=', ',', '.', ';' };

#define MAXINS 8

char* mnemonic[MAXINS] = {

\};

typedef struct {

char name[MAXIDLEN + 1]; int kind; int value; } comtab;

comtab table[TXMAX];

24

typedef struct {

char name[MAXIDLEN + 1]; int kind; short level; short address; } mask;

FILE* infile;

// EOF PL0.h

25

/************ SET.h *************/

#ifndef SET_H #define SET_H

typedef struct snode {

int elem;

struct snode* next; } snode, *symset;

symset phi, declbegsys, statbegsys, facbegsys, relset;

symset createset(int data, .../* SYM_NULL */); void destroyset(symset s);

symset uniteset(symset s1, symset s2); int inset(int elem, symset s);

#endif

// EOF set.h

26

/************ SET.c *************/

#include #include #include #include \

symset uniteset(symset s1, symset s2) {

symset s; snode* p;

s = p = (snode*) malloc(sizeof(snode)); while (s1 && s2) {

p->next = (snode*) malloc(sizeof(snode)); p = p->next;

if (s1->elem < s2->elem) {

p->elem = s1->elem; s1 = s1->next; } else {

p->elem = s2->elem; s2 = s2->next; } }

while (s1) {

p->next = (snode*) malloc(sizeof(snode)); p = p->next;

p->elem = s1->elem; s1 = s1->next; }

while (s2) {

p->next = (snode*) malloc(sizeof(snode)); p = p->next;

p->elem = s2->elem; s2 = s2->next;

27

}

p->next = NULL;

return s; } // uniteset

void setinsert(symset s, int elem) {

snode* p = s; snode* q;

while (p->next && p->next->elem < elem) {

p = p->next; }

q = (snode*) malloc(sizeof(snode)); q->elem = elem; q->next = p->next; p->next = q; } // setinsert

symset createset(int elem, .../* SYM_NULL */) {

va_list list; symset s;

s = (snode*) malloc(sizeof(snode)); s->next = NULL;

va_start(list, elem); while (elem) {

setinsert(s, elem);

elem = va_arg(list, int); }

va_end(list); return s; } // createset

void destroyset(symset s) {

snode* p;

28

while (s) {

p = s;

s = s->next; free(p); }

} // destroyset

int inset(int elem, symset s) {

s = s->next;

while (s && s->elem < elem) s = s->next;

if (s && s->elem == elem) return 1; else

return 0; } // inset

// EOF set.c

29

/************ PL0.c *************/

// pl0 compiler source code

#include #include #include #include #include \#include \

////////////////////////////////////////////////////////////////////// // print error message. void error(n) {

int i;

printf(\

for (i = 1; i <= cc - 1; i++) printf(\ printf(\

printf(\ err++; } // error

////////////////////////////////////////////////////////////////////// void getch(void) {

if (cc == ll) {

if (feof(infile)) {

printf(\ exit(1); }

ll = cc = 0;

printf(\

while (!feof(infile) && (ch = getc(infile))!='\\n') {

printf(\ line[++ll] = ch; } // while printf(\ line[++ll] = ' ';

30

}

ch = line[++cc]; } // getch

////////////////////////////////////////////////////////////////////// // gets a symbol from input stream. void getsym(void) {

int i, k;

char a[MAXIDLEN + 1];

while (ch == ' ') getch();

if (isalpha(ch))

{ // symbol is a reserved word or an identifier. k = 0; do {

if (k < MAXIDLEN) a[k++] = ch; getch(); }

while (isalpha(ch) || isdigit(ch)); a[k] = 0;

strcpy(id, a); word[0] = id; i = NRW;

while (strcmp(id, word[i--])); if (++i)

sym = wsym[i]; // symbol is a reserved word else

sym = SYM_IDENTIFIER; // symbol is an identifier }

else if (isdigit(ch)) { // symbol is a number. k = num = 0;

sym = SYM_NUMBER; do {

num = num * 10 + ch - '0'; k++; getch(); }

31

while (isdigit(ch)); if (k > MAXNUMLEN)

error(25); // The number is too great. }

else if (ch == ':') {

getch();

if (ch == '=') {

sym = SYM_BECOMES; // := getch(); } else {

sym = SYM_NULL; // illegal? } }

else if (ch == '>') {

getch();

if (ch == '=') {

sym = SYM_GEQ; // >= getch(); } else {

sym = SYM_GTR; // > } }

else if (ch == '<') {

getch();

if (ch == '=') {

sym = SYM_LEQ; // <= getch(); }

else if (ch == '>') {

sym = SYM_NEQ; // <> getch(); } else

32

{

sym = SYM_LES; // < } } else

{ // other tokens i = NSYM; csym[0] = ch;

while (csym[i--] != ch); if (++i) {

sym = ssym[i]; getch(); } else {

printf(\ exit(1); } }

} // getsym

////////////////////////////////////////////////////////////////////// // generates (assembles) an instruction. void gen(int x, int y, int z) {

if (cx > CXMAX) {

printf(\ exit(1); }

code[cx].f = x; code[cx].l = y; code[cx++].a = z; } // gen

//////////////////////////////////////////////////////////////////////

// tests if error occurs and skips all symbols that do not belongs to s1 or s2. void test(symset s1, symset s2, int n) {

symset s;

if (! inset(sym, s1)) {

33

error(n);

s = uniteset(s1, s2); while(! inset(sym, s)) getsym(); destroyset(s); } } // test

////////////////////////////////////////////////////////////////////// int dx; // data allocation index

// enter object(constant, variable or procedre) into table. void enter(int kind) {

mask* mk;

tx++;

strcpy(table[tx].name, id); table[tx].kind = kind; switch (kind) {

case ID_CONSTANT:

if (num > MAXADDRESS) {

error(25); // The number is too great. num = 0; }

table[tx].value = num; break;

case ID_VARIABLE:

mk = (mask*) &table[tx]; mk->level = level; mk->address = dx++; break;

case ID_PROCEDURE:

mk = (mask*) &table[tx]; mk->level = level; break; } // switch } // enter

////////////////////////////////////////////////////////////////////// // locates identifier in symbol table. int position(char* id)

34

{

int i;

strcpy(table[0].name, id); i = tx + 1;

while (strcmp(table[--i].name, id) != 0); return i; } // position

////////////////////////////////////////////////////////////////////// void constdeclaration() {

if (sym == SYM_IDENTIFIER) {

getsym();

if (sym == SYM_EQU || sym == SYM_BECOMES) {

if (sym == SYM_BECOMES)

error(1); // Found ':=' when expecting '='. getsym();

if (sym == SYM_NUMBER) {

enter(ID_CONSTANT); getsym(); } else {

error(2); // There must be a number to follow '='. } } else {

error(3); // There must be an '=' to follow the identifier. } }

error(4); // There must be an identifier to follow 'const', 'var', 'procedure'.

} // constdeclaration

////////////////////////////////////////////////////////////////////// void vardeclaration(void) {

if (sym == SYM_IDENTIFIER) {

enter(ID_VARIABLE);

35

or getsym(); } else {

error(4); // There must be an identifier to follow 'const', 'var', or 'procedure'. }

} // vardeclaration

////////////////////////////////////////////////////////////////////// void listcode(int from, int to) {

int i;

printf(\

for (i = from; i < to; i++) {

printf(\%s\\t%d\\t%d\\n\i, mnemonic[code[i].f], code[i].l, code[i].a); }

printf(\} // listcode

////////////////////////////////////////////////////////////////////// void factor(symset fsys) {

void expression(); int i;

symset set;

test(facbegsys, fsys, 24); // The symbol can not be as the beginning of an expression.

while (inset(sym, facbegsys)) {

if (sym == SYM_IDENTIFIER) {

if ((i = position(id)) == 0) {

error(11); // Undeclared identifier. } else {

switch (table[i].kind) {

36

mask* mk; case ID_CONSTANT:

gen(LIT, 0, table[i].value); break;

case ID_VARIABLE:

mk = (mask*) &table[i];

gen(LOD, level - mk->level, mk->address); break;

case ID_PROCEDURE: error(21); // Procedure identifier can not be in an expression. break; } // switch }

getsym(); }

else if (sym == SYM_NUMBER) {

if (num > MAXADDRESS) {

error(25); // The number is too great. num = 0; }

gen(LIT, 0, num); getsym(); }

else if (sym == SYM_LPAREN) {

getsym();

set = uniteset(createset(SYM_RPAREN, SYM_NULL), fsys); expression(set); destroyset(set);

if (sym == SYM_RPAREN) {

getsym(); } else {

error(22); // Missing ')'. } }

test(fsys, createset(SYM_LPAREN, SYM_NULL), 23); } // while } // factor

37

////////////////////////////////////////////////////////////////////// void term(symset fsys) {

int mulop; symset set;

set = uniteset(fsys, createset(SYM_TIMES, SYM_SLASH, SYM_NULL)); factor(set);

while (sym == SYM_TIMES || sym == SYM_SLASH) {

mulop = sym; getsym(); factor(set);

if (mulop == SYM_TIMES) {

gen(OPR, 0, OPR_MUL); } else {

gen(OPR, 0, OPR_DIV); }

} // while

destroyset(set); } // term

////////////////////////////////////////////////////////////////////// void expression(symset fsys) {

int addop; symset set;

set = uniteset(fsys, createset(SYM_PLUS, SYM_MINUS, SYM_NULL)); if (sym == SYM_PLUS || sym == SYM_MINUS) {

addop = sym; getsym(); term(set);

if (addop == SYM_MINUS) {

gen(OPR, 0, OPR_NEG); } } else {

38

term(set); }

while (sym == SYM_PLUS || sym == SYM_MINUS) {

addop = sym; getsym(); term(set);

if (addop == SYM_PLUS) {

gen(OPR, 0, OPR_ADD); } else {

gen(OPR, 0, OPR_MIN); }

} // while

destroyset(set); } // expression

////////////////////////////////////////////////////////////////////// void condition(symset fsys) {

int relop; symset set;

if (sym == SYM_ODD) {

getsym();

expression(fsys); gen(OPR, 0, 6); } else {

set = uniteset(relset, fsys); expression(set); destroyset(set);

if (! inset(sym, relset)) {

error(20); } else {

39

本文来源：https://www.bwwdw.com/article/pr17.html