西南交大编译原理课程设计词法分析器和语法分析器Word下载.docx

西南交大编译原理课程设计词法分析器和语法分析器Word下载.docx

《西南交大编译原理课程设计词法分析器和语法分析器Word下载.docx》由会员分享，可在线阅读，更多相关《西南交大编译原理课程设计词法分析器和语法分析器Word下载.docx（20页珍藏版）》请在冰豆网上搜索。

7.RETRACT把CHAR中字符回送到缓冲区

源程序：

#include"

stdio.h"

stdlib.h"

conio.h"

string.h"

#defineN47//保留字个数

charch='

\0'

;

//存放最新读进的源程序字符

charstrToken[20]="

\0"

//存放构成单词符号的字符串

charbuffer[257]="

//字符缓冲区

/*------------保留字结构-------------*/

structkeyType{

charkeyname[256];

intvalue;

}Key[N]={{"

$ID"

0},{"

$INT"

1},{"

auto"

2},{"

break"

3},{"

case"

4},

{"

char"

5},{"

const"

6},{"

continue"

7},{"

default"

8},{"

do"

9},

double"

10},{"

else"

11},{"

enum"

12},{"

extern"

13},{"

float"

14},

for"

15},{"

goto"

16},{"

if"

17},{"

int"

18},{"

long"

19},{"

register"

20},

return"

21},{"

short"

22},{"

signed"

23},{"

sizeof"

24},{"

static"

25},

struct"

26},{"

switch"

27},{"

typedef"

28},{"

union"

29},{"

unsigned"

30},

void"

31},{"

volatile"

32},{"

while"

33},{"

="

34},{"

+"

35},{"

-"

36},{"

*"

37},

/"

38},{"

%"

39},{"

"

40},{"

"

41},{"

（"

42},{"

）"

43},{"

?

44},{"

clear"

45},{"

#"

46}};

/*-------------子过程-------------*/

voidGetChar（）//读一个字符到ch中

{inti;

if（strlen（buffer）>

0）{

ch=buffer[0];

for（i=0;

i<

256;

i++）

buffer[i]=buffer[i+1];

}

else

ch='

}

voidGetBC（）//读一个非空白字符到ch中

while（strlen（buffer））{

i=0;

ch=buffer[i];

for（;

i++）buffer[i]=buffer[i+1];

if（ch!

='

'

&

ch!

\n'

）break;

voidConCat（）//把ch连接到strToken之后

{chartemp[2];

temp[0]=ch;

temp[1]='

strcat（strToken,temp）;

boolLetter（）//判断ch是否为字母

{if（ch>

A'

ch<

Z'

||ch>

a'

z'

）

returntrue;

returnfalse;

boolDigit（）//判断ch是否为数字

0'

9'

intReserve（）//用strToken中的字符查找保留字表，并返回保留字种别码，若返回0，则非保留字

for（i=0;

N;

if（strcmp（strToken,Key[i].keyname）==0）

returnKey[i].value;

return0;

voidRetract（）//把ch中的字符回送到缓冲区

if（ch!

）{

buffer[256]='

for（i=255;

i>

0;

i--）

buffer[i]=buffer[i-1];

buffer[0]=ch;

ch='

/*----------词法分析器------------*/

keyTypeReturnWord（）

{strcpy（strToken,"

）;

intc;

keyTypetempkey;

GetBC（）;

if（ch>

）{

ConCat（）;

GetChar（）;

while（Letter（）||Digit（））{

ConCat（）;

GetChar（）;

}

Retract（）;

c=Reserve（）;

strcpy（tempkey.keyname,strToken）;

if（c==0）

tempkey.value=0;

else

tempkey.value=Key[c].value;

elseif（ch>

）{

ConCat（）;

while（Digit（））{

tempkey.value=1;

else{

tempkey.value=Reserve（）;

returntempkey;

/*-------------主函数-------------*/

intmain（）{

keyTypetemp;

strcpy（buffer,"

if（a>

0）a=b+c;

printf（"

buffer:

\n%s\n\t\t单词\t种别号\n"

buffer）;

printf（"

按任意键提出一个词：

getch（）;

temp=ReturnWord（）;

%s\t%d\n\n"

temp.keyname,temp.value）;

theend!

\n"

七、测试

当输入字符“if（i>

0）a=b+c”，当缓冲区接受这串字符后，通过调用词法分析子程序，可有如下的显示结果：

八、结束语

通过对C语言词法分析器的设计和编写，更加了解了编译程序在编译过程中的效用。

同时，也更加了解了C语言的结构。

对于词法分析器这一章的理论知识也有了较深入的理解。

课程设计二：

手工设计简单的语法分析器

用算符优先分析方法设计一个分析解释程序，对输入的赋值语句、输出语句、清除语句进行词法分析、语法分析、表达式求值并存储于指定变量中；

若存在错误，提示错误相关信息。

了解掌握算符优先分析的基本方法、内容；

学会科学思考并解决问题，提高程序设计能力。

语法分析的任务:

把单词符号作为基本单位,分析程序是否为合法的程序.

算符优先分析法是自下而上的语法分析方法，即根据文法,对输入字串进行归约,若能正确地归约为文法的初始符号,则表示输入字串是合法的.

该试验主要研究对输入的赋值语句、输出语句、清除语句进行词法分析、语法分析、表达式求值并存储于指定变量中；

文法表示：

S→v=E|E?

|clear

E→E+T|E-T|T

T→T*F|T/F|F

F→（E）|v|c

单词种别码设计：

符号

种别码

=

1

？

2

+

3

-

4

*

5

/

6

（

7

8

v

9

c

10

clear

11

#

12

N

13

1.优先关系矩阵：

intpriority[NUM][NUM]

2.单词种别码结构：

structWordType

3.变量表中的元素结构：

structVarWord

4.变量表结构：

structVarTable

5.归约栈：

mainStack

6.单词串：

wordStack

7.输入串转化成单词串：

GetwordStack（）

8.从单词串中取单词：

GetWord（）

9.清空单词串和归约栈：

ClearwordStack（）、ClearmainStack（）

10.查看变量在变量表中的位置：

CheckvarTable（chara[]）

11.变量表添加变量：

AddvarTable（VarWorda）

12.初始化归约栈：

InitmainStack（）

13.归约栈添加：

AddmainStack（WordTypea）

14.归约处理程序：

Handle（）

15.归约子程序：

MainHandle（）

#defineNUM14

#defineM256

//优先关系矩阵

intpriority[NUM][NUM]={{0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,0,0},

{0,0,0,0,0,0,0,0,0,0,0,0,1,0},

{0,0,0,1,1,-1,-1,-1,1,-1,0,0,1,0},

{0,0,0,1,1,1,1,-1,1,-1,0,0,1,0},

{0,0,0,-1,-1,-1,-1,-1,2,-1,0,0,0,0},

{0,0,0,1,1,1,1,0,1,0,0,0,1,0},

{0,0,1,1,1,1,1,0,1,0,0,0,1,0},

{0,0,0,-1,-1,-1,-1,-1,0,0,0,0,3,0},

{0,0,1,0,0,0,0,0,0,0,0,0,1,0}};

/*--------单词，种别码---------*/

structWordType{

charword[M];

}wordType[NUM]={{"

error"

4},{"

$i"

9},{"

$c"

$N"

13}};

/*---------变量表-------------*/

structVarWord{

charvarname[M];

//变量名

charvalue[M];

//变量值

boolflag;

//变量是否赋值标志

};

structVarTable{

VarWordelem[M];

//变量数组

intlen;

//变量表的长度

}varTable;

/*----------单词栈-----------*/

structOperateStack{

WordTypeelem[M];

//单词元素

//栈的长度

OperateStackmainStack;

//归约栈

OperateStackwordStack;

//单词串

/*-------------------输入串转化成单词串---------------*/

boolGetwordStack（）{

inti;

wordStack.len=0;

//词法分析器获得一个分析词

if（temp.value==1）//常数（"

10）

{strcpy（wordStack.elem[wordStack.len].word,temp.keyname）;

wordStack.elem[wordStack.len].value=10;

elseif（temp.value==0）//变量（"

9）

wordStack.elem[wordStack.len].value=9;

else{

for（i=0;

NUM;

i++）{

if（strcmp（temp.keyname,wordType[i].word）==0）//关键字

{wordStack.elem[wordStack.len]=wordType[i];

break;

}

elseif（i==NUM-1）{

printf（"

输入串中出现未识别单词！

returnfalse;

}

wordStack.len++;

wordStack.elem[wordStack.len++]=wordType[12];

returntrue;

/*---------------------从单词串中取单词---------------*/

WordTypeGetWord（）{

WordTypetemp=wordStack.elem[0];

for（inti=0;

wordStack.len-1;

wordStack.elem[i]=wordStack.elem[i+1];

wordStack.len--;

returntemp;

/*---------------------清空栈-------------------------*/

voidClearwordStack（）//清空单词串

{wordStack.len=0;

voidClearmainStack（）//清空归约栈

{mainStack.len=0;

/*---------------查看变量在变量表中的位置-------------*/

intCheckvarTable（chara[]）{

M;

if（strcmp（a,varTable.elem[i].varname）==0）

returni;

elseif（i==M-1）

return-1;

/*-------------------添加变量-------------------------*/

voidAddvarTable（VarWorda）{

varTable.elem[varTable.len]=a;

varTable.len++;

/*-------------------初始化归约栈---------------------*/

voidInitmainStack（）

{mainStack.elem[0]=wordType[12];

mainStack.len=1;

/*-------------------添加归约栈-----------------------*/

voidAddmainStack（WordTypea）

{mainStack.elem[mainStack.len]=a;

mainStack.len++;

/*----------------------归约--------------------------*/

boolHandle（）

//常量归约

if（mainStack.elem[mainStack.len-1].value==10）{

mainStack.elem[mainStack.len-1].value=13;

//变量归约

elseif（mainStack.elem[mainStack.len-1].value==9）{

i=CheckvarTable（mainStack.elem[mainStack.len-1].word）;

if（i<

printf（"

\n变量%s未定义！

mainStack.elem[mainStack.len-1].word）;

returnfalse;

strcpy（mainStack.elem[mainStack.len-1].word,varTable.elem[i].value）;

//赋值归约

elseif（mainStack.elem[mainStack.len-2].value==1）{

if（mainStack.elem[mainStack.len-3].value==9）{

i=CheckvarTable（mainStack.elem[mainStack.len-3].word）;

if（i<

VarWordtemp;

strcpy（temp.varname,mainStack.elem[mainStack.len-3].word）;

strcpy（temp.value,mainStack.elem[mainStack.len-1].word）;

temp.flag=true;

AddvarTable（temp）;

else

strcpy（varTable.elem[i].value,mainStack.elem[mainStack.len-1].word）;

strcpy（mainStack.elem[mainStack.len-3].word,mainStack.elem[mainStack.len-1].word）;

mainStack.elem[mainStack.len-3].value=13;

elseif（mainStack.elem[mainStack.len-3].value==13）

mainStack.len=mainStack.len-2;

//运算归约

elseif（mainStack.elem[mainStack.len-2].value==3）{

inta,b;

a=atoi（mainStack.elem[mainStack.len-1].word）;

b=atoi（mainStack.elem[mainStack.len-3].word）;

a=a+b;

itoa（a,mainStack.elem[mainStack.len-3].word,10）;

elseif（mainStack.elem[mainStack.len-2].value==5）{

b=atoi（ma