简单C语言编译器(编译原理)

#include

#include

#include

#include

#include

#include

#include

#include

#define NULL 0

struct Stack // 栈结构体: 序号、内容、连接下一结点指针

{

int num;

char name;

struct Stack *next;

};

struct Guiyue// 规则集结构体:序号、规则长度、符号、连接下一结点指针

{

int num;

int count;

char name;

struct Guiyue *next;

};

struct Relation // 分析表结构体:状态序号、对应符号列、操作类型的对应序号、操作类型、连接下一结点指针

{

int line_States ;

char rank_Letter;

int relationship;

char name;

struct Relation *next;

};

struct Sign // 符号表结构体: 自变量名、标识类型、连接下一结点指针

{

char name[20];

char kind;

struct Sign *next;

};

struct Word // 单词表结构体: 单词名字、标识类型、状态、序号、行号、连接符号表指针、连接下一结点指针

{

char name[20];

char mark_name;

int state;

int num;

int line;

struct Sign *link;

struct Word *next;

};

FILE *fp1;//文件指针

int row=1,line[10000],Lin[300],w_num;//字符行变量、字符行、单词所在行、字符数char buffer[10000];//字符串缓冲区

Stack *MarkPush(Stack *ip,char mark,int I_i)//压栈

{

Stack *s;

s=(Stack *)malloc(sizeof(Stack));

s->name=mark;

s->num=I_i;

s->next=ip;

ip=s;

return ip;

}

void MarkPop(Stack *ip)//出栈

{

Stack *q;

char name;

name=ip->name;

q=ip->next;

if(ip->next!=NULL)

{

ip->name=ip->next->name;

ip->num=ip->next->num;

ip->next=ip->next->next;

free(q);

}

}

int judge(char ch)// 接收ch判断字符，变量flag返回字符类别

{

int flag;

if(ch=='!'||ch=='$'||ch=='&'||ch=='*'||ch=='('||ch==')'||ch=='-'||ch=='_'||

ch=='+'||ch=='='||ch=='|'||ch=='{'||ch=='}'||ch=='['||ch==']'||ch==';'||

ch==':'||ch=='"'||ch=='<'||ch==','||ch=='>'||ch=='.'||ch=='/'||ch=='\'')

flag=1;

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

flag=2;

else if(('a'<=ch&&ch<='z')||('A'<=ch&&ch<='Z'))

flag=3;

else if(ch==' ')

flag=4;

else if(ch=='\n')

flag=5;

else if(ch=='?')

flag=6;

else if(feof(fp1))

flag=7;//结束

else

flag=0; //illegal character

return(flag);

}

//===================================================================== =================================

// 词法分析函数: void scan()

// 数据传递: 形参fp接收指向文本文件头的文件指针；

// 全局变量buffer与line对应保存源文件字符及其行号，char_num保存字符总数。

void scan()

{

char ch;

int flag,j=0,i=-1;

while(!feof(fp1))

{

ch=fgetc(fp1);

flag=judge(ch);

printf("%c",ch);//显示打开的文件

if(flag==1||flag==2||flag==3) {i++;buffer[i]=ch;line[i]=row;}

else if(flag==4) {i++;buffer[i]='?';line[i]=row;}

else if(flag==5) {i++;buffer[i]='~';row++;}

else if(flag==7) continue;

else cout<<"\n请注意，第"<

}

w_num=i;

/*****************确定单词所在的行*****************/

int one,two,k=0;

for(i=0;i

one=judge(buffer[i]);

two=judge(buffer[i+1]);

if((one!=two&&buffer[i]!='?'&&buffer[i]!='~')||one==1){

Lin[k]=line[i];

k++;

}

}

}

//===================================================================== =================================

// 初始化单词表函数: struct Word *InitWord()

// 数据传递: head返回单词表的头指针

// 备注: 初始化单词表函数包括分割单词、标识单词、生成变量符号表、完善单词属性表四个功能

struct Word *InitWord(){

struct Word *head,*ft,*news,*p;

struct Sign *s_first,*s_look;

s_first=s_look=(struct Sign *)malloc(sizeof(struct Sign));

s_first->kind='\0';

s_first->name[0]='\0';

news=head=ft=(struct Word *)malloc(sizeof(struct Word));

ft->link=s_first;

ft->next=NULL;

//====================================分割单词功能========================================================== int i=0,k,flag,jud=0;

for(k=0;k

{

flag=judge(buffer[k]);

if(jud==0){//1~

if(flag==2||flag==3) {

news->name[i]=buffer[k];

news->name[++i]='\0';

}

else {//2~

i=0;

ft=news;

if(news->name[0]>=33&&news->name[0]<=125){

news=(struct Word *)malloc(sizeof(struct Word));

ft->next=news;

news->next=NULL;

}

if(flag==1){//3~

if(buffer[k]=='/'&&buffer[k+1]=='/') jud=1;

else if(buffer[k]=='/'&&buffer[k+1]=='*') jud=2;

else{//4~

news->name[i]=buffer[k];

if((buffer[k]=='='&&buffer[k+1]=='=')||(buffer[k]=='&'&&buffer[k+1]=='&')|| (buffer[k]=='|'&&buffer[k+1]=='|')||(buffer[k]=='>'&&buffer[k+1]=='=')||

(buffer[k]=='<'&&buffer[k+1]=='=')||(buffer[k]=='!'&&buffer[k+1]=='=')){

k=k+1;

i=i+1;

printf("%d",i);

news->name[i]=buffer[k];

}

news->name[1+i]='\0';

ft=news;

news=(struct Word *)malloc(sizeof(struct Word));

ft->next=news;

news->next=NULL;

}//4~

}//3~

}//2~

}//1~

else if(jud==1)

if(buffer[k]=='~') jud=0;

else ;

else if(jud==2)

if(buffer[k]=='*'&&buffer[k+1]=='/') { jud=0; k=k+1;}

else ;

}

if(news->name[0]<33||news->name[0]>125) ft->next=NULL;

/*******************单词转换成标识符*******************/

ft=head;

while(ft){

if(strcmp(ft->name,"main")==0){ft->mark_name='m';}

else if(strcmp(ft->name,"void")==0){ft->mark_name='v';}

else if(strcmp(ft->name,"while")==0){ft->mark_name='w';}

else if(strcmp(ft->name,"if")==0){ft->mark_name='f';}

else if(strcmp(ft->name,"else")==0){ft->mark_name='e';}

else if(strcmp(ft->name,"int")==0){ft->mark_name='a';}

else if(strcmp(ft->name,"float")==0){ft->mark_name='b';}

else if(strcmp(ft->name,"double")==0){ft->mark_name='d';}

else if(strcmp(ft->name,"char")==0){ft->mark_name='c';}

else if(ft->name[0]>='0'&&ft->name[0]<='9'){ft->mark_name='n';}

else if(ft->name[0]=='+'||ft->name[0]=='-'||ft->name[0]=='*'||ft->name[0]=='/' ||ft->name[0]=='='||ft->name[0]=='<'||ft->name[0]=='>'

||ft->name[0]==','||ft->name[0]==';'||ft->name[0]=='('||ft->name[0]==')'

||ft->name[0]=='{'||ft->name[0]=='}'){ft->mark_name=ft->name[0];} else if(strcmp(ft->name,"&&")==0){ft->mark_name='&';}

else if(strcmp(ft->name,"||")==0){ft->mark_name='|';}

else if(strcmp(ft->name,"!=")==0){ft->mark_name='@';}

else if(strcmp(ft->name,"==")==0){ft->mark_name='#';}

else {ft->mark_name='i';}

ft=ft->next;

}

/********************初始化单词表的序号和行号********************/

i=0;

ft=head;

while(ft){

ft->num=i;

ft->line=Lin[i];

i++;

ft=ft->next;

}

/*************************初始化符号表*************************/

ft=head;

char word_type;

while(ft){//1~

if(ft->mark_name=='a'||ft->mark_name=='b'||ft->mark_name=='c'||ft->mark_name=='d'){//2~ p=ft->next;

word_type=ft->mark_name;

while(p->mark_name!=';'){

if(p->mark_name!=','){

s_look=(struct Sign *)malloc(sizeof(struct Sign));

s_look->kind=word_type;

strcpy(s_look->name,p->name);

s_first->next=s_look;

s_first=s_look;

s_look->next=NULL;

}

p=p->next;

}

ft=p;

}//2~

ft=ft->next;

}//1~

return(head);

}

//===================================================================== ================================

//正确性检测函数: FindWordDeclare(Word *head)

// 数据传递: *head:单词表的头指针.

// 备注: 查找保留字是否被声名和符号是否对称.

void FindWordDeclare(Word *head){

struct Sign *s_first;

struct Word *find,*w_name[1000],*word_fu[100];

struct Stack *ip,*q;

int i,cal=0,ca=0,end;

find=head;

cout<

while(find){

if(find->mark_name=='i'){

w_name[cal]=find;

cal++;

}

if(find->next!=NULL){

if((find->mark_name==find->next->mark_name)&&(find->mark_name!='{')&& (find->mark_name!='}')&&(find->mark_name!='(')&&(find->mark_name!=')'))

cout<<"第"<line<<" 行，‘"<mark_name<<" ’存在字符重复错误!"<

else

if((find->mark_name=='i'&&find->next->mark_name=='}')||(find->mark_name==','&&find->next ->mark_name=='}')||

(find->mark_name==','&&find->next->mark_name==';')||(find->mark_name==';'&&find->next-> mark_name==',')||

(find->mark_name=='('&&find->next->mark_name==',')||(find->mark_name==','&&find->next-> mark_name=='(')||

(find->mark_name==')'&&find->next->mark_name==';')||(find->mark_name==')'&&find->next-> mark_name==',')||

(find->mark_name==')'&&find->next->mark_name=='}')){

cout<<"第"<line<<" 行，"<name<<" 处存在符号连接错误!"<

if((find->mark_name=='a'||find->mark_name=='b'||find->mark_name=='c'||find->mark_name=='d' )&&

(find->next->mark_name=='}'||find->next->mark_name=='{'||find->next->mark_name==','||

find->next->mark_name==';'||find->next->mark_name=='('||find->next->mark_name==')'||

find->next->mark_name=='+'||find->next->mark_name=='-'||find->next->mark_name=='*'||

find->next->mark_name=='/'||find->next->mark_name=='&'||find->next->mark_name=='>'||

find->next->mark_name=='<'||find->next->mark_name=='='||find->next->mark_name=='!'||

find->next->mark_name=='@'||find->next->mark_name=='n'))

cout<<"第"<line<<" 行，‘"<mark_name<<" ’存在自变量声明搭配错误!"<

}

}

if(find->mark_name=='('||find->mark_name==')'||find->mark_name=='{'||find->mark_name= ='}'){

word_fu[ca]=find;

ca++;

}

if(find->name[0]>='0'&&find->name[0]<='9'&&find->name[1]>='a'&&find->name[1]<='z') cout<<"第"<line<<" 行，"<name<<" 存在变量声明错误!"<

find=find->next;

}

int j=0;

for(i=0;i

s_first=head->link;

end=1;

while(s_first&&end){

if(strcmp(s_first->name,w_name[i]->name)==0) end=0;

else s_first=s_first->next;

}

if(end==1&&i!=cal-1) cout<<"错误! 第"<line<<" 行，变量"<name<<" 没有被声明!"<

}

q=ip=(struct Stack *)malloc(sizeof(struct Stack));

ip->name='$';

for(i=0;i

if((word_fu[i]->mark_name=='(')||(word_fu[i]->mark_name=='{'))

ip=MarkPush(ip,word_fu[i]->mark_name,i);

else

if((ip->name=='('&&word_fu[i]->mark_name==')')||(ip->name=='{'&&word_fu[i]->mark_name= ='}')) MarkPop(ip);

else cout<<"错误! 第"<line<<" 行，“"<name<<" ”存在符号匹配错误! "<

if(ip->name!='$') cout<<"错误! 第"<line<<" 行，“"<name<<" ”存在符号匹配错误!"<

cout<<"\n============================================================\n" <

}

//===================================================================== =================================

//初始化分析表函数: Relation *FirstRelation()

// 数据传递: r_head返回分析表的头指针

Relation *FirstRelation(){

Relation *r_head,*r_find,*r_new;

r_head=NULL;

//状态

int sr[][13]={{2,1},{100},{3},{4},{5},{6},{12,15,16,17,18,10,11,7,9,13,14,8},{19},

{12,4,15,16,17,18,10,11,20,9,13,14,8},{21},{22},{23},{24},{6},{26,25}, {8},{9},{10},{11},{1},{3},{12,15,16,17,18,10,11,28,14,27},{33,34,32,29,30,31},

{33,34,32,35,30,31},{42,41,43,36,37,38,39,40},{44,7},{13,13},{2,2,2,2,2,2,2,2},{5},

{47,46},{18,48,18},{20,20,20},{33,34,32,49,30,31},{27,27,51,52,54,53,27},

{50},{47,59},{60,83},{29,61,29,29},{31,31,62,31,31},{33,33,63,33,33,33,},

{35,35,35,35,35,35},{42,41,43,64,37,38,39,40},{37,37,37,37,37,37},

{38,38,38,38,38,38},{45},{12,12},{65},{33,34,32,66,31},{33,34,32,67},

{47,82},{26,26,26},{55},{56},{57},{58},{22,22,22},{23,23,23},{24,24,24},

{25,25,25},{68},{42,41,43,69,38,39,40},{42,41,43,70,39,40},{42,41,43,71,40},

{42,41,43,72},{60,73},{12,15,16,17,18,10,11,74,9,13,14,8},{17,48,17}, {19,19,19},{12,15,16,17,18,10,11,75,9,13,14,8},{28,61,28,28},{30,30,62,30,30},

{32,32,63,32,32,32},{34,34,34,34,34,34},{36,36,36,36,36,36},{77},{76},

{15,15,15,15,15,15,15,15},{78},{79},{12,15,16,17,18,10,11,80,9,13,14,8},

{81},{14,14,14,14,14,14,14,14},{21,21,21},{16,16,16,16,16,16,16,16}};

//以上状态对应的操作类别

char SS[][14]={"ss","o","s","s","s","s","ssssssssssss","s","srsssssssssss","s","s","s","s"

,"r","ss","r","r","r","r","r","r","ssssssssss","ssssss","ssssss","ssssssss","sr"

,"rr","rrrrrrrr","r","ss","rsr","rrr","ssssss","rrssssr","s","ss","ss","rsrr","rrsrr"

,"rrsrrr","rrrrrr","ssssssss","rrrrrr","rrrrrr","s","rr","s","sssss","ssss"

,"ss","rrr","s","s","s","s","rrr","rrr","rrr","rrr","s","sssssss","ssssss"

,"sssss","ssss","ss","ssssssssssss","rsr","rrr","ssssssssssss","rsrr","rrsrr"

,"rrsrrr","rrrrrr","rrrrrr","s","s","rrrrrrrr","s","s","ssssssssssss","s"

,"rrrrrrrr","rrr","rrrrrrrr"};

//状态的个数

int cal[84]={2,1,1,1,1,1,12,1,13,1,1,1,1,1,2,1,1,1,1,1,1,10,6,6,8,2,2,8,1,2,3,3,6,7,1,2,2,4,5,6,

6,8,6,6,1,2,1,5,4,2,3,1,1,1,1,3,3,3,3,1,7,6,5,4,2,12,3,3,12,4,5,6,6,6,1,1,8,1,1,12,1,8,3,8};

//以上状态在action和goto中对应的列

char Let[][14]={{'v','Q'},{'$'},{'m'},{'('},{')'},{'{'},{'i','a','b','c','d','f','w','A',

'C','X','Y','S'},{'}'},{'i','}','a','b','c','d','f','w','A','C','X','Y','S'},{';'},

{'('},{'('},{'='},{';'},{'i','Z'},{'i'},{'i'},{'i'},{'i'},{'$'},{'}'},{'i','a',

'b','c','d','f','w','X','Y','S'},{'i','!','(','E','H','G'},{'i','!','(','E','H','G'

},{'i','(','n','L','I','K','T','F'},{',',';'},{',',';'},{'i','}','a','b','c','d','f','w'},{';'},{'&',')'},

{'&','|',')'},{'&','|',')'},{'i','!','(','E','H','G'},{'&','|','<','>','@','#',

')'},{'i'},{'&',')'},{'+',';'},{'+','-',';',')'},{'+','-','/',';',')'},{'+','-',

'*','/',';',')'},{'+','-','*','/',';',')'},{'i','(','n','L','I','K','T','F'},

{'+','-','*','/',';',')'},{'+','-','*','/',';',')'},{'i'},{',',';'},{'{'},{'i',

'!','(','H','G'},{'i','!','(','G'},{'&',')'},{'&','|',')'},{'i'},{'i'},{'i'},

{'i'},{'&','|',')'},{'&','|',')'},{'&','|',')'},{'&','|',')'},{'{'},{'i','(',

'n','I','K','T','F'},{'i','(','n','K','T','F'},{'i','(','n','T','F'},{'i','(',

'n','F'},{'+',')'},{'i','a','b','c','d','f','w','A','C','X','Y','S'},{'&','|',

')'},{'&','|',')'},{'i','a','b','c','d','f','w','A','C','X','Y','S'},{'+','-',

';',')'},{'+','-','/',';',')'},{'+','-','*','/',';',')'},{'+','-','*','/',';',

')'},{'+','-','*','/',';',')'},{'}'},{'}'},{'i','}','a','b','c','d','f','w'},

{'e'},{'{'},{'i','a','b','c','d','f','w','A','C','X','Y','S'},{'}'},{'i','}',

'a','b','c','d','f','w'},{'&','|',')'},{'i','}','a','b','c','d','f','w','}'}};

//初始化关系表

for(int i=0;i<84;i++){

for(int j=0;j

r_new=(Relation *)malloc(sizeof(Relation));

if(r_head==NULL){

r_find=r_head=r_new;

}

r_new->line_States=i;

r_new->rank_Letter=Let[i][j];

r_new->relationship=sr[i][j];

r_new->name=SS[i][j];

r_find->next=r_new;

r_find=r_new;

r_new->next=NULL;

}

}

return r_head;

}

//===================================================================== =================================

//初始化规则表函数: Guiyue *guiyue()

// 数据传递: g_head返回规则表的头指针

Guiyue *FirstGuiyue(){

Guiyue *g_head,*g_find,*g_new;

g_head=NULL;

//规约

char root[]={'B','Q','S','A','A','C','C','X','Y','Y','Y','Y','Z','Z','S','S','S','E','E','H',

'H','G','G','G','G','G','G','G','L','L','I','I','K','K','T','T','F','F','F'};

int LR[]={1,7,3,2,1,3,1,2,1,1,1,1,3,1,11,7,4,3,1,3,1,3,3,3,3,3,2,1,3,1,3,1,3,1,3,1,3,1,1};

//初始化规则表

for(int i=0;i<39;i++){

g_new=(Guiyue *)malloc(sizeof(Guiyue));

if(g_head==NULL){

g_find=g_head=g_new;

}

g_new->num=i;

g_new->count=LR[i];

g_new->name=root[i];

g_find->next=g_new;

g_find=g_new;

g_new->next=NULL;

}

return g_head;

}

//=====================================================================

=================================

//语法分析函数: int ResultAnely(Relation *r_head,Stack *s_head,char str[],Guiyue *g_head,int cal)

// 数据传递: 1 *r_head:分析表头指针.

// 2 *s_head:符号栈头指针.

// 3 str[] ：转义字符流.

// 4 *g_head：规则表头指针.

// 5 cal ：转义字符流的长度.

int ResultAnely(Relation *r_head,Stack *s_head,char str[],Guiyue *g_head,int cal){ Relation *r_find;

Guiyue *g_find;

Stack *s_find,*s_look;

s_find=s_head;

int j,v,admition=1,goon=1,in,out=1,hang=-1,count;

char stack[200],name;

// cout<<"\n===================显--示--语--法--分--析--过--程--及--结--果==================="<

// cout<<" LineNum StackData inputSentence\n"<

while(goon){//:1

int admit=1;

r_find=r_head;

g_find=g_head;

hang++;

while(r_find&&admit){//:2

if(r_find->line_States==s_find->num&&r_find->rank_Letter==str[0]&&r_find->name=='s') {//:入栈

s_find=MarkPush(s_find,str[0],r_find->relationship);

admit=0;

for(in=0;in

str[in]='\0';

cal--;

r_find=r_find->next;

}//:入栈~

if(r_find->line_States==s_find->num&&r_find->rank_Letter==str[0]&&r_find->name=='r'){ //:规约

g_find=g_head;

int g=r_find->relationship;

while(g) {g_find=g_find->next;g--; }

name=g_find->name;

count=g_find->count;

admit=0;

for(int k=0;k

MarkPop(s_find);

}

r_find=r_head;

int a=1;

while(r_find&&a){

if(r_find->line_States==s_find->num && r_find->rank_Letter==name){

s_find=MarkPush(s_find,name,r_find->relationship);

a=0;

}

r_find=r_find->next;

}

}//:规约~

if(r_find->line_States==s_find->num&&r_find->rank_Letter==str[0]&&r_find->name=='o') {//:2判断运算结束

admit=0;

goon=0;

out=0;

cout<<"\nSuccession !"<

return(1);

}

r_find=r_find->next;

}//:2~

/* if(out==1)//显示语法分析结果

{

s_look=s_find;

v=0;

while(s_look)

{

stack[v]=s_look->name;

s_look=s_look->next;

v++;

}

cout<

for(j=v-1;j>=0;j--)

{

cout<

if(stack[j]=='i'){v++;}

}

for(j=0;j<10-v;j++){cout<<" ";}

cout<<" "<

cout<

}*/

if(admit==1){ //判断输入流是否正确，如在分析表中找不到关系，则输入流错误goon=0;

cout<<"\nInput Flow Error !"<

return(0);

}

}//1:~

cout<<"\n****************************************\n"<

}

//===================================================================== =================================

// 算术表达式四元式函数: void ProduceStyle(char str[],int order_num)

// 数据传递：1.str[] ：转义字符流.

// 2 order_num ：表达式所在行.

void ProduceStyle(char str[],int order_num){

struct FourStyle{

char Word,Opr1,Opr2,Result;

int num;

struct FourStyle *next;

};

struct Stack *stack_a,*stack_b;

char temp;

struct FourStyle *f_head,*f_find,*f_new;

stack_a=(struct Stack *)malloc(sizeof(struct Stack));

stack_a->name='$';

stack_a->next=NULL;

stack_b=(struct Stack *)malloc(sizeof(struct Stack));

stack_b->name='#';

stack_b->next=NULL;

f_head=NULL;

int admit,cal,four;

four=1;// 四元式序号

cal=0;

admit=1;

while(admit){

if(str[cal]=='='){

stack_a=MarkPush(stack_a,str[cal],cal);

cal++;

}

else

if(stack_b->name=='#'||stack_b->name=='+'||stack_b->name=='-'||stack_b->name=='*'||stack_b->n ame=='/')

{

if((str[cal]>='a')&&(str[cal]<='z')||(str[cal]>='0')&&(str[cal]<='9')){

stack_a=MarkPush(stack_a,str[cal],cal);

cal++;

}

else if(str[cal]=='('){

stack_b=MarkPush(stack_b,'#',cal);

cal++;

}

else

if((stack_b->name=='#')&&(str[cal]=='+'||str[cal]=='-'||str[cal]=='*'||str[cal]=='/')){

stack_b=MarkPush(stack_b,str[cal],cal);

cal++;

}

else if((stack_b->name=='#')&&(str[cal]==')')){

MarkPop(stack_b);

cal++;

}

else if((stack_b->name=='#')&&(str[cal]==';')){

admit=0;

}

else

if(stack_b->name=='+'||stack_b->name=='-'||stack_b->name=='*'||stack_b->name=='/'){

if((stack_b->name=='+'||stack_b->name=='-')&&(str[cal]=='*'||str[cal]=='/')){

stack_b=MarkPush(stack_b,str[cal],cal);

cal++;

}

else{

if(f_head==NULL){

f_new=(struct FourStyle *)malloc(sizeof(struct FourStyle));

f_find=f_new;

f_head=f_find;

}

else{

f_new=(struct FourStyle *)malloc(sizeof(struct FourStyle));

f_find->next=f_new;

f_find=f_new;

f_new->next=NULL;

}

f_new->num=order_num;

f_new->Word=stack_b->name;

MarkPop(stack_b);

f_new->Opr2=stack_a->name;

MarkPop(stack_a);

f_new->Opr1=stack_a->name;

MarkPop(stack_a);

temp=four+65;

f_new->Result=temp;

stack_a=MarkPush(stack_a,f_new->Result,cal);

four++;

}

}

}

if(cal!=3&&admit==0&&str[cal]==';'){

f_new=(struct FourStyle *)malloc(sizeof(struct FourStyle));

f_new->num=order_num;

f_new->Opr1=stack_a->name;

MarkPop(stack_a);

f_new->Word=stack_a->name;

MarkPop(stack_a);

f_new->Opr2='_';

f_new->Result=stack_a->name;

MarkPop(stack_a);

f_find->next=f_new;

f_find=f_new;

f_new->next=NULL;

four++;

}

else if(cal==3&&admit==0&&str[cal]==';'){

f_new=(struct FourStyle *)malloc(sizeof(struct FourStyle));

f_new->num=order_num;

f_new->Opr1=stack_a->name;

MarkPop(stack_a);

f_new->Word=stack_a->name;

MarkPop(stack_a);

f_new->Opr2='_';

f_new->Result=stack_a->name;

f_head=f_new;

f_new->next=NULL;

four++;

}

}

f_find=f_head;

while(f_find){

/*cout.width(20);*/cout<num<<" "<Word<<" "<Opr1<<" "<Opr2<<" "<Result<

f_find=f_find->next;

}

}

//===================================================================== =================================

// 布尔表达式四元式函数: void BoolStyle(char str[],int order_num)

// 数据传递：1.str[] ：转义字符流.

// 2 order_num ：表达式所在行.

void BoolStyle(char str[],int order_num){

struct FourStyle{

char Word,Opr1,Opr2;

int Order,num;

struct FourStyle *next;

};

struct FourStyle *b_head,*b_find,*b_new,*p[100];

b_head=NULL;

int cal,admit,i=0;

admit=1;

cal=0;

while(admit){

if(str[cal]!='|'&&str[cal]!='&'){

if(b_head==NULL){

b_find=b_new=(struct FourStyle *)malloc(sizeof(struct FourStyle));

b_head=b_find;

p[i]=b_find;

i++;

}

else{

b_new=(struct FourStyle *)malloc(sizeof(struct FourStyle));

p[i]=b_new;i++;

b_find->next=b_new;

b_find=b_new;

b_new->next=NULL;

}

b_new->Opr1=str[cal];cal++;

b_new->Word=str[cal];cal++;

b_new->Opr2=str[cal];cal++;

b_new->num=order_num;

b_new->Order=0;

b_new=(struct FourStyle *)malloc(sizeof(struct FourStyle));

p[i]=b_new;i++;

b_new->Opr1='_';

b_new->Word='j';

b_new->Opr2='_';

b_new->num=order_num;

b_new->Order=0;

b_find->next=b_new;

b_find=b_new;

b_new->next=NULL;

}

else if(str[cal]=='|'){

p[i-1]->Order=p[i-1]->num+1;

cal++;

}

else if(str[cal]=='&'){

p[i-2]->Order=p[i-2]->num+2;

cal++;

}

if(str[cal]=='$'){

admit=0;

p[0]->Order=order_num;

p[i-2]->Order=p[i-2]->num+2;

if(str[cal-4]=='&'){

p[i-1]->Order=p[i-3]->num;

}

}

}

b_find=b_head;

while(b_find){

cout<num<<" "<Word<<" "<Opr1<<" "<Opr2<<" "<Order<

b_find=b_find->next;

}

}

//===================================================================== =================================

// 显示四元式函数: FourStyle(int goon,Word *head)

// 数据传递：1.goon ：语法分析成功标志

// 2 head ：单词表头指针.

void FourStyle(int goon,Word *head){

Word *find;

find=head;

int jishu=0,order_num=1;

char str1[20];

cout<

while(goon){

if(find->next->mark_name=='='){

order_num=find->line;

jishu=0;

while(find->mark_name!=';'){

str1[jishu]=find->name[0];

jishu++;

find=find->next;

}

str1[jishu]=';';

str1[jishu+1]='\0';

ProduceStyle(str1,order_num);

}

else if(find->mark_name=='f'||find->mark_name=='w'){ jishu=0;

find=find->next->next;

order_num=find->line;

while(find->next->mark_name!='{'){

str1[jishu]=find->name[0];

jishu++;

find=find->next;

}

str1[jishu]='$';

str1[jishu+1]='\0';

BoolStyle(str1,order_num);

}

else if(find->mark_name=='e'){

find=find->next->next;

order_num=find->line;

if(find->next->mark_name=='='){

jishu=0;

while(find->mark_name!=';'){

str1[jishu]=find->name[0];

jishu++;

find=find->next;

}

str1[jishu]=';';

str1[jishu+1]='\0';

ProduceStyle(str1,order_num);

}

else if(find->mark_name=='f'||find->mark_name=='w'){ order_num=find->line;

jishu=0;

find=find->next->next;

while(find->next->mark_name!='{'){

str1[jishu]=find->name[0];

jishu++;

find=find->next;

}

str1[jishu]='$';

str1[jishu+1]='\0';

BoolStyle(str1,order_num);

}

}

find=find->next;

if(find->next==NULL){goon=0;}

}

cout<

}

//===================================================================== =================================

// 打印表格函数: Print(int t,Word *head,FILE *fp,Relation *r_head)

// 数据传递：1.t ：打印表格类别标志

// 2 head ：单词表头指针.

// 3 fp ：规则表文件指针.

// 4 r_head：分析表头指针.

void Print(int t,Word *head,FILE *fp,Relation *r_head){

struct Word *w_look;

struct Sign *s_look;

struct Relation *r_new;

int i=0;

switch(t){

case 1:

{ cout<

w_look=head;

while(w_look){

if(i==30) {cout<<" "<mark_name<

else {cout<<" "<mark_name;i++;}

w_look=w_look->next;

}

break;

}

case 2:

{

cout<

w_look=head;

cout<<"WordNumber WordLine WordName