Week 3
This presentation is the property of its rightful owner.
Sponsored Links
1 / 33

Week 3 PowerPoint PPT Presentation


  • 108 Views
  • Uploaded on
  • Presentation posted in: General

Week 3. Questions / Concerns What’s due: Lab1b due Friday at midnight Lab1b check-off next week (schedule will be announced on Monday) Homework #2 due next Monday (Draw a parse tree) Homework #3 due next Wednesday (Define grammar for your language)

Download Presentation

Week 3

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Week 3

Week 3

  • Questions / Concerns

  • What’s due:

    • Lab1b due Friday at midnight

    • Lab1b check-off next week (schedule will be announced on Monday)

    • Homework #2 due next Monday (Draw a parse tree)

    • Homework #3 due next Wednesday (Define grammar for your language)

    • Homework #4 due next Thursday (Grammar modifications)

  • Top down parser

  • Grammar modifications


Structure of compilers

Structure of Compilers

skeletal source program

preprocessor

Modified Source Program

Syntax Analysis

(Parser)

Lexical Analyzer (scanner)

Tokens

Syntactic Structure

Semantic Analysis

Intermediate Representation

Optimizer

Symbol Table

Code Generator

Target machine code


Parser

Parser

  • Choose a type of parser

    • Top-Down parser

    • Bottom-Up parser

  • Choose a parsing technique

    • Recursive Descent

    • Table driven parser (LL(1) or LR(1))

  • Generate a grammar for your language

  • Modify the grammar to fit the particular parsing technique

    • Remove lambda productions

    • Remove unit productions

    • Remove left recursion

    • Left factor the grammar


Parser1

Parser

  • Parser is just a matching tool

    • It matches list of tokens with grammar rules to determine if they are legal constructs/statements or not.

    • Yes/No machine

    • Context-Free

      • It doesn’t care about context (types), it just cares about syntax

      • If it looks like an assignment statement, then it is an assignment statement.

int x;

x = “Hello”;


Grammar 1

Grammar #1

S -> aaSc| B

B -> bbbB | 

Generate a parse tree for the input string

aaaabbbcc


Grammar 2

Grammar #2

S -> E

E -> E + E

E -> E * E

E -> a |b | c

Generate a parse tree for the input string

a + b * c


Grammar 3

Grammar #3

  • Lua Grammar


Grammar

Grammar

  • Two formats

    • Context-Free Grammar

    • Extended Backus-Naur Form

      Lua Example

      laststat ::= return [explist] | break

      Laststat -> return LaststatOptional | break LaststatOptional -> Explist | 

      varlist ::= var {`,´ var}

      Varlist -> Var Varlist2

      Varlist2 -> `,´ Var Varlist2 | 


Grammar1

Grammar

  • Two formats

    • Context-Free Grammar

    • Extended Backus-Naur Form

      Mini C example

      Program = Definition { Definition }

      program -> Definition MoreDefinitions MoreDefinitions -> Definition MoreDefinitions | 

      Definition = Data_definition | Function_definitionDefinition -> Data_definition | Function_definition

      Function_definition = ['int'] Function_header Function_bodyFunction_definition -> OptionalType Function_header Function_body OptionalType -> ‘int’ | 


Top down parser

Top-down parser

  • Start with start symbol of the grammar.

  • Grab an input token and select a production rule.

    • Use “stack” to store the production rule.

  • Try to parse that rule by matching input tokens.

  • Keep going until all of the input tokens have been processed.

  • If the rule is not the right one, put all the tokens back and try a different rule. (backtracking)


Top down parser1

Top-down Parser

  • Ideal grammar:

    • Unique rule for each type of token.

      • One-token look ahead


One token look ahead

One token look ahead

Stat ->

localfunction Name Funcbody |

local Namelist LocalOptional

  • Based on one token “local” we should be able to pick one unique rule so we don’t have to backtrack.

  • What if we could combine these 2 rules into one rule by factoring out the common parts, it would eliminate the need for backtracking.


One token look ahead1

One token look ahead

Stat ->

localfunction Name Funcbody |

local Namelist LocalOptional

  • Left factor the grammar:

    Stat -> localMorelocal

    Morelocal -> function Name Funcbody |

    Namelist LocalOptional


Top down parser2

Top-down Parser

  • Ideal grammar:

    • Unique rule for each type of token.

      • One-token look ahead

    • Minimize unit productions

      • Unit productions don’t parse tokens immediately. It requires another production.

      • It’s hard to tell which tokens match the unit productions thus more chances for backtracking.


Minimize unit productions

Minimize Unit Productions

S -> aaSc

S -> B

B -> bbbB

B -> 

S

B

b b b B


Minimize unit productions1

Minimize Unit Productions

Exp -> nil | false | true | Number | String | `...´ | Functioncall | Prefixexp | Tableconstructor | Exp Binop Exp | Unop Exp


Remove unit productions

Remove Unit Productions

S -> aaSc

S -> B

B -> bbbB

B -> 

S -> aaSc

S -> bbbB

S -> 

B -> bbbB

B -> 


Minimize unit productions2

Minimize Unit Productions

Exp -> nil | false | true | Number | String | `...´ | Functioncall | Prefixexp | Tableconstructor | Exp Binop Exp | Unop Exp

Exp -> nil | false | true | Number | String | `...´ |

Functioncall| Prefixexp | { Fieldlistoptional }| Exp Binop Exp | Unop Exp


Minimize unit productions3

Minimize Unit Productions

Exp -> nil | false | true | Number | String | `...´ | Functioncall | Prefixexp | Tableconstructor | Exp Binop Exp | Unop Exp

Exp -> nil | false | true | Number | String | `...´ | Prefixexp Args | Prefixexp `:´ Name Args | Prefixexp | { Fieldlistoptional } | Exp Binop Exp | Unop Exp


Minimize unit productions4

Minimize Unit Productions

Exp -> nil | false | true | Number | String | `...´ | Functioncall | Prefixexp | Tableconstructor | Exp Binop Exp | Unop Exp

Exp -> nil | false | true | Number | String | `...´ | Prefixexp Args | Prefixexp `:´ Name Args | Prefixexp | { Fieldlistoptional } | Exp Binop Exp | Unop Exp

More left factoring needed


Top down parser3

Top-down Parser

  • Ideal grammar:

    • Unique rule for each type of token.

      • One-token look ahead

    • Minimize unit productions

      • Unit productions don’t parse tokens immediately. It requires another production.

      • It’s hard to tell which tokens match the unit productions thus more chances for backtracking.

    • Lambda productions are okay but we have to process them accordingly.

      • Removing lambdas always add more rules.

      • It’s not possible to remove all lambda productions and still yield unique token-rule matching.

    • Remove left recursion in the grammar.


Grammar left recursive vs right recursive

Grammar (left recursive vs. right recursive)

Right Recursion

A -> aA

A -> 

Left Recursion

A -> Aa

A -> 

Same grammar?

A

A

A

a

a

A

a

A

a

A

Only non-recursive rule is 

a

A

a

A


Grammar left recursive vs right recursive1

Grammar (left recursive vs. right recursive)

Which one works for top down?

A -> Aa

A -> 

A -> aA

A -> 

A

A

A

a

a

A

a

A

a

A

a

A

a

A


Grammar left recursive vs right recursive2

Grammar (left recursive vs. right recursive)

Same grammar?

A -> Aa

A -> b

A -> aA

A -> b

A

A

A

a

a

A

a

A

a

A

Non-recursive rules are not only 

a

A

a

A

b

b


Remove left recursion in the grammar

Remove Left Recursion in the Grammar

  • Example:

    A -> Aa

    A -> b

  • Step 1: Make all left recursive rules right recursive, but give them a new non-terminal

    A -> Aa  X -> aX

  • Step 2: Add a lambda production to the new non-terminal X -> 

  • Step 3: Identify all non-recursive rules.

    A -> b

  • Step 4: Append the new non-terminal to the end of all non-recursive rules

    • A -> bX

A -> A… Left Recursive rule


Grammar left recursive vs right recursive3

Grammar (left recursive vs. right recursive)

Same grammar?

A -> bX

X -> aX | 

A -> Aa

A -> b

A

A

b

X

A

a

a

X

a

A

Non-recursive rules are not only 

a

X

a

A

a

b


Remove left recursion

Remove Left Recursion

S -> Sab

S -> c

S -> d

X -> abX

X -> 

S -> cX

S -> dX


Remove left recursion1

Remove Left Recursion

PARAMLIST -> IDLIST : TYPE |

PARAMLIST ; IDLIST : TYPE

PARAMLIST2 -> ; IDLIST : TYPE PARAMLIST2

PARAMLIST2 -> 

PARAMLIST -> IDLIST : TYPE PARAMLIST2


Remove unit production example

Remove Unit Production Example

S -> abSc

S -> A

S -> AB

A -> aA

A -> 

B -> bbB

B -> 

S -> abSc

S -> aA

S -> 

S -> AB

A -> aA

A -> 

B -> bbB

B -> 


Remove unit production example1

Remove Unit Production Example

TERM -> FACTOR

FACTOR ->

id

| id ( EXPR_LIST )

| num

| ( EXPRESSION )

| not FACTOR

TERM ->

id

| id ( EXPR_LIST )

| num

| ( EXPRESSION )

| not FACTOR

FACTOR ->

id

| id ( EXPR_LIST )

| num

| ( EXPRESSION )

| not FACTOR


Left factor example

Left Factor Example

S -> abS

S -> aaA

S -> a

A -> bA

A -> 

S -> aX

X -> bS

X -> aA

X -> 

A -> bA

A -> 


Left factor example1

Left Factor Example

EXPRESSION ->

SIMPLE_EXPR

| SIMPLE_EXPR relop SIMPLE_EXPR

EXPRESSION -> SIMPLE_EXPR RestOfExp RestOfExp ->  |

relop SIMPLE_EXPR


In class exercise 5

In-Class Exercise #5

  • Remove Unit Production

    S -> abS | bSa | A | d A -> c | dA

  • Left Factor this grammar

    FACTOR -> id

    | id ( EXPR_LIST )

    | num

    | ( EXPRESSION )

    | not FACTOR

  • Remove Left recursion:

    SIMPLE_EXPR -> TERM

    | SIGN TERM

    | SIMPLE_EXPR addop TERM


  • Login