c递归向下语法分析Word文档下载推荐.docx

c递归向下语法分析Word文档下载推荐.docx

《c递归向下语法分析Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《c递归向下语法分析Word文档下载推荐.docx（20页珍藏版）》请在冰豆网上搜索。

#include"

2.h"

staticvoidmatch（Tokentypeexpected）

if（token==expected）////////////////////////

token=gettoken（）;

else

;

////////输出错误

intmain（）

chartemp[100]={'

\0'

};

printf（"

输入文件路径:

"

）;

scanf（"

%s"

temp）;

if（（fp=fopen（temp,"

rt"

））==NULL）

printf（"

文件名错误"

{

TreeNode*t=parse（）;

//t为所求

}

return0;

TreeNode*declaration_list（）

TreeNode*t=declaration（）;

TreeNode*p=t;

while（（token!

=ENDFILE）&

&

（token!

=ELSE））//条件还没有弄清楚

TreeNode*q;

q=declaration（）;

if（q!

=NULL）

{

if（t==NULL）

t=p=q;

else

{

p->

sibling=q;

///兄弟节点

p=q;

}

}

TreeNode*declaration（）

TreeNode*t=NULL;

if（token==INT||token==VOID）

{

RESERVED++;

//保存第一个token的信息

if（token==INT）//INT情况

pp=true;

match（INT）;

else//void情况

match（VOID）;

//保存第二个节点的信息

match（ID）;

switch（token）

caseFENHAO:

markvar=true;

t=var_declaration（）;

break;

caseLDAKUO:

caseLKUOHAO:

t=fun_declaration（）;

default:

printf（"

ERROR"

}

TreeNode*var_declaration（）

//胡乱定义的这是

if（markvar）

TreeNode*t=newDefineNode（var）;

TreeNode*p=newExpNode（idk）;

//////保存先前保留的ID中的内容

child[0]=p;

if（token==FENHAO）

match（FENHAO）;

elseif（token==LDAKUO）

match（LDAKUO）;

TreeNode*q=newExpNode（constk）;

//保存数字的值

match（NUM）;

match（RDAKUO）;

RESERVED=0;

TreeNode*fun_declaration（）

TreeNode*t=newDefineNode（fun）;

TreeNode*p=newExpNode（idk）;

match（LKUOHAO）;

child[0]=params（）;

match（RKUOHAO）;

child[1]=compound_stmt（）;

match（FENHAO）;

TreeNode*params（）

if（token==VOID）

t=newDefineNode（var）;

//把这个单个的void当做一个定义的节点定义

match（VOID）;

//是void的情况下t直接返回NULL

t=param_list（）;

TreeNode*param_list（）

TreeNode*t=param（）;

while（token==DOUHAO）

TreeNode*p=newExpNode（opk）;

if（p!

p->

child[0]=t;

attr.op=token;

t=p;

match（token）;

child[1]=param（）;

TreeNode*arglist（）

TreeNode*param（）//建立定义类型的节点

///变量定义的情况

if（token==INT）//IF的情况

t->

else

child[0]=newExpNode（idk）;

///是不是还要把字符给记录进去啊这个

if（token==LDAKUO）

match（LDAKUO）;

child[1]=newExpNode（constk）;

///////虽然括号里面是空的，但还是把它看做一个常量constk处理

child[1]->

match（RDAKUO）;

TreeNode*compound_stmt（）//参照repet_stmt编写代码

match（LHUAKUO）;

if（t!

t=local_declarations（）;

if（t!

sibling=statement_list（）;

else//在上一个节点确实存在的时候才把后一个节点保存在t->

child[0]中；

t=statement_list（）;

TreeNode*local_declarations（）

TreeNode*p1=NULL;

TreeNode*p2=NULL;

t=var_declaration（）;

p2=t;

while（token==INT||token==VOID）

p1=var_declaration（）;

p2->

sibling=p1;

p2=p1;

TreeNode*statement_list（）

if（token==FENHAO||token==ID||token==LHUAKUO||token==IF||token==WHILE||token==RETURN）

t=statement（）;

while（token==FENHAO||token==ID||token==LHUAKUO||token==IF||token==WHILE||token==RETURN）

p1=statement（）;

TreeNode*statement（）

switch（token）

caseFENHAO:

t=expression_stmt（）;

break;

caseID:

caseLHUAKUO:

t=compound_stmt（）;

caseIF:

t=selection_stmt（）;

caseWHILE:

t=iteration_stmt（）;

caseRETURN:

t=return_stmt（）;

TreeNode*expression_stmt（）///////没有建立节点不知道对不对

//FENHAO结束，没有操作

elseif（token==ID）

t=expression（）;

///出错处理

TreeNode*selection_stmt（）

TreeNode*t=newStmtNode（ifk）;

match（IF）;

child[0]=expression（）;

child[1]=statement（）;

if（token==ELSE）

match（ELSE）;

child[2]=statement（）;

TreeNode*iteration_stmt（）

TreeNode*t=newStmtNode（whilek）;

match（WHILE）;

TreeNode*return_stmt（）

TreeNode*t=newStmtNode（returnk）;

match（RETURN）;

TreeNode*expression（）

TreeNode*t=newStmtNode（assignk）;

////赋值表达式

TreeNode*p1,*p2;

booltemp=true;

////最开始那个循环的节点作为t的孩子节点，后面的节点全当做第一个孩子节点的兄弟节点处理

while（token=ID）

p1=Var（）;

//还需要把ID的内容写到相应的节点中

if（temp）

p2->

child[0]=p1;

match（EQ）;

temp=false;

p1=simple_expression（）;

p2->

TreeNode*Var（）

TreeNode*t=newExpNode（idk）;

////对应attr中的内容

TreeNode*p=NULL;

match（ID）;

//还需要吧ID的内容添加到相应的节点中

if（token==LDAKUO）

p=expression（）;

sibling=p;

//把expression当做兄弟节点看待

TreeNode*simple_expression（）

TreeNode*t=additive_expression（）;

TreeNode*p2=NULL;

if（token==LESS||token==LESSA||token==MORE||token==MOREA||token==EQ||token==UEQ）

p2=newExpNode（opk）;

if（p2!

child[1]=additive_expression（）;

t=p2;

TreeNode*additive_expression（）//完全参照书上的实现

TreeNode*t=term（）;

while（token==PLUS||token==MINUS）

child[1]=term（）;

TreeNode*term（）/////完全参照书上的实现

TreeNode*t=factor（）;

while（token==MULTI||token==DIV）//乘除问题

child[1]=factor（）;

TreeNode*factor（）////////////////////////////////参照书上的FACTOR实现

TreeNode*t=NULL;

caseNUM:

t=newExpNode（constk）;

if（（t!

=NULL）&

（token=NUM））

attr.val=atoi（tokenstring）;

//////////////////////tokenstring表示匹配token的内容推广

break;

caseLKUOHAO:

match（LKUOHAO）;

match（RKUOHAO）;

pp=true;

///////同时要在这里定义一个来保存

if（token==LKUOHAO）

t=call（）;

t=Var（）;

default:

///////////////出错处理

TreeNode*call（）

TreeNode*t=newStmtNode（whilek）;

///、、。

。

/胡乱写的whilek

///保存没有实现

sibling=args（）;

///把args当做函数调用节点的兄弟节点保存

TreeNode*args（）

if（token==ID||token==NUM||token==LKUOHAO）

t=arg_list（）;

TreeNode*arg_list（）

TreeNode*t=expression（）;

while（token==DOUHAO）/////////////////////////////////////逗号表达式

attr.op=DOUHAO;

match（DOUHAO）;

child[1]=expression（）;

TreeNode*parse（）

TreeNode*t;

token=gettoken（）;

t=declaration_list（）;

if（token!

=ENDFILE）

error"