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(cC)={c}
FIRST(aADC)={a}
FIRST(b)={b}
FOLLOW集
FOLLOW(A)={c,b,a,#}
其中#是FOLLOW(A)=FOLLOW(C)=FOLLOW(B)=FOLLOW(S)
FOLLOW(B)={#}
FOLLOW(C)={#}
FOLLOW(D={a,#}
SELECT Set
SELECT(A->Da)=FIRST(Da)={b,a}
SELECT(A->ε)=FOLLOW(A)={c,b,a,#}
SELECT(C->aADC)=FIRST(aADC)={a}
SELECT(C->ε)=FOLLOW(C)={#}
SELECT(D->b)=FIRST(b)={b}
SELECT(D->ε)=FOLLOW(D)={a,#}
Since the SELECT (A-> Da) ∩ the SELECT ( A-> [epsilon] ) ≠ ∅
SElECT(C->aADC）∩SELECT(C->ε)=∅
SELECT(D->b)∩SELECT(D->ε)=∅
Therefore, G (S) is not LL (1) syntax.
2. ( last job ) to eliminate left after the recursive expression grammar whether it is LL (1) grammar?
Eliminate left recursion too:
E-> TE '
E '-> + TE' | e
T->FT’
T’->*FT’|ε
F->(E)|i
FIRST集：
FIRST(TE’)={ (, i }
FIRST (TE + ') = {+ , 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’ -> ε) = FIRST(ε) - {ε} U FOLLOW(E’) = FOLLOW(E’) = { ) , # }
SELECT(T -> FT’) = FIRST(FT’) = { ( , i }
SELECT(T’ -> *FT’) = FIRST(*FT’) = { * }
SELECT(T’ -> ε) = FIRST(ε) - {ε} U FOLLOW(T’) = FOLLOW(T’) = { + , ) ,# }
SELECT(F -> (E)) = FIRST((E)) = { ( }
SELECT(F -> i) = FIRST(i) = { i }
SELECT(E’ -> +TE’) = FIRST(+TE’) = { + } ∩ SELECT(E’ -> ε) = FOLLOW(E’) = { ) , # }=∅
SELECT(T’ -> *FT’) = FIRST(*FT’) = { * } ∩ SELECT(T’ -> ε) =FOLLOW(T’) = { + , ) ,# }=∅
SELECT(F -> (E)) = FIRST((E)) = { ( } ∩ SELECT(F -> i) = FIRST(i) = { i }=∅
Therefore, the grammar is 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:
printf("syntx error\n");
exit(0);
}
}
Void ParseE’()
{
Switch(lookahead){
case ‘+’:
Match Token (+);
Frset ();
ParseE’();
break;
case ‘)’,’#’
break;
default:
printf("syntx error\n");
exit(0);
}
}
Void ParseT()
{
Switch(lookahead){
case ‘(’,’i’
ParseF();
Frset '();
break;
default:
printf("syntx error\n");
exit(0);
}
}
Void ParseT’()
{
Switch(lookahead){
case ‘*’:
Match Token (*);
ParseF();
Frset '();
break;
case ‘+’ ,’ )’ ,’#’:
break;
default:
printf("syntx error\n");
exit(0);
}
}
void ParseF(){
switch(lookahead){
case '(':
Match Token ( '(');
ParseE();
Match Token ( ')');
break;
case 'i':
Match Token ( 'in');
break;
default:
printf("syntx error\n");
exit(0);
}
}