Date post: | 18-Jan-2018 |
Category: |
Documents |
Upload: | melinda-flynn |
View: | 222 times |
Download: | 0 times |
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