An Attribute Grammar for Tiny Prepared by Manuel E. Bermúdez, Ph.D. Associate Professor University...

An Attribute Grammar for Tiny

Prepared byManuel E. Bermúdez, Ph.D.

Associate ProfessorUniversity of Florida

Programming Language PrinciplesLecture 18

An Attribute Grammar for Tiny

• Tiny: a very small Pascal-like language with the following: • Every program is given a name.• Variables of type integer.• Expressions composed of:

• variables• integers• intrinsic function "read"• boolean operator "not"

An Attribute Grammar for Tiny (cont’d)

• equality operator "="• binary operators "+" and "-"• unary "-", "not".

• Assignment statements.• Variables must be assigned a value

before they are used.• No declarations.

An Attribute Grammar for Tiny (cont’d)

• Statements:• if-then-else• while• statement sequencing (";")• output statement.

Tiny’s Syntax

Tiny → 'program' Name ':' S 'end' Name '.’ => 'program';S → 'assign' Name ':=' Exp => 'assign' → 'output' Exp => 'output' → 'if' Exp 'then' S 'else' S 'fi' => 'if' → 'while' Exp 'do' S 'od' => 'while' → S list ';' => ';' ;Exp → Term '=' Term => '=' → Term;Term → Term '+' Factor => '+' → Term '-' Factor => '-' → Factor;

Tiny’s Syntax (cont’d)

Factor → '-' Factor => '-' → 'not' Factor => 'not' → Name → 'read' => 'read' → '<integer>' → '(' Expression ')'; Name → '<identifier>';

Sample Tiny Program

• Copies 10 integers from input to output:

program copy: assign i := 1; while not (i=11) do output read; assign i := i + 1 odend copy.

AST Grammar for Tiny

P → <'program' '<identifier>' E '<identifier>'> E → <'assign' '<identifier>' E> → <'output' E> → <'if' E E E> → <'while' E E> → <';' E+> → <'not' E> → <'=' E E> → <'+' E E> → <'-' E E> → <'-' E> → '<identifier>' → '<integer>' → 'read'

Note

• AST grammar simplified.• No distinction between expressions

and statements.

• Our attribute grammar will specify the translation (compilation) of Tiny programs to assembly for an abstract machine.

Target Machine Instruction Set

PC := 1;Next: case Code[PC] of save n:stack[n] := stack[top--] load n:stack[++top] := stack[n] negate:stack[top] := -stack[top] not: stack[top] := not stack[top] add: t := stack[top--]; stack[top] := stack[top] + t subtract: t := stack[top--]; stack[top] := stack[top] - t equal: t := stack[top--]; stack[top] := stack[top] = t

Target Machine Instruction Set (cont’d)

read: stack[++top] := getinteger(input) print: putinteger(stack[top--]) lit n: stack[++top] := n goto n: PC := n; goto Next iffalse n: if stack[top--] = 0 then PC:=n; goto Next

fi iftrue n: if stack[top--] = 1 then PC:=n; goto Next

fi stop: haltend;++PC;goto Next;

Target Code for our Sample Tiny Program1: lit 1 # i := 12: load 1 # i = 113: lit 114: equal5: not6: iffalse 14 # while7: read8: print9: load 1 # i := i + 110: lit 111: add12: save 113: goto 2 # od14: stop # end

program copy: assign i := 1; while not (i=11) do output read; assign i := i +

1 odend copy.

Semantic Errors

• Variables used before being initialized.• Non-boolean expression in "while", "not",

or "if".• Non-integer expression in "=", "-", or "+".• Program names do not match.

Data Structures Required

• Declaration table.• Function enter(name,l).

• Binds "name" with stack location "l".• Returns "l".

• Function lookup(name).• Returns the location of "name" .• Returns 0 if "name" is not found.

Data Structures Required (cont’d)• Files.

• Function gen(file, arg1 , ..., argn). Writes a new line to "file". The line contains arg1 , ..., argn. Returns the new, modified file.

• function Open. Creates a new file.• function Close. Closes a file.

Attributes

• code: File of code generated.• next: Label of the next

instruction on the code file.• error: File of semantic errors.• top: Current (predicted) size

of run-time stack.• type: Type of subtree.

Used for type-checking.

Attributes (cont’d)

• ALL attributes are both synthesized and inherited.

• Convention:• a is the synthesized attribute a.• a is the inherited attribute a.

Synthesized and Inherited Attributes

S(program) = { code , error }I(program) = { }S(assign) = { code , next , error , top , type }I(assign) = { code , next , error , top }

• All other nodes:• Same synthesized and inherited

attributes as "assign".

Synthesized and Inherited Attributes • Most nodes have:

• Four inherited attributes (all except type ).

• All five synthesized attributes.

• One exception:• "program" node:

• no inherited attributes.• two synthesized attributes: code

and error .

Tree Walking Assumptions

• Top-down on the left,• Bottom-up on the right.

• Defaults:• If axiom is missing, assume

• no kids: a () = a ()• n kids:

•a (1) = a ()•a (i) = a (i-1), for 1 < i <= n•a () = a (n)

Tiny's Attribute Grammar

E → '<integer>:n'

code () = gen (code (), "lit", "n")next () = next () + 1top () = top () + 1type () = "integer"

Tiny's Attribute Grammar (cont’d)E → '<identifier:x>'

code () = gen (code (), "load", lookup("x"))

next () = next () + 1top () = top () + 1type () = "integer"error () = if lookup("x") = 0 then gen (error (), "identifier un-initialized") else error ()

Tiny's Attribute Grammar (cont’d)E → read

code () = gen (code (), "read")next () = next () + 1top () = top () + 1type () = "integer"

Tiny's Attribute Grammar (cont’d)E → < - E >

code () = gen (code (1), "negate")next () = next (1) + 1type () = "integer"error () = if type (1) = "integer" then error (1) else gen (error (1), “Illegal type for minus"))

Tiny's Attribute Grammar (cont’d)E → <not E >

code () = gen (code (1), “not")next () = next (1) + 1type () = “boolean"error () = if type (1) = “boolean" then error (1) else gen (error (1), "Illegal type for not")

Tiny's Attribute Grammar (cont’d)E → < + E E >

code () = gen (code (2), "add")next () = next (2) + 1top () = top (2) - 1type () = "integer"error () = if type (1)=type (2)= "integer" then error (2) else gen (error (2), "Illegal type for plus")

Tiny's Attribute Grammar (cont’d)E → < - E E >

code () = gen (code (2), “subtract")next () = next (2) + 1top () = top (2) - 1type () = "integer"error () = if type (1)=type (2)= "integer" then error (2) else gen (error (2), "Illegal type for minus")

Tiny's Attribute Grammar (cont’d)E → < = E E >

code () = gen (code (2), “equal")next () = next (2) + 1type () = “boolean"top () = top (2) - 1error () = if type (1) = type (2) then error (2) else gen (error (2), "Type clash in equal comparison")

Tiny's Attribute Grammar (cont’d)E → < output E >

code () = gen (code (1), “print")next () = next (1) + 1top () = top (1) - 1type () = “statement"error () = if type (1) = "integer" then error (1) else gen (error (1), "Illegal type for output")

Tiny's Attribute Grammar (cont’d)E → < assign '<identifier:x>' E >

code () = if lookup("x") = 0 then enter("x",top (2)); code (2) else gen (code (2), "save", lookup("x"))next () = if lookup("x") = 0 then next (2) else next (2) + 1

E → < assign '<identifier:x>' E >(cont’d)top () = if lookup ("x") = 0 then top (2) else top (2) - 1error () = if type (2) = "integer" then error (2)

else gen (error (2), "Assignment type clash")

type () = "statement"

Tiny's Attribute Grammar (cont’d)E -> < ; E* >

Use Defaults !

Tiny's Attribute Grammar (cont’d)E → < if E E E >

code (2) = gen (code (1),"iffalse", next (2) + 1)

next (2) = next (1) + 1top (2) = top (1) - 1code (3) = gen (code (2), "goto", next (3))next (3) = next (2) + 1error (2) = if type (1) = "boolean" then error (1) else gen (error (1), "Illegal expression for if")

E → < if E E E > (cont’d)

error (3) = if type (2) = "statement" then error (2) else gen (error (2), "Statement required for if")error () = if type (3) = "statement" then error (3) else gen (error (3), "Statement required for if")

Tiny's Attribute Grammar (cont’d)E → < while E E >

code (2) = gen (code (1), "iffalse", next (2) + 1)next (2) = next (1) + 1top (2) = top (1) - 1code () = gen (code (2), "goto", next ())next () = next (2) + 1type () = "statement"

E → < while E E > (cont’d)

error (2) = if type (1) = "boolean" then error (1) else gen (error (1),

"Illegal expression in while")error () = if type (2) = "statement"

then error (2) else gen (error (2),

"Statement required in while")

Tiny's Attribute Grammar (cont’d)Tiny → < program '<identifier:x>' E '<identifier:y>' >

code (2) = Openerror (2) = Opennext (2) = 1top (2) = 0code () = close (gen (code (2), "stop"))error () = close (if x = y then error (2) else gen (error (2), "program names don't match") )

An Attribute Grammar for Tiny

Prepared byManuel E. Bermúdez, Ph.D.

Associate ProfessorUniversity of Florida

Programming Language PrinciplesLecture 18