Data Structure for Grammars - Compiler Design - Lecture Slides, Slides of Computer Science

Download Data Structure for Grammars - Compiler Design - Lecture Slides and more Slides Computer Science in PDF only on Docsity!

Lecture #9, Feb. 12, 2007

• A data structure for grammars
• Computing Nullable and First in SML

fun inputc fname =

(fn n => TextIO.inputN(TextIO.openIn fname,n):string);

val lex = Mlex.makeLexer (inputc "test.english");

fun inputc h =

(fn n =>

TextIO.inputN(h,n):string);

val lex = let val h = TextIO.openIn “test.english”

in Mlex.makeLexer (inputc h) end;

Example Grammar

val g1 = Gram(["Expr","Term","Factor","Expr'","Term'"] ,["ident","+","-","","div","(",")","num"] ,[("Expr",["Term","Expr'"]) ,("Expr'",["+","Term","Expr'"]) ,("Expr'",["-","Term","Expr'"]) ,("Expr'",[]) ,("Term",["Factor","Term'"]) ,("Term'",["","Factor","Term'"]) ,("Term'",["div","Factor","Term'"]) ,("Term'",[]) ,("Factor",["(","Expr",")"]) ,("Factor",["num"]) ,("Factor",["ident"]) ] ,"Expr");

Operations on Grammars

fun termP (Gram(nts,ts,ps,s)) x =

List.exists (fn y => y=x) ts;

fun nontermP (Gram(nts,ts,ps,s)) x =

List.exists (fn y => y=x) nts;

fun rhssFor (Gram(nts,ts,ps,start))

symbol =

let fun test (lhs,rhs) = lhs=symbol

fun rhs (l,r) = r

in List.map rhs (List.filter test

ps) end;

Updating

• When we update a table we need to know if the update makes a change. Since

we continue until no new changes are possible.

(* Update the slot at "s" with the function "updatef" *)

(* returns true if it makes a change, false otherwise *)

fun update s updatef pairs =

case List.find (fn (y,r) => s=y) pairs of

SOME(_,r) => let val old = !r

val new = updatef old

in if new=old

then false

else (r := new; true) end

| NONE => false

Basic Strategy

let val table = init … symbols

val changed = ref true

in while (!changed) do

(changed := false

; changed := onePass symbols);

table

end

• Initialize table
• Record changes
• Apply rules until no changes are made in a single

pass.

and nullable table s =

case List.find (fn (y,r) => y=s)

table of

NONE => false

| SOME(_,r) => !r

and nullableRhs table [] = true

| nullableRhs table (x::xs) =

(nullable table x) andalso

(nullableRhs table xs);

val NullT = nullTable g1;

• NullT;

val it =

[("Expr",ref false), ("Term",ref false), ("Factor",ref false), ("Expr'",ref true), ("Term'",ref true), ("ident",ref false), ("+",ref false), ("-",ref false), ("*",ref false), ("div",ref false), ("(",ref false), (")",ref false), ("num",ref false)] : (string * bool ref) list

First for a RHS

and first table s =

case List.find (fn (y,r) => y=s) table of

NONE => []

| SOME(_,r) => !r

and firstRhs gram table [] = [empty]

| firstRhs gram table [x] = first table x

| firstRhs gram table (x::xs) =

let val temp = first table x

in case List.find emptyP temp of

NONE => temp

| SOME _ => temp @ firstRhs gram table xs

end;

The main loop

fun firstTable (gram as(Gram(nts,ts,ps,start))) = let val termTable = init ts (fn x => [x]) val nontermTable = init nts (fn x => []) val table = termTable @ nontermTable val changed = ref true fun onePass [] = false | onePass (x::xs) = let val rhss = rhssFor gram x fun first old = let val listOflists = map (firstRhs gram table) rhss val new = List.concat listOflists in norm(old @ new) end val b1 = update x first table val b2 = onePass xs in b1 orelse b2 end

in while (!changed) do (changed := false; changed := onePass nts); table end

Possible exam questions

• Define a grammar.

• Prove that a particular grammar is

ambiguous.

– i.e. find a single string accepted by the

grammar with more than 1 parse.

• Give a regular expression that describes

comments (or some other given lexeme).

• Translate a regular expression into a finite

state automata

– where the FSA has transitions

– where the FSA has no transitions

Possible exam questions (cont. 2)

• Write a function over an abstract (inductive)

data type by using patterns.

• Produce the First, and Last sets from a

regular expression.

• Simulate a top-down parse of a string by

hand for a particular grammar.

• Remove left recursion from a grammar.

Possible exam questions (cont. 4)

• Write simple anonymous function in ML
• Use the List library functions List.map,

List.filter, List.exists,

Lists.all, List.find to write

simple functions.