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?
solution:
A->Da
A->ε
C->aADC
C->ε
D->b
D->ε
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) = {b,a}
Select(A->ε) = {c,b,a,#}
Select(C->aADC) ={a}
Select(C->ε) = {#}
Select(D->b) = {b}
Select(D->ε) = {a,#}
Thus be obtained: Select (A-> Da) ∩ Select (A-> ε) ≠ ∅
Select(C->aADC) ∩ Select(C->ε) ＝∅
Select(D->b) ∩ Select(D->ε) ＝∅
Thus the LL (1) grammar that defines the grammar is not LL (1) syntax.
2. (last job) after the elimination of left recursion whether the expression grammar is LL (1) grammar?
solution:
Eliminate left recursion:
(1) E-> TE '
E '-> + TE' | e
(2) T->FT'
T'->*FT'|ε
(3) F->(E)|i
SELECT set:
Select(E->TE') = First(TE') = {(,i}
Select(E'->+TE') = First(+TE') = {+}
Select (E '-> e) = (First (e) = {e}) ∪Follow (E') = {), #}
Select(T->FT') = First(FT') = {(,i}
Select(T'->*FT') = First(+TE') = {*}
Select(T'->ε) = (First(ε) = {ε})∪Follow(T') = {+,),#}
Select( F->(E)) = First((E)) = {( }
Select( F->i) = First(i) = {i}
Thus can be obtained, Select (E '-> + TE') ∩ Select (E '-> ε) = ∅
Select(T'->*FT') ∩ Select(T'->ε) = ∅
Select( F->(E)) ∩ Select( F->i) = ∅
So that (1) the grammar defined by the grammar is LL LL (1) syntax.
3. The connection 2, if it is LL (1) grammar, write its recursive descent parser code.
E()
｛T();
E'();
}
E'()
T()
T'()
F()
void ParseE(){
switch(lookahead){
case '(','i':
Frset ();
ParseE'();
break;
default:
print("syntax error \n");
exit(0);
}
}
void ParseE'(){
switch(lookahead){
case '+':
Match Token ( '+');
Frset ();
ParseE'();
break;
case ')','#':
break;
default:
print("syntax error \n");
exit(0);
}
}
void ParseT(){
switch(lookahead){
case '(','i':
ParseF();
Frset '();
break;
default:
print("syntax error \n");
exit(0);
}
}
void ParseT'(){
switch(lookahead){
case '*':
Match Token ( '*');
ParseF();
Frset '();
break;
case '+',')','#':
break;
default:
print("syntax error \n");
exit(0);
}
}
void ParseF(){
switch(lookahead){
case '(':
Match Token ( '(');
ParseE();
Match Token ( ')');
break;
case 'i':
Match Token ( 'in');
break;
default:
print("syntax 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.