编译原理课程实验指导书-PL0语言及其编译器

《编译原理》课程实验指导书

（Compiler Principle）

目录

序言................................................................................................................................ 1

一、实验安排 ............................................................................................................... 2

第一阶段：编译器的词法分析 ................................................................................ 2

第二阶段：编译器的语法分析 ................................................................................ 2

第三阶段：编译器的代码生成 ................................................................................ 3

二、考核方式及评定标准 ........................................................................................... 4

三、参考资料与编译器分析 ....................................................................................... 4

第一部分

PL语言及其编译器 ................................................................................. 4

1. PL语言介绍 ...................................................................................................... 4

1.1 PL语言的语法图 ..................................................................................... 5

2. PL语言编译器 .................................................................................................. 8

2.1 词法分析 ................................................................................................. 9

2.2 语法分析.................................................................................................. 9

2.3 语义分析................................................................................................ 11

2.4 代码生成................................................................................................ 11

2.5 代码执行................................................................................................ 13

2.6 错误诊断处理........................................................................................ 15

2.7 符号表管理............................................................................................ 17

2.8 其他 ....................................................................................................... 18

第二部分

上机实验要求 ........................................................................................ 19

第三部分

PL语言编译器源程序与示例 ............................................................... 21

1．示例与结果表示 ........................................................................................... 21

1.1 PL语言源程序 ...................................................................................... 21

1.2 生成的代码（片段） .......................................................................... 28

2.

PL语言编译器源程序 ..................................................................................... 28

1

序言

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

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

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

具体操作时分成三个阶段：词法分析、语法分析及代码生成。最后再统一组装成一个完整的PL编译器，并适当进行改进、补充。

1

一、实验安排

第一阶段：编译器的词法分析

学时：2

（一）、实验目的：通过阅读PL的语法图，设计、编制并调试一个PL词法分析程序，加深对词法分析原理的理解。

（二）、实验内容：

PL的词法分析器将要完成以下工作：

（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） 产生一份程序列表，输出相应行号或指令计数器的值。

第二阶段：编译器的语法分析

学时：4

（一）、实验目的：掌握PL语言编译器的语法分析程序设计与LL（1）文法应用的实现方法。

（二）、实验内容：

采用递归下降的方法来设计PL/0编译器，证明PL/0语言属于LL（1）文法。然后结合语法图编写（递归下降）语法分析程序的一般方法，具体方面有：

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

（2） 将每一个图按下面的规则（3）-（7）翻译成一个过程说明；

（3） 顺序图对应复合语句：

（4） 选择：

（5） 循环

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

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

相关过程有：

block(), constdeclaration(), vardeclaration(), statement(), condition(),

expression(), term(), factor()等。

并画出它们之间依赖关系图，并在此基础上实现程序的编制。

并适当进行语义分析的相关检查：

2

（1） 是否存在标识符先引用未声明的情况；

（2） 是否存在己声明的标识符的错误引用；

（3） 是否存在一般标识符的多重声明。

第三阶段：编译器的代码生成

学时：2

（一）、实验目的：掌握PL语言编译器的中间代码生成的程序分析与实现方法，并能对错误进行分析与处理。

（二）、实验内容：

为了使我们的编译程序保持适当简单的水平，不致陷入与本课程无关的实际机器的特有性质的考虑中去，我们假想有台适合PL程序运行的计算机，我们称之为PL处理机。PL处理机顺序解释生成的目标代码。

PL处理机的指令集根据PL语言的要求而设计，它包括以下的指令：

（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

———

———

层次差

层次差

层次差

———

———

———

表1 PL 处理机指令

a

常 量

常 量

数据地址

数据地址

程序地址

程序地址

程序地址

运算类别

PL的编译程序为每一条PL源程序的可执行语句生成后缀式目标代码。

另一方面，发现错误，并给出合适的诊断信息且继续编译下去从而发现更多的错误，对于编译程序而言是完全必要的。结合关键字规则、镇定规则，采用策略：先用一些明显的关键符号给它赋初值，然后随着分析子目标的层次深入，逐步补充别的合法符号。并编写子程序去验证之。

3

二、考核方式及评定标准

上机实验要求对PL语言及其编译器进行实现及扩充、修改。每个扩充或修改方式可得到不同的分数，满分为100分。

完成上机作业后，必须提交下列文档：

（1） 修改后的PL语言文本。包含词法分析（正规式），语法分析（BNF）。

（2） 有关修改后的PL编译/解释器的说明。详细说明编译器是如何编译新的PL语言程序的。指出程序中最精彩的部分，以及为什么这样做，如何控制和恢复语义错误的。

（3） 给出改动后的编译器源程序清单，并标记出所修改的部分。比较你的编译器和原来的编译器之间的差别。

（4） 说明你的编译器中可能存在的错误。

（5） 总结经验与教训，如果重做一遍，会有哪些新的改进？

对现存的PL编译程序做如下修改或扩充，其中（1）、（2）、（11）和（12）必须完成，剩余的均可任意选择，但总分必须超过40分。

（1） 注释（5分）

（2） 布尔类型的数据（10分）

（3） 布尔表达式的短路计算（5分）

（4） 数组（10分）为了便于解释执行，可能要增加新的PL机器操作指令。

（5） 参数（10分） 语法同Pascal（不用var声明）。

（6） 函数（10分）语法同Pascal。

（7） else子句和repeat语句（5分）

（8） for语句，语法参照Pascal或C语言（5分）

（9） exit语句和break语句（5分）

（10）记录（结构）,语法同Pascal语言（10分）。

（11）更有力的语法错误恢复机制（20分）

（12）分离解释和编译器（5分）

三、参考资料与编译器分析

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

1. PL语言介绍

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

4

1.1

PL语言的语法图

程序

程序体

语句序列

程序体

.

const

,

;

var

,

ident

=

number

ident

;

procedure ident

;

;

程序体

语句

语句

;

5

语句

条件

表达式

项

ident

:=

表达式

call ident

begin

语句序列

end

if

条件

then

语句

while

条件

do

语句

odd 表达式

表达式

= <> < > <= >=

表达式

+

项

- + -

项

6

因子

因子

* /

因子

ident

number

(

表达式

)

7

2. PL语言编译器

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

源程序

词法分析

语法分析

符号表管理语义分析

错误诊断处理

代码生成

代码执行

执行结果

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

8

2.1 词法分析

PL的语言的词法分析器将要完成以下工作：

(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编译器。以下我们给出该语言的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语言属于LL（1）文法。（证明从略。）

以下是我们给出如何结合语法图编写（递归下降）语法分析程序的一般方法。假定图S所对应的程序段为T（S），则：

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

(2) 将每一个图按下面的规则（3）-（7）翻译成一个过程说明；

(3) 顺序图对应复合语句：

S1 S2 Sn

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

(4)选择：

9

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：

10

程序

程序体

语句

条件

表达式

项

因子

图1-2 语法分析过程依赖关系

2.3

语义分析

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

(1) 是否存在标识符先引用未声明的情况；

(2) 是否存在己声明的标识符的错误引用；

(3) 是否存在一般标识符的多重声明。

2.4

代码生成

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

11

是PL机硬件，把解释执行看成是PL的硬件执行，那么我们所做的工作：由PL源语言程序到PL机器指令的变换，就是一个完整的编译程序。

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

PL处理机的指令集根据PL语言的要求而设计，它包括以下的指令：

（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

———

———

层次差

层次差

层次差

———

———

———

表2-1 PL 处理机指令

a

常 量

常 量

数据地址

数据地址

程序地址

程序地址

程序地址

运算类别

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

PL的编译程序为每一条PL源程序的可执行语句生成后缀式目标代码。这种代码生成方式对于表达式、赋值语句、过程调用等的翻译较简单。

如赋值语句X := Y op Z（op为某个运算符），将被翻译成下面的目标代码序列：（设指令计数从第100号开始）

No. f L a

100

101

102

103

而对if和while语句稍繁琐一点，因为此时要生成一些跳转指令，而跳转的目标地址大都是未知的。为解决这一问题，我们在PL编译程序中采用了回填技术，

12

LOD

LOD

OPR

STO

Level_diff_Y

Level_diff_Z

——————

Level_diff_X

Addr_Y

Addr_Z

op

Addr_X

即产生跳转目标地址不明确的指令时，先保留这些指令的地址（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处理机，它能够解释执行PL编译程序所生成的目标代码。这个PL处理机有两类存贮、一个指令寄存器和三个地址寄存器组成。程序（目标代码）存贮称为code，由编译程序装入，在目标代码执行过程中保持不变，因此它可被看成是“只读”存贮器。数据存贮S组织成为一个栈，所有的算术运算均对栈顶元和次栈顶元进行（一元运算仅作用于栈顶元），并用结果值代替原来的运算对象。栈顶元的地址（下标）记在栈顶寄存器T中，指令寄存器I包含着当前正在解释执行的指令，程序地址寄存器P指向下一条将取出的指令。

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

address）RA和动态链（dynamic link）DL。动态链的头，即最新分配的数据区的地址，保存在某地址寄存器B内。

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

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

13

又调用过程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的变量

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

step 1,

14

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编译程序制定了以下两条规则：

（1） 关键字规则；程序员在写程序时，可能会因为粗心而漏掉语句的分隔符——“;”，但他决不会漏掉算术运算符“+”，对于编译程序而言，不论是分隔符号类的符号还是关键字符号类的符号，它们都具有同等重要的地位。基于这样的特点，我们可以采用不易出错的部分来作为恢复正常步调的标记。每当遇到错误时，分析程序跳过后面的某些部分，直到出现所期望的符号为止。对于程序设计语言来说，这种符号（称为同步符号）的最好选择就是关键字。PL的每一种构造语句以begin、if或while开头；每种说明则以var、const或procedure开头。每遇到错误时，编译程序便可跳过一段程序，直到遇到这类符号为止，而继续编译。

（2） 镇定规则；自顶向下分析的特点在于目标对分成一些子目标，分程序则用别的分析程序来处理其子目标。镇定规则是说一个分析程序发现了错误，它不应该消极地停止前进，仅仅向调用它的程序报告发生的错误；

15

而应该自己继续向前扫描，找到似乎可以使正常的分析得以恢复的地方。这一规则在程序设计上的含义就是任一分析程序除了正常终止外，没有其它出口。

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

为了找到这个后继符号集合，我们给对应语法图的每一个分析过程提供一个显式参数，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);

}

}

我们前面提出的方案，具有这样的性质：试图通过略过输入正文中的一个或多个符号来恢复分析的正常步调。在错误仅为漏掉一个符号所引起的情况下，它都是不适宜的策略。经验表明，这类错误基本上限于那种仅有语法作用，而不代表动作的符号（如“;”）。把一些关键字加到后继符号集合中去可使分析程序不再盲目地跳过后面的符号，好象漏掉的已经补上去一样。下面程序段就是PL分析程序中复合语句分析的一小段。它的效果等于关键字前插入漏掉的分号。statbegsys集合是“语句”这个结构的首符号集。

if (sym == SYM_BEGIN)

{ getsym();

set1 = createset(SYM_SEMICOLON, SYM_END, SYM_NULL);

16

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 符号表管理

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

常数的值由程序正文提供，编译的任务就是确定存放该值的地址。我们选择顺序分配变量和代码的方法；每遇到一个变量说明，就将数据单元的下标加一（PL机中，每个变量占一个存贮单元）。开始编译一个过程时，要对数据单元的下标dx赋初值，表示新开辟一个数据区。dx的初值为3，因为每个数据区包含三个内部变量RA，DL和SL。

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

17

2.8 其他

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

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

（2） 解释程序作为PL编译程序的一个过程，若被编译的源代码没有错误，则编译结束时调用这个过程。

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

18

第二部分 上机实验具体要求

“编译原理”的上机实验要求对PL语言及其编译器进行实现、扩充和修改。每个扩充或修改方式可得到不同的分数，满分为100分。

完成上机作业后，必须提交下列文档：

(1) 修改后的PL语言文本。包含词法分析（正规式），语法分析（BNF）。

(2) 有关修改后的PL编译/解释器的说明。详细说明你的编译器是如何编译新的PL语言程序的。指出你的程序中最精彩的部分，以及你为什么这样做，你是如何控制和恢复语义错误的。

(3) 给出你所改动后的编译器源程序清单，并标记出你所修改的部分。比较你的编译器和原来的编译器之间的差别。

(4) 说明你的编译器中可能存在的错误。

(5) 总结经验与教训，如果重做一遍，你会有哪些新的改进？

对现存的PL编译程序可做如下修改或扩充，其中（1）、（2）、（11）和（12）必须完成，剩余的均可任意选择，但总分必须超过40分。

(1) 注释（5分）

注释由(*和*)包含，不允许嵌套。

(2) 布尔类型的数据（10分）

布尔类型的BNF为：

var_option → ε| var var_decl_list

var_decl_list → var_decl | var_decl_list var_decl

var_decl → ident_list : data_type

data_type → integer | boolean

这种修改包括：

（i） 区别整型与布尔型变量、常量和表达式。

（ii） 增加按严格计算的布尔类型运算符and、or和not。这些算符以及己有的运算符的优先级与Pascal语言相同。

（iii） 能够使用布尔常量true和false。

（iv） 把PL语言中的“条件”概念一般化为Pascal语言那样。

（v） 布尔表达式可以比较大小：false < true

(3) 布尔表达式的短路计算（5分）

增加布尔类型（见（2），除（2）的（ii）外），但对and和or采取短路计算。

(4)数组（10分）

增加由任何数据类型构造的一维数组。数组的下标限于纯量类型。

注意：数组可以由其它的数组来构造，因而必须考虑多维数组的情况。数组的上下界可为任意的纯量常数。

数组的定义如下：

data_type → integer | boolean | array [st] of

data_type

const → ident | number

19

语言中允许有数组说明，对数组元素赋值，在表达式中引用数组元素。为了便于解释执行，可能要增加新的PL机器操作指令。

(5) 参数（10分） 语法同Pascal，采用值-结果方式传递（不用var声明）。

(6) 函数（10分）语法同Pascal。

(7) else子句和repeat语句（5分）

(8) for语句，语法参照Pascal或C语言（5分）

(9) exit语句（退出当前执行过程）和break语句（跳出包含它的最内层循环），（5分）

(10) 记录（结构）,语法同Pascal语言（10分）。

(11) 更有力的语法错误恢复机制（20分）

(12) 分离解释和编译器（5分）

注意：上面的这些要求有时会互相影响：例如实现布尔类型数据，则数组和参数就应该能处理其相互组合的情况，如布尔型数组（包括多维数组）、布尔型作为下标的数组、布尔型作为参数传递。甚至能够实现数组作为参数传递等。

另外，为了实现以上功能，你可任意增加PL处理机的指令。但要注意指令的简单与合理。

选做题：此题不计入总分，仅做为学生在有余力的情况下的进一步练习。

实现PL语言的输入、输出语句。其语法、语义定义和Pascal语言相同。可以仅仅实现一次输入或输出一个值的语句——语句参数固定；也可以实现完全和Pascal语言一样，能够接受任意个数参数的输入或输出语句。

20

第三部分 PL语言编译器源程序与示例

1．示例与结果表示

1.1 PL语言源程序

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

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;

var f, g;

begin

21

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.

调试结果下：

22

23

24

25

26

27

1.2 生成的代码（片段）

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

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(b)

odd

if not(odd(b)) goto 20

if

+

z

2

*

a

z := z + a

while

a := 2 * a

2

b := b / 2

/

b

goto 9

return

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

2. PL语言编译器的参考程序

PL语言编译器的参考程序包括如下C程序文件：PL0.h、PL0.c、set.h和set.c。见打包程序(下发)。

28

Pl0c.c

#include

#include "pl0c.h"

#include "string.h"

/* 解释执行时使用的栈 */

#define stacksize 500

int main()

{

bool nxtlev[symnum];

init(); /* 初始化 */

fas=fopen("","w");

fa1=fopen("","w");

printf("Input file? ");

fprintf(fa1,"Input file? ");

scanf("%s",fname); /* 输入文件名 */

fin=fopen(fname,"r");

if(fin)

{

fprintf(fa1,"%sn",fname);

printf("List object code?(Y/N)"); /* 是否输出虚拟机代码 */

scanf("%s",fname);

listswitch=(fname[0]=='y'||fname[0]=='Y');

printf("List symbol table?(Y/N)"); /* 是否输出名字表 */

scanf("%s",fname);

tableswitch=(fname[0]=='y'||fname[0]=='Y');

err=0;

cc=cx=ll=0;

ch=' ';

kk=al-1;

if(-1!=getsym())

{

fa=fopen("","w");

fa2=fopen("","w");

addset(nxtlev,declbegsys,statbegsys,symnum);

nxtlev[period]=true;

if(-1==block(0,0,nxtlev)) /* 调用编译程序 */

{

fclose(fa);

fclose(fa1);

fclose(fin);

printf("n");

return 0;

}

29

fclose(fa);

fclose(fa1);

if(sym!=period)error(9);

if(err==0)interpret(); /* 调用解释执行程序 */

else

{

printf("Errors in pl/0 program");

}

}

fclose(fin);

}

else

{

printf("Can't open file!n");

fprintf(fa1,"Can't open file!n");

fclose(fa1);

}

fclose(fas);

printf("n");

return 0;

}

/* 在适当的位置显示错误 */

void error(int n)

{

char space[81];

memset(space,32,81);

space[cc-1]=0; /* 出错时当前符号已经读完，所以cc-1 */

printf("****%s!%dn",space,n);

fprintf(fa1,"****%s!%dn",space,n);

err++;

}

/* 词法分析，获取一个符号 */

int getsym()

{

int i,j,k;

while(ch==' '||ch==10||ch==9) /* 忽略空格、换行和TAB */

{

getchdo;

}

if(ch>='a'&&ch<='z')

30

{ /* 名字或保留字以a..z开头 */

k=0;

do

{

if(k

{

a[k]=ch;

k++;

}

getchdo;

}

while(ch>='a'&&ch<='z'||ch>='0'&&ch<='9');

a[k]=0;

strcpy(id,a);

i=0;

j=norw-1;

do /* 搜索当前符号是否为保留字 */

{

k=(i+j)/2;

if(strcmp(id,word[k])<=0)j=k-1;

if(strcmp(id,word[k])>=0)i=k+1;

}

while(i<=j);

if(i-1>j)sym=wsym[k]; else sym=ident; /* 搜索失败则，是名字或数字 */

}

else

{

if(ch>='0'&&ch<='9')

{ /* 检测是否为数字：以0..9开头 */

k=0;

num=0;

sym=number;

do

{

num=10*num+ch-'0';

k++;

getchdo;

}

while(ch>='0'&&ch<='9'); /* 获取数字的值 */

k--;

if(k>nmax)error(30);

}

else

{

if(ch==':') /* 检测赋值符号 */

{

31

getchdo;

if(ch=='=')

{

sym=becomes;

getchdo;

}

else

{

sym=nul; /* 不能识别的符号 */

}

}

else

{

if(ch=='<') /* 检测小于或小于等于符号 */

{

getchdo;

if(ch=='=')

{

sym=leq;

getchdo;

}

else

{

sym=lss;

}

}

else

{

if(ch=='>') /* 检测大于或大于等于符号 */

{

getchdo;

if(ch=='=')

{

sym=geq;

getchdo;

}

else

{

sym=gtr;

}

}

else

{

sym=ssym[ch]; /* 当符号不满足上述条件时，全部按照单字符符号处理 */

getchdo;

32

}

}

}

}

}

return 0;

}

/* 生成虚拟机代码 */

int gen(enum fct x, /* f */

int y, /* l */

int z /* a */

)

{

if(cx>cxmax)

{

printf("Program too long"); /* 程序过长 */

return -1;

}

code[cx].f=x;

code[cx].l=y;

code[cx].a=z;

cx++;

return 0;

}

/* 在某一部分（如一条语句，一个表达式）将要结束时时我们希望下一个符号属于某集合（该部分的后跟符号），test负责这项监测，并且负责当监测不通过时的补救措施，程序在需要检测时指定当前需要的符号集合和补救用的集合（如之前未完成部分的后跟符号），以及检测不通过时的错误号 */

int test(bool* s1, /* 我们需要的符号 */

bool* s2, /* 如果不是我们需要的，则需要一个补救用的集合 */

int n) /* 错误号 */

{

if(!inset(sym,s1))

{

error(n);

/* 当检测不通过时，不停获取符号，直到它属于需要的集合或补救的集合 */

while((!inset(sym,s1))&&(!inset(sym,s2)))

{

getsymdo;

}

}

return 0;

33

}

/* 编译程序主体 */

int block(int lev, /* 当前分程序所在层 */

int tx, /* 名字表当前尾指针 */

bool* fsys /* 当前模块后跟符号集合 */

)

{

int i;

int dx; /* 名字分配到的相对地址 */

int tx0; /* 保留初始tx */

int cx0; /* 保留初始cx */

bool nxtlev[symnum]; /* 在下级函数的参数中，符号集合均为值参，但由于使用数租实现，传递进来的是指针，为防止下级函数改变上级函数的集合，开辟新的空间传递给下级函数，之后所有的nxtlev都是这样 */

dx=3;

tx0=tx; /* 记录本层名字的初始位置 */

table[tx].adr=cx;

gendo(jmp,0,0);

if(lev>levmax)error(32);

do

{

if(sym==constsym) /* 收到常量声明符号，开始处理常量声明 */

{

getsymdo;

do

{

constdeclarationdo(&tx,lev,&dx); /* dx的值会被constdeclaration改变，使用指针 */

while(sym==comma)

{

getsymdo;

constdeclarationdo(&tx,lev,&dx);

}

if(sym==semicolon)

{

getsymdo;

}

else error(5);

}

while(sym==ident);

}

if(sym==varsym) /* 收到变量声明符号，开始处理变量声明 */

{

34

getsymdo;

do

{

vardeclarationdo(&tx,lev,&dx);

while(sym==comma)

{

getsymdo;

vardeclarationdo(&tx,lev,&dx);

}

if(sym==semicolon)

{

getsymdo;

}

else error(5);

}

while(sym==ident);

}

while(sym==procsym) /* 收到过程声明符号，开始处理过程声明 */

{

getsymdo;

if(sym==ident)

{

enter(procedur,&tx,lev,&dx); /* 记录过程名字 */

getsymdo;

}

else error(4); /* procedure后应为标识符 */

if(sym==semicolon)

{

getsymdo;

}

else error(5); /* 漏掉了分号 */

memcpy(nxtlev,fsys,sizeof(bool)*symnum);

nxtlev[semicolon]=true;

if(-1==block(lev+1,tx,nxtlev))return -1; /* 递归调用 */

if(sym==semicolon)

{

getsymdo;

memcpy(nxtlev,statbegsys,sizeof(bool)*symnum);

nxtlev[ident]=true;

nxtlev[procsym]=true;

testdo(nxtlev,fsys,6);

}

else error(5); /* 漏掉了分号 */

}

memcpy(nxtlev,statbegsys,sizeof(bool)*symnum);

nxtlev[ident]=true;

35

testdo(nxtlev,declbegsys,7);

}

while(inset(sym,declbegsys)); /* 直到没有声明符号 */

code[table[tx0].adr].a=cx; /* 开始生成当前过程代码 */

table[tx0].adr=cx; /* 当前过程代码地址 */

table[tx0].size=dx; /* 声明部分中每增加一条声明都会给dx增加1，声明部分已经结束，dx就是当前过程数据的size */

cx0=cx;

gendo(inte,0,dx); /* 生成分配内存代码 */

if(tableswitch) /* 输出名字表 */

{

printf("TABLE:n");

if(tx0+1>tx)printf(" NULLn");

for(i=tx0+1;i<=tx;i++)

{

switch(table[i].kind)

{

case constant:

printf(" %d const %s ",i,table[i].name);

printf("val=%dn",table[i].val);

fprintf(fas," %d const %s ",i,table[i].name);

fprintf(fas,"val=%dn",table[i].val);

break;

case variable:

printf(" %d var %s ",i,table[i].name);

printf("lev=%d addr=%dn",table[i].level,table[i].adr);

fprintf(fas," %d var %s ",i,table[i].name);

fprintf(fas,"lev=%d addr=%dn",table[i].level,table[i].adr);

break;

case procedur:

printf(" %d proc %s ",i,table[i].name);

printf("lev=%d addr=%d

size=%dn",table[i].level,table[i].adr,table[i].size);

fprintf(fas," %d proc %s ",i,table[i].name);

fprintf(fas,"lev=%d addr=%d

size=%dn",table[i].level,table[i].adr,table[i].size);

break;

}

}

printf("n");

}

/* 语句后跟符号为分号或end */

memcpy(nxtlev,fsys,sizeof(bool)*symnum); /* 每个后跟符号集和都包含上层后跟符号集和，以便补救 */

nxtlev[semicolon]=true;

36

nxtlev[endsym]=true;

statementdo(nxtlev,&tx,lev);

gendo(opr,0,0); /* 每个过程出口都要使用的释放数据段指令 */

memset(nxtlev,0,sizeof(bool)*symnum); /*分程序没有补救集合 */

testdo(fsys,nxtlev,8); /* 检测后跟符号正确性 */

listcode(cx0); /* 输出代码 */

return 0;

}

/* 解释程序 */

void interpret()

{

int p,b,t; /* 指令指针，指令基址，栈顶指针 */

struct instruction i; /* 存放当前指令 */

int s[stacksize]; /* 栈 */

printf("start pl0n");

t=0;b=0;p=0;

s[0]=s[1]=s[2]=0;

do

{

i=code[p]; /* 读当前指令 */

p++;

switch(i.f)

{

case lit: /* 将a的值取到栈顶 */

s[t]=i.a;

t++;

break;

case opr: /* 数学、逻辑运算 */

switch(i.a)

{

case 0:

t=b;

p=s[t+2];

b=s[t+1];

break;

case 1:

s[t-1]=-s[t-1];

break;

case 2:

t--;

s[t-1]=s[t-1]+s[t];

break;

case 3:

t--;

37

s[t-1]=s[t-1]-s[t];

break;

case 4:

t--;

s[t-1]=s[t-1]*s[t];

break;

case 5:

t--;

s[t-1]=s[t-1]/s[t];

break;

case 6:

s[t-1]=s[t-1]%2;

break;

case 8:

t--;

s[t-1]=s[t-1]==s[t];

break;

case 9:

t--;

s[t-1]=s[t-1]!=s[t];

break;

case 10:

t--;

s[t-1]=s[t-1]

break;

case 11:

t--;

s[t-1]=s[t-1]>=s[t];

break;

case 12:

t--;

s[t-1]=s[t-1]>s[t];

break;

case 13:

t--;

s[t-1]=s[t-1]<=s[t];

break;

case 14:

printf("%d",s[t-1]);

fprintf(fa2,"%d",s[t-1]);

t--;

break;

case 15:

printf("n");

fprintf(fa2,"n");

break;

38

case 16:

printf("?");

fprintf(fa2,"?");

scanf("%d",&(s[t]));

fprintf(fa2,"%dn",s[t]);

t++;

break;

}

break;

case lod:/*取相对当前过程的数据基地址为a的内存的值到栈顶 */

s[t]=s[base(i.l,s,b)+i.a];

t++;

break;

case sto: /*栈顶的值存到相对当前过程的数据基地址为a的内存 */

t--;

s[base(i.l,s,b)+i.a]=s[t];

break;

case cal: /* 调用子过程 */

s[t]=base(i.l,s,b); /* 将父过程基地址入栈 */

s[t+1]=b; /* 将本过程基地址入栈，此两项用于base函数 */

s[t+2]=p; /* 将当前指令指针入栈 */

b=t; /* 改变基地址指针值为新过程的基地址 */

p=i.a; /* 跳转 */

break;

case inte: /* 分配内存 */

t+=i.a;

break;

case jmp: /* 直接跳转 */

p=i.a;

break;

case jpc: /* 条件跳转 */

t--;

if(s[t]==0)p=i.a;

break;

}

}

while(p!=0);

fclose(fa2);

}

/* 初始化 */

void init()

{

int i;

39

/* 设置单字符符号 */

for(i=0;i<=255;i++)ssym[i]=nul;

ssym['+']=plus;

ssym['-']=minus;

ssym['*']=times;

ssym['/']=slash;

ssym['(']=lparen;

ssym[')']=rparen;

ssym['=']=eql;

ssym[',']=comma;

ssym['.']=period;

ssym['#']=neq;

ssym[';']=semicolon;

/* 设置保留字名字 */

strcpy(&(word[0][0]),"begin");

strcpy(&(word[1][0]),"call");

strcpy(&(word[2][0]),"const");

strcpy(&(word[3][0]),"do");

strcpy(&(word[4][0]),"end");

strcpy(&(word[5][0]),"if");

strcpy(&(word[6][0]),"odd");

strcpy(&(word[7][0]),"procedure");

strcpy(&(word[8][0]),"read");

strcpy(&(word[9][0]),"then");

strcpy(&(word[10][0]),"var");

strcpy(&(word[11][0]),"while");

strcpy(&(word[12][0]),"write");

/* 设置保留字符号 */

wsym[0]=beginsym;

wsym[1]=callsym;

wsym[2]=constsym;

wsym[3]=dosym;

wsym[4]=endsym;

wsym[5]=ifsym;

wsym[6]=oddsym;

wsym[7]=procsym;

wsym[8]=readsym;

wsym[9]=thensym;

wsym[10]=varsym;

wsym[11]=whilesym;

wsym[12]=writesym;

/* 设置指令名称 */

strcpy(&(mnemonic[lit][0]),"lit");

40

strcpy(&(mnemonic[opr][0]),"opr");

strcpy(&(mnemonic[lod][0]),"lod");

strcpy(&(mnemonic[sto][0]),"sto");

strcpy(&(mnemonic[cal][0]),"cal");

strcpy(&(mnemonic[inte][0]),"int");

strcpy(&(mnemonic[jmp][0]),"jmp");

strcpy(&(mnemonic[jpc][0]),"jpc");

/* 设置符号集 */

for(i=0;i

{

declbegsys[i]=false;

statbegsys[i]=false;

facbegsys[i]=false;

}

/* 设置声明开始符号集 */

declbegsys[constsym]=true;

declbegsys[varsym]=true;

declbegsys[procsym]=true;

/* 设置语句开始符号集 */

statbegsys[beginsym]=true;

statbegsys[callsym]=true;

statbegsys[ifsym]=true;

statbegsys[whilesym]=true;

/* 设置因子开始符号集 */

facbegsys[ident]=true;

facbegsys[number]=true;

facbegsys[lparen]=true;

}

/* 用数组实现集合的集合运算 */

int inset(int e,bool* s)

{

return s[e];

}

int addset(bool* sr,bool* s1,bool* s2,int n)

{

int i;

for(i=0;i

{

sr[i]=s1[i]||s2[i];

}

41

return 0;

}

int subset(bool* sr,bool* s1,bool* s2,int n)

{

int i;

for(i=0;i

{

sr[i]=s1[i]&&(!s2[i]);

}

return 0;

}

int mulset(bool* sr,bool* s1,bool* s2,int n)

{

int i;

for(i=0;i

{

sr[i]=s1[i]&&s2[i];

}

return 0;

}

/* 供getsym取一个字符，每次读一行，存入line缓冲区，line被getsym取空时 再读一行*/

int getch()

{

if(cc==ll)

{

if(feof(fin))

{

printf("program incomplete");

return -1;

}

ll=0;

cc=0;

printf("%d ",cx);

fprintf(fa1,"%d ",cx);

ch=' ';

while(ch!=10)

{

fscanf(fin,"%c",&ch);

printf("%c",ch);

fprintf(fa1,"%c",ch);

line[ll]=ch;

ll++;

42

}

printf("n");

fprintf(fa1,"n");

}

ch=line[cc];

cc++;

return 0;

}

/* 生成一项名字表 */

void enter(enum object k, /* 名字种类const,var or procedure */

int* ptx, /* 名字表尾指针的指针，为了可以改变名字表尾指针的值，以后所有的ptx都是这样 */

int lev, /* 名字所在的层次,，以后所有的lev都是这样 */

int* pdx /* dx为当前应分配的变量的相对地址，分配后要增加1，所以使用指针，以后所有的pdx都是这样 */

)

{

(*ptx)++;

strcpy(table[(*ptx)].name,id); /* 全局变量id中已存有当前名字的名字 */

table[(*ptx)].kind=k;

switch(k)

{

case constant: /* 常量名字 */

if(num>amax)

{

error(31); /* 数值越界 */

num=0;

}

table[(*ptx)].val=num;

break;

case variable: /* 变量名字 */

table[(*ptx)].level=lev;

table[(*ptx)].adr=(*pdx);

(*pdx)++;

break;

case procedur: /* 过程名字 */

table[(*ptx)].level=lev;

break;

}

}

/* 查找名字的位置 */

/* 找到则返回在名字表中的位置，否则返回0 */

43

int postion(char* idt, /* 要查找的名字 */

int tx /* 当前名字表尾指针 */

)

{

int i;

strcpy(table[0].name,idt);

i=tx;

while(strcmp(table[i].name,idt)!=0)i--;

return i;

}

/* 常量声明处理 */

int constdeclaration(int* ptx,

int lev,

int* pdx)

{

if(sym==ident)

{

getsymdo;

if(sym==eql||sym==becomes)

{

if(sym==becomes)error(1); /* 把=写成了:= */

getsymdo;

if(sym==number)

{

enter(constant,ptx,lev,pdx);

getsymdo;

}

else error(2); /* 常量说明=后应是数字 */

}

else error(3); /* 常量说明标识后应是= */

}

else error(4); /* const后应是标识 */

return 0;

}

/* 变量声明处理 */

int vardeclaration(int* ptx,int lev,int* pdx)

{

if(sym==ident)

{

enter(variable,ptx,lev,pdx); /* 填写名字表 */

getsymdo;

}

else error(4); /* var后应是标识 */

return 0;

44

}

/* 输出代码 */

void listcode(int cx0)

{

int i;

if(listswitch)

{

for(i=cx0;i

{

printf("%d %s %d %dn",i,mnemonic[code[i].f],code[i].l,code[i].a);

fprintf(fa,"%d %s %d %dn",i,mnemonic[code[i].f],code[i].l,code[i].a);

}

}

}

/* 语句处理 */

int statement(bool* fsys,int* ptx,int lev) /* 参数意义见block和enter函数 */

{

int i,cx1,cx2;

bool nxtlev[symnum]; /* 意义见block函数 */

if(sym==ident) /* 准备按照赋值语句处理 */

{

i=postion(id,*ptx);

if(i==0)error(11); /* 变量未找到 */

else

{

if(table[i].kind!=variable)

{

error(12); /* 赋值语句格式错误 */

i=0;

}

}

getsymdo;

if(sym==becomes)

{

getsymdo;

}

else error(13); /* 检测赋值符号 */

memcpy(nxtlev,fsys,sizeof(bool)*symnum);

expressiondo(nxtlev,ptx,lev); /* 处理赋值符号右侧表达式 */

if(i!=0)

{

45

gendo(sto,lev-table[i].level,table[i].adr); /* expression将执行一系列指令，但最终结果将会保存在栈顶，执行sto命令完成赋值 */

}

}

else

{

量 */

跟符号 */

if(sym==readsym) /* 准备按照read语句处理 */

{

getsymdo;

if(sym!=lparen)error(34); /* 格式错误，应是左括号 */

else

{

do

{

getsymdo;

if(sym==ident)i=postion(id,*ptx); /* 查找要读的变量 */

else i=0;

if(i==0)error(35); /* read()中应是声明过的变量名 */

else

{

gendo(opr,0,16); /* 生成输入指令，读取值到栈顶 */

gendo(sto,lev-table[i].level,table[i].adr); /* 储存到变 }

getsymdo;

}

while(sym==comma); /* 一条read语句可读多个变量 */

}

if(sym!=rparen)

{

error(33); /* 格式错误，应是右括号 */

while(!inset(sym,fsys)) /* 出错补救，直到收到上层函数的后 getsymdo;

}

else

{

getsymdo;

}

}

else

{

if(sym==writesym) /* 准备按照write语句处理，与read类似 */

{

getsymdo;

if(sym==lparen)

46

{

do

{

getsymdo;

memcpy(nxtlev,fsys,sizeof(bool)*symnum);

nxtlev[rparen]=true;

nxtlev[comma]=true; /* write的后跟符号为) or , */

expressiondo(nxtlev,ptx,lev); /* 调用表达式处理，此处与read不同，read为给变量赋值 */

gendo(opr,0,14); /* 生成输出指令，输出栈顶的值 */

}

while(sym==comma);

if(sym!=rparen)error(33); /* write()中应为完整表达式 */

else

{

getsymdo;

}

}

gendo(opr,0,15); /* 输出换行 */

}

else

{

if(sym==callsym) /* 准备按照call语句处理 */

{

getsymdo;

if(sym!=ident)error(14); /* call后应为标识符 */

else

{

i=postion(id,*ptx);

if(i==0)error(11); /* 过程未找到 */

else

{

if(table[i].kind==procedur)

{

gendo(cal,lev-table[i].level,table[i].adr); /*

生成call指令 */

}

else error(15); /* call后标识符应为过程 */

}

getsymdo;

}

}

else

{

if(sym==ifsym) /* 准备按照if语句处理 */

{

47