1. Syntax Analysis
Sections :

2. Other Derivation Concepts
Leftmost: Replace the leftmost non-terminal symbol
E  E A E  id A E  id * E  id * id
Rightmost: Replace the rightmost non-terminal symbol
E  E A E  E A id  E * id  id * id lm lm lm lm rm rm rm rm
Important Notes: A  
If A    , what’s true about  ?
If A    , what’s true about  ?  lm  rm
Derivations: Actions to parse input can be represented pictorially in a parse tree.

3. Examples of LM / RM Derivations
E  E A E | ( E ) | -E | id
A  + | - | * | / | 
A leftmost derivation of : id + id * id
A rightmost derivation of : id + id * id

4. Derivations & Parse Tree
E  E A E E A *
 E * E E A id *
 id * E E A id *
 id * id

5. Parse Trees and Derivations
Consider the expression grammar:
E  E+E | E*E | (E) | -E | id
Leftmost derivations of id + id * id
E + E  id + E E + id E +
E  E + E E *
id + E  id + E * E + id

6. Parse Tree & Derivations - continued*
id + E * E  id + id * E + id
id + id * E  id + id * id E * + id

7. Alternative Parse Tree & Derivation
E  E * E
 E + E * E
 id + E * E
 id + id * E
 id + id * id E + * id
WHAT’S THE ISSUE HERE ?
Two distinct leftmost derivations!

8. Resolving Grammar Problems/Difficulties
Regular Expressions : Basis of Lexical Analysis
Reg. Expr.  generate/represent regular languages
Reg. Languages  smallest, most well defined class
of languages
Context Free Grammars: Basis of Parsing
CFGs  represent context free languages
CFLs  contain more powerful languages
Reg. Lang.
CFLs
anbn – CFL that’s not regular.

9. Resolving Problems/Difficulties – (2)
Since Reg. Lang.  Context Free Lang., it is possible to go from reg. expr. to CFGs via NFA.
Recall: (a | b)*abb
start 3 b 2 1 a

10. Resolving Problems/Difficulties – (3)
Construct CFG as follows:
Each State I has non-terminal Ai : A0, A1, A2, A3
If then Ai a Aj
If then Ai bAj
If I is an accepting state, Ai  : A3  
If I is a starting state, Ai is the start symbol : A0 i j a
: A0 aA0, A0 aA1
: A0 bA0, A1 bA2
: A2 bA3 i j b
T={a,b}, NT={A0, A1, A2, A3}, S = A0
PR ={ A0 aA0 | aA1 | bA0 ;
A1  bA2 ;
A2  bA3 ;
A3   }
start 3 b 2 1 a

11. How Does This CFG Derive Strings ?
start 3 b 2 1 a
vs.
A0 aA0, A0 aA1
A0 bA0, A1 bA2
A2 bA3, A3 
How is abaabb derived in each ?

12. Regular Expressions vs. CFGs
Regular expressions for lexical syntax
CFGs are overkill, lexical rules are quite simple and straightforward
REs – concise / easy to understand
More efficient lexical analyzer can be constructed
RE for lexical analysis and CFGs for parsing promotes modularity, low coupling & high cohesion.
CFGs : Match tokens “(“ “)”, begin / end, if-then-else, whiles, proc/func calls, …
Intended for structural associations between tokens !
Are tokens in correct order ?

13. Resolving Grammar Difficulties : Motivation
The structure of a grammar affects the compiler design recall “syntax-directed” translation
Different parsing approaches have different needs
Top-Down vs. Bottom-Up
redesigning a grammar may assist in producing better parsing methods.
ambiguity
-moves
cycles
left recursion
left factoring
Grammar Problems

14. Resolving Problems: Ambiguous Grammars
Consider the following grammar segment:
stmt  if expr then stmt
| if expr then stmt else stmt
| other (any other statement)
What’s problem here ?
Let’s consider a simple parse tree:
stmt
expr E1 E2 S3 S1 S2
then
else if
Else must match to previous then. Structure indicates parse subtree for expression.

15. Example : What Happens with this string?
If E1 then if E2 then S1 else S2
How is this parsed ?
if E1 then
if E2 then S1
else S2
if E1 then
if E2 then S1
else S2
vs.
What’s the issue here ?

16. Parse Trees for Example
Form 1:
stmt
expr E1
then if E2 S2 S1
else
Form 2:
stmt
expr E1 S2
then
else if E2 S1
What’s the issue here ?