S -> aS | bS | c

Working-string      Production
S                   S -> aS
aS                  S -> bS
abS                 S -> aS
abaS                S -> c
abac                ACCEPT

S → rXd | rZd
X → oa | ea
Z → ai

S → rS'
S'-> Xd | Zd
X → oa | ea
Z → ai

S–> AB
A –> aA | ε
B –> b | bB

Working-string    Production
S                 S –> AB
AB

Working-string      Production
S                   S –> AB
AB                  A –> aA
aAB

Working-string    Production
S                 S –> AB
AB                A –> aA
aAB               A –> aA
aaAB

Working-string   Production
S                S –> AB
AB               A –> aA
aAB              A –> aA
aaAB             A –> aA
aaaAB

Working-string    Production
S                 S –> AB
AB                A –> aA
aAB               A –> aA
aaAB              A –> aA
aaaAB             A -> ε
aaaB

Working-string   Production
S                S –> AB
AB               A –> aA
aAB              A –> aA
aaAB             A –> aA
aaaAB            A -> ε
aaaB             B -> b
aaab             ACCEPT

A -> a

S -> AB
A -> a

FIRST(A) = {a}
FIRST(S) = {a}

S -> AB
A -> a | ε
B -> b

FIRST(A) = {a，ε}
FIRST(S) = ？

S -> AB
A -> a | ε
B -> b | ε

FIRST(A) = {a，ε}
FIRST(S) = ？

S -> AB
A -> a | ε
B -> b

S->AB

A->ε

S -> AB
A -> C|a
B -> b
C -> c | ε

A -> C

S -> aS | bS | c

S–> AB
A –> aA | ε
B –> b | bB

E->TE'
E'->+TE'|Ɛ
T->FT'
T'->*FT'|Ɛ
F->(E)|id

FIRST(E) = FIRST(T) = FIRST(F) = { ( , id }
FIRST(E'） = {+, Ɛ}
FRIST(T') = {*, Ɛ}
FOLLOW(E) = FOLLOW(E') = { ), $}
FOLLOW(T) = FOLLOW (T') = {+, ), $}
FOLLOW(F) = {+, *, ), $} 

S->SS+|SS*|a

S->aS’
S’->aS’AS’|Ɛ
A->+|*

FIRST(S)={a}
FOLLOW(S)={a,+,*,$}

First(S) = First(aS’)={a}
First(S’)= First(aS’AS’) ∪ First(Ɛ)= {a} ∪{Ɛ}= {a, Ɛ}
First(A) = { +,*}
Follow(S) ={$}
Follow(S’)= {$, +,*}
Follow(A)= {a, +,*,$}

S->Aa
A->B|C
C->Ɛ
B->a

S ->AB|PQx
A -> xy
B -> bc
P -> dP| ε
Q -> aQ| ε

E->TE'
E'->+TE'|ε
T->FT'
T'->*FT'|ε
F->(E)|id

FIRST(E) = FIRST(T) = FIRST(F) = { ( , id }
FIRST(E') = {+, Ɛ}
FRIST(T') = {*, Ɛ}
FOLLOW(E) = FOLLOW(E') = { ), $}
FOLLOW(T) = FOLLOW (T') = {+, ), $}
FOLLOW(F) = {+, *, ), $} 

S->Ɛ

S –> AB
A –> aA | ε
B –> b | bB

Working-string   Production
S                S –> AB
AB               A –> aA
aAB              A –> aA
aaAB             A –> aA
aaaAB            A -> εaaaB
B -> b           aaab
ACCEPT

S->Aa
A->B|C
C->Ɛ
B->a

D -> TL
T -> int | real
L -> id R
R -> , idR | ε

#include <iostream>
#include <map>
#include <stack>/*grammar:
S->F;
S->(S+F);
F->a;
sentence:a,(a+a),((a+a)+a) */enum Symbols {// the symbols:// Terminal symbols:TS_L_PARENS,    // (TS_R_PARENS,    // )TS_A,           // aTS_PLUS,        // +TS_EOS,         // $, in this case corresponds to '0'TS_INVALID,     // invalid token// Non-terminal symbols:NTS_S,          // SNTS_F           // F
};/*
Converts a valid token to the corresponding terminal symbol
*/
Symbols lexer(char c)
{switch(c){case '(':  return TS_L_PARENS;case ')':  return TS_R_PARENS;case 'a':  return TS_A;case '+':  return TS_PLUS;case '0': return TS_EOS; // end of stack: the $ terminal symboldefault:   return TS_INVALID;}
}int main(int argc, char **argv)
{using namespace std;if (argc < 2){cout << "usage:ntll '(a+a)'" << endl;return 0;}// LL parser table, maps < non-terminal, terminal> pair to action       map< Symbols, map<Symbols, int> > table;stack<Symbols>  ss;     // symbol stackchar *p;        // input buffer// initialize the symbols stackss.push(TS_EOS);        // terminal, $ss.push(NTS_S);         // non-terminal, S// initialize the symbol stream cursorp = &argv[1][0];// set up the parsing table 预测分析表；table[NTS_S][TS_L_PARENS] = 2;table[NTS_S][TS_A] = 1;table[NTS_F][TS_A] = 3;while(ss.size() > 0){if(lexer(*p) == ss.top()){cout << "Matched symbols: " << lexer(*p) << endl;p++;ss.pop();}else{cout << "Rule " << table[ss.top()][lexer(*p)] << endl;switch(table[ss.top()][lexer(*p)]){case 1: // 1. S → Fss.pop();ss.push(NTS_F); // Fbreak;case 2: // 2. S → ( S + F ) //使用产生式的右部替换左部ss.pop();ss.push(TS_R_PARENS);   // )ss.push(NTS_F);         // Fss.push(TS_PLUS);       // +ss.push(NTS_S);         // Sss.push(TS_L_PARENS);   // (break;case 3: // 3. F → ass.pop();ss.push(TS_A);  // abreak;default:cout << "parsing table defaulted" << endl;return 0;break;}}}cout << "finished parsing" << endl;return 0;
}