1. grammar G (S):
（1）S -> AB
（2）A ->Da|ε
（3）B -> cC
（4）C -> aADC |ε
（5）D -> b|ε
Verify grammar G (S) is not LL (1) grammar?
FIRST集：
FIRST(Da)={b,a}
FIRST (e) = {e}
FIRST(aADC)={a}
FIRST(b)={b}
FOLLOW集：
FOLLOW(A)={c,b,a,#}
FOLLOW(C)={#,}
FOLLOW(D)={a,#}
SELECT set:
SELECT(A->Da)=FIRST(Da)={b,a}
SELECT(A->ε)=FIRST(ε)-{ε}UFOLLOW(A)=FOLLOW(A)={c,b,a,#}
solution:
SELECT(A->Da) ∩ SELECT(A->ε) ≠ Ø
It found that G (S) is not LL (1) syntax.
2. (last job) after the elimination of left recursion whether the expression grammar is LL (1) grammar?
Eliminate left recursion:
E -> TE '
E '-> + TE' | e
T -> FT’
T’ -> *FT’ | ε
F -> (E) | i
FIRST集：
FIRST(TE')={ (, i }
FIRST(+TE')={+}
FIRST (e) = {e}
FIRST(FT')={ (, i }
FIRST(*FT')={*}
FIRST((E))={ ( }
FIRST(i)={i}
FOLLOW集：
FOLLOW(E) = {)，#}
FOLLOW(E’) = { ) ，# }
FOLLOW(T) = { + ， ) ， # }
FOLLOW(T’) = { + ， ) ， # }
FOLLOW(F) = {+，*，) ，# }
SELECT set:
SELECT(E->TE')=FIRST(TE')={ (, i }
SELECT(E'->+TE')=FIRST(+TE')={+}
SELECT (E '-> e) = FIRST (e) - {e} UFOLLOW (E') = FOLLOW (E ') = {), #}
SELECT(T->FT')=FIRST(FT')={ (,i }
SELECT(T'->*FT')=FIRST(*FT')={*}
SELECT(T'->ε)=FIRST(ε)-{ε}UFOLLOW(T')=FOLLOW(T')={ +,),# }
SELECT(F->(E))=FIRST((E))={ ( }
SELECT(F->i)=FIRST(i)={i}
solution:
SELECT (E '-> + TE') ∩ SELECT (E '-> ε) = O
SELECT(T'->*FT') ∩ SELECT(T'->ε) = Ø
SELECT(F->(E)) ∩ SELECT(F->i) = Ø
Therefore, after the elimination of left recursion expression grammar is LL (1) grammar.
3. The connection 2, if it is LL (1) grammar, write its recursive descent parser code.
E()
｛T();
E'();
}
E'()
T()
T'()
F()
Code:
void ParseE(){
switch(lookahead){
case ‘(‘,‘i‘, ‘*‘:
Frset ();
ParseEP();
break;
default:
print("syntx error!\n");
exit(0);
}
}
void ParseEP(){
switch(lookahead){
case ‘+‘:
Match Token ( '+');
Frset ();
ParseEP();
break;
case ‘#‘, ‘)‘:
break;
default:
print("syntx error!\n");
exit(0);
}
}
void ParseT(){
switch(lookahead){
case ‘(‘,‘i‘:
ParseF();
ParseTP();
break;
default:
print("syntx error！\n");
exit(0);
}
}
void ParseTP(){
switch(lookahead){
case ‘*‘:
Match Token ( '*');
ParseF();
ParseTP();
break;
case ‘#‘, ‘)‘, ‘+‘:
break;
default:
print("syntx error！\n");
exit(0);
}
}
void ParseF(){
switch(lookahead){
case ‘(‘:
Match Token ( '(');
ParseE();
Match Token ( ')');
break;
case ‘i‘:
Match Token ( 'in');
break;
default:
print("syntx error!\n");
exit(0);
}
}
Experiment 4. Add a lexical analyzer, parser can form a run, analyzing any input symbol string is not a valid expression.