正则表达式LL1分析算符优先LR分析.docx

资源描述

正则表达式LL1分析算符优先LR分析.docx

《正则表达式LL1分析算符优先LR分析.docx》由会员分享，可在线阅读，更多相关《正则表达式LL1分析算符优先LR分析.docx（22页珍藏版）》请在冰豆网上搜索。

正则表达式LL1分析算符优先LR分析.docx

正则表达式LL1分析算符优先LR分析

1正则表达式1

1.1正则表达式1

1.2确定化（化简）后的状态转换图1

1.3分析程序代码1

1.4程序运行截图1

1.5小结1

2LL

（1）分析2

2.1LL

（1）文法2

2.2LL

（1）预测分析表2

2.3分析程序代码2

2.4程序运行截图2

2.5小结2

3算符优先分析3

3.1算符优先文法3

3.2算符优先关系表3

3.3分析程序代码3

3.4程序运行截图3

3.5小结3

4LR分析4

4.1LR文法4

4.2LR分析表4

4.3分析程序代码4

4.4程序运行截图4

4.5小结4

参考文献：

1正则表达式

1.1正则表达式

（a|b）*（aa|bb）（a|b）*（注：

该正规式为示例，可更改）

1.2确定化（化简）后的状态转换图

1.3分析程序代码

#include

usingnamespacestd;

//定义一个存储状态转换的类

classStatu

{

public:

mapMAP;

};

intmain（）

{

//定义4个状态并初始化各个状态间的关系，以及定义一个存储当前状态的变量status

StatuA,B,C,D,*status;

A.MAP['a']=&B;

A.MAP['b']=&C;

B.MAP['a']=&D;

B.MAP['b']=&C;

C.MAP['a']=&B;

C.MAP['b']=&D;

D.MAP['a']=&D;

D.MAP['b']=&D;

while

（1）

{

string:

size_typesize=0;

stringstr;

boolflag=true;

cout<<"请输入符合（a|b）*（aa|bb）（a|b）*的正则表达式"<

cin>>str;

status=&A;//刚开始指向初始状态

constchar*ch=str.c_str（）;

while（ch[size]）

{

if（ch[size]!

='a'&&ch[size]!

='b'）

{

flag=false;

break;

}

status=status->MAP[ch[size++]];//根据输入字符串调整状态

}

if（status==&D&&flag）//若为终结状态则符合此正则表达式

cout<<"√正确"<

else

cout<<"×错误"<

}

return0;

}

1.4程序运行截图

1.5小结

通过定义各个状态，并生成各个状态间的关系可以方便地表示状态转换图，使用关联容器则可以方便的管理状态。

2LL

（1）分析

2.1LL

（1）文法

E→TE'（注：

该文法为示例，可更改）

E'→+TE'|ε

T→FT'

T'→*FT'|ε

F→（E）|i

2.2LL

（1）预测分析表

（

）

E→TE'

E'→+TE'

E'→ε

T→FT'

T'→ε

T'→*FT'

T'→ε

F→i

F→（E）

2.3分析程序代码

#include

usingnamespacestd;

enumSymbols

{

//终结符号Terminalsymbols：

TS_I,//i

TS_PLUS,//+

TS_MULTIPLY,//*

TS_L_PARENS,//（

TS_R_PARENS,//）

TS_EOS,//#,'\0'

TS_INVALID,//非法字符

//非终结符号Noneterminalsymbols：

NTS

NTS_E,//E

NTS_EE,//E'

NTS_T,//T

NTS_TT,//T'

NTS_F//F

};

enumSymbolslexer（charc）

{

switch（c）

{

case'i':

returnTS_I;

case'+':

returnTS_PLUS;

case'*':

returnTS_MULTIPLY;

case'（':

returnTS_L_PARENS;

case'）':

returnTS_R_PARENS;

case'#':

returnTS_EOS;//栈底：

#终结符号

default:

returnTS_INVALID;

}

intmain（）

{

while

（1）

{

cout<<"输入一个以#结束的字符串"<

constchar*p;

stringstr;

cin>>str;

p=str.c_str（）;

map>table;

stackss;

//设置词法分析表

table[NTS_E][TS_I]=1;

table[NTS_E][TS_L_PARENS]=1;

table[NTS_EE][TS_PLUS]=2;

table[NTS_EE][TS_R_PARENS]=3;

table[NTS_EE][TS_EOS]=3;

table[NTS_T][TS_I]=4;

table[NTS_T][TS_L_PARENS]=4;

table[NTS_TT][TS_PLUS]=6;

table[NTS_TT][TS_MULTIPLY]=5;

table[NTS_TT][TS_R_PARENS]=6;

table[NTS_TT][TS_EOS]=6;

table[NTS_F][TS_I]=8;

table[NTS_F][TS_L_PARENS]=7;

//初始化符号栈

ss.push（TS_EOS）;

ss.push（NTS_E）;

while（ss.size（）>0）

{

if（lexer（*p）==ss.top（））

{

p++;

ss.pop（）;

}

else

{

switch（table[ss.top（）][lexer（*p）]）

{

case1:

//1.E→TE'

ss.pop（）;

ss.push（NTS_EE）;

ss.push（NTS_T）;

break;

case2:

//2.E'→+TE'

ss.pop（）;

ss.push（NTS_EE）;

ss.push（NTS_T）;

ss.push（TS_PLUS）;

break;

case3:

//2.E'→ε

ss.pop（）;

break;

case4:

//4.T→FT'

ss.pop（）;

ss.push（NTS_TT）;

ss.push（NTS_F）;

break;

case5:

//5.T'→*FT'

ss.pop（）;

ss.push（NTS_TT）;

ss.push（NTS_F）;

ss.push（TS_MULTIPLY）;

break;

case6:

//6.T'→ε

ss.pop（）;

break;

case7:

//7.F→（E）

ss.pop（）;

ss.push（TS_R_PARENS）;

ss.push（NTS_E）;

ss.push（TS_L_PARENS）;

break;

case8:

//7.F→i

ss.pop（）;

ss.push（TS_I）;

break;

default:

cout<<"错误的句子"<

gotoEND;

break;

}

cout<<"正确的句子"<

END:

;

}

return0;

}

2.4程序运行截图

2.5小结

在程序中要跳出多层语句只能用goto语句实现。

用枚举类型表示各个终结符与非终结符，再用关联容器生成预测分析表即可方便地实现此算法。

3算符优先分析

3.1算符优先文法

E→T|E+T|E-T（注：

该文法为示例，可更改）

T→F|T*F|T/F

F→（E）|i

3.2算符优先关系表

（

）

＞

＜

＞

＜

＞

＜

＞

＜

＞

＜

＞

＜

＞

＜

＞

＜

＞

（

＜

＝

＜

）

＞

＜

＝

3.3分析程序代码

#include

usingnamespacestd;

enumSymbols{

//终结符号

TS_PLUS,//+

TS_MINUS,//-

TS_MULTIPLY,//*

TS_DIVISION,///

TS_L_PARENS,//（

TS_R_PARENS,//）

TS_I,//i

TS_EOS,//#,'\0'

TS_INVALID,//非法字符

};

map>table;

enumSymbolslexer（charc）

{

switch（c）

{

case'+':

returnTS_PLUS;

case'-':

returnTS_MINUS;

case'*':

returnTS_MULTIPLY;

case'/':

returnTS_DIVISION;

case'（':

returnTS_L_PARENS;

case'）':

returnTS_R_PARENS;

case'i':

returnTS_I;

case'#':

returnTS_EOS;//栈底：

#终结符号

default:

returnTS_INVALID;

}

//初始化算符优先关系表，0、1、2分别表示=、〈、〉，-1表示不存在

voidsetup（）

{

table[TS_PLUS][TS_PLUS]=2;

table[TS_PLUS][TS_MINUS]=2;

table[TS_PLUS][TS_MULTIPLY]=1;

table[TS_PLUS][TS_DIVISION]=1;

table[TS_PLUS][TS_L_PARENS]=1;

table[TS_PLUS][TS_R_PARENS]=2;

table[TS_PLUS][TS_I]=1;

table[TS_PLUS][TS_EOS]=2;

table[TS_MINUS][TS_PLUS]=2;

table[TS_MINUS][TS_MINUS]=2;

table[TS_MINUS][TS_MULTIPLY]=1;

table[TS_MINUS][TS_DIVISION]=1;

table[TS_MINUS][TS_L_PARENS]=1;

table[TS_MINUS][TS_R_PARENS]=2;

table[TS_MINUS][TS_I]=1;

table[TS_MINUS][TS_EOS]=2;

table[TS_MULTIPLY][TS_PLUS]=2;

table[TS_MULTIPLY][TS_MINUS]=2;

table[TS_MULTIPLY][TS_MULTIPLY]=2;

table[TS_MULTIPLY][TS_DIVISION]=2;

table[TS_MULTIPLY][TS_L_PARENS]=1;

table[TS_MULTIPLY][TS_R_PARENS]=2;

table[TS_MULTIPLY][TS_I]=1;

table[TS_MULTIPLY][TS_EOS]=2;

table[TS_DIVISION][TS_PLUS]=2;

table[TS_DIVISION][TS_MINUS]=2;

table[TS_DIVISION][TS_MULTIPLY]=2;

table[TS_DIVISION][TS_DIVISION]=2;

table[TS_DIVISION][TS_L_PARENS]=1;

table[TS_DIVISION][TS_R_PARENS]=2;

table[TS_DIVISION][TS_I]=1;

table[TS_DIVISION][TS_EOS]=2;

table[TS_L_PARENS][TS_PLUS]=1;

table[TS_L_PARENS][TS_MINUS]=1;

table[TS_L_PARENS][TS_MULTIPLY]=1;

table[TS_L_PARENS][TS_DIVISION]=1;

table[TS_L_PARENS][TS_L_PARENS]=1;

table[TS_L_PARENS][TS_R_PARENS]=0;

table[TS_L_PARENS][TS_I]=1;

table[TS_L_PARENS][TS_EOS]=-1;

table[TS_R_PARENS][TS_PLUS]=2;

table[TS_R_PARENS][TS_MINUS]=2;

table[TS_R_PARENS][TS_MULTIPLY]=2;

table[TS_R_PARENS][TS_DIVISION]=2;

table[TS_R_PARENS][TS_L_PARENS]=-1;

table[TS_R_PARENS][TS_R_PARENS]=2;

table[TS_R_PARENS][TS_I]=-1;

table[TS_R_PARENS][TS_EOS]=2;

table[TS_I][TS_PLUS]=2;

table[TS_I][TS_MINUS]=2;

table[TS_I][TS_MULTIPLY]=2;

table[TS_I][TS_DIVISION]=2;

table[TS_I][TS_L_PARENS]=-1;

table[TS_I][TS_R_PARENS]=2;

table[TS_I][TS_I]=-1;

table[TS_I][TS_EOS]=2;

table[TS_EOS][TS_PLUS]=1;

table[TS_EOS][TS_MINUS]=1;

table[TS_EOS][TS_MULTIPLY]=1;

table[TS_EOS][TS_DIVISION]=1;

table[TS_EOS][TS_L_PARENS]=1;

table[TS_EOS][TS_R_PARENS]=-1;

table[TS_EOS][TS_I]=1;

table[TS_EOS][TS_EOS]=0;

}

intmain（）

{

setup（）;//初始化优先关系表

while

（1）

{

cout<<"输入一个以#结束的符号串"<

constchar*p;

stringstr;

cin>>str;

p=str.c_str（）;

stackss;

ss.push（TS_EOS）;

while

（1）

{

if（lexer（*p）==TS_INVALID）//读取到不在集合中的非法字符

{

cout<<"×不是给定算符优先文法的句子"<

break;

}

if（ss.top（）==TS_EOS&&lexer（*p）==TS_EOS）//成功规约

{

cout<<"√是给定算符优先文法的句子"<

break;

}

else

{

if（table[ss.top（）][lexer（*p）]==1||table[ss.top（）][lexer（*p）]==0）

{

//继续读入字符，暂不规约

ss.push（lexer（*p））;

++p;

}

elseif（table[ss.top（）][lexer（*p）]==2）//符合规约要求，开始规约

{

enumSymbolstemp;

while

（1）

{

temp=ss.top（）;

ss.pop（）;

if（table[ss.top（）][temp]==1）

break;

}

else//语法错误

{

cout<<"×不是给定算符优先文法的句子"<

break;

}

return0;

}

3.4程序运行截图

3.5小结

此方法初始化优先关系法显得有点繁琐，有待改进。

4LR分析

4.1LR文法

（0）S'→S（注：

该文法为示例，可更改）

（1）S→BB

（2）B→aB

（3）B→b

4.2LR分析表

ACTION

GOTO

acc

4.3分析程序代码

#include

usingnamespacestd;

enumSymbols{

//终结符号

TS_A,//A

TS_B,//B

TS_EOS,//#,'\0'

TS_INVALID,//非法字符

//非终结符号

NTS_SS,//S'

NTS_S,//S

NTS_B,//B

//状态status

S_0,

S_1,

S_2,

S_3,

S_4,

S_5,

S_6,

S_ACC,

//GOGO

G_S,

G_B,

//规约式

R_1,

R_2,

R_3,

};

enumSymbolslexer（charc）

{

switch（c）

{

case'a':

returnTS_A;

case'b':

returnTS_B;

case'#':

returnTS_EOS;//栈底：

#终结符号

default:

returnTS_INVALID;

}

map>table;

intmain（）

{

while

（1）

{

cout<<"输入一个以#结束的字符串"<

constchar*p;

stringstr;

cin>>str;

p=str.c_str（）;

stackstatus;

//设置LR分析表

table[S_0][TS_A]=S_3;

table[S_0][TS_B]=S_4;

table[S_0][NTS_S]=S_1;

table[S_0][NTS_B]=S_2;

table[S_1][TS_EOS]=S_ACC;

table[S_2][TS_A]=S_3;

table[S_2][TS_B]=S_4;

table[S_2][NTS_B]=S_5;

table[S_3][TS_A]=S_3;

table[S_3][TS_B]=S_4;

table[S_3][NTS_B]=S_6;

table[S_4][TS_A]=R_3;

table[S_4][TS_B]=R_3;

展开阅读全文