[PDF] Turtle Graphics - ezekiel

Language Translation for Turtle Graphics
CS 355
January 7, 2007
1. “Turtle Graphics” Language
(a) Simple (ambiguous) grammar
(b) Example turtle program:
program → stmt list
stmt list → stmt list stmt | stmt
stmt → assignment | action
assignment → IDENT ASSIGN expr
expr → expr + expr | expr − expr
→
→
expr ∗ expr | expr / expr
− expr | + expr
→ ( expr )
→
IDENT | REAL
action → HOME | PENUP | PENDOWN
angle := 60 # interior angle for hexagon
side := 100 # size of one side of hexagon
PENDOWN # begin drawing
FORWARD side
RIGHT angle
FORWARD side
RIGHT angle
FORWARD side
RIGHT angle
FORWARD side
RIGHT angle
FORWARD side
RIGHT angle
FORWARD side
RIGHT angle
PENUP # end drawing
(c) Lexical Elements
→
→
FORWARD expr | RIGHT expr | LEFT expr
PUSHSTATE | POPSTATE
comments: # ignore remainder of line
reserved words: HOME, PENUP, PENDOWN, FORWARD, RIGHT, LEFT, PUSHSTATE, POPSTATE
single character tokens: +,-,*,/,(,)
real numbers: REAL, regular expression: [0-9]+([\.][0-9]*)?
identifiers: IDENT, regular expression: [a-zA-Z\_][a-zA-Z0-9\_]*
1

2. Scanner
assignment operator: ASSIGN, :=
enum {REAL, IDENT, ASSIGN, HOME, PENUP, ..., POPSTATE}; /* token constants */
typedef union { /* hold’s "value" associated with certain tokens */
char *s; /* IDENT string */
float f; /* REAL value */
} LVAL;
int nextToken(LVAL *lval) { /* returns next token / value */
top:
eat whitespace;
if EOF return 0; /* no more tokens */
if next char a digit {
scan real number;
lval->f = convert string to number;
return REAL;
}
if next char alphabetic {
scan alphanumeric string;
if string is a reserved word
return reserved word token
else {
lval->s = string; /* allocate or reuse from "string pool" */
return IDENT;
}
}
if next char is ’:’ {
if next char not ’=’ error;
return ASSIGN;
}
if next char in {+, -, *, (, )}
return char;
if next char ’#’ {
eat chars to end of line;
goto top;
}
error;
}
2

3. Symbol Table
symtab
"side"
100
"angle"
60
symbolLookup(symbol) {
scan symtab for symbol;
if found
return symtab entry;
else {
insert (symbol, value=0) into table;
return newly created entry;
}
}
Note that we do not require variables to be declared before use. The first time a variable is referenced, it
is inserted into the symbol table with a value of 0.
4. Create unambiguous grammar using normal precedence and associativity rules.
expr → expr + term | expr − term | term
term → term ∗ factor | term / factor | factor
factor → − factor | + factor
→ ( expr )
→
• Note that grammar is left recursive.
IDENT | REAL
• If grammar had a dangling else problem, we would have to fix that too (we’ll add more to the language
later).
5. LL(k) parsing
• Goal is to produce a leftmost derivation.
• k is the number of tokens we can “look ahead” to predict which productions to apply.
• Top down approach : begin with start symbol and try to derive input string.
• Predictive : We predict which production to apply based on “look ahead” mechanism.
• LL(1) parsers may use a parse table:
– rows indexed by non-terminals
– columns indexed by terminals (i.e. tokens)
– each entry tells parses which production to apply based on the left-most non-terminal and the
look-ahead token.
• Recursive descent parser
– Each non-terminal is mapped to a subroutine.
– The right hand side (RHS) of the corresponding production dictates the body of the subroutine.
– Non-terminals on the RHS are mapped to (possible recursive or co-recursive) subroutine calls.
– Terminals on the RHS represent tokens that must be matched.
– For non-terminals that appear on the LHS of more than one production, the appropriate production
to use is predicted via the look-ahead mechasnism.
– LL(1) grammars are typically used.
3

– The grammar can not be left recursive.
6. Unambiguous, non-left-recursive grammar for Turtle Graphics
• $ is EOF marker
program → stmt list $
stmt list → stmt {stmt}
stmt → assignment | action
assignment → IDENT ASSIGN expr
expr → term {(+|−) term}
term → factor {(∗|/) factor}
factor → − factor | + factor | ( expr ) | IDENT | REAL
action → HOME | PENUP | PENDOWN
→
→
• {} is EBNF shorthand for “0 or more”
7. Turtle State
x,y : coordinates of turtle (initially x = y = 0)
dir : direction of turtle (initially 90 ◦ = north)
pendown : is pen down? (initially true)
8. Recursive descent parser for Turtle Graphics
FORWARD expr | RIGHT expr | LEFT expr
PUSHSTATE | POPSTATE
match(expected) {
if (lookahead = expected)
lookahead = nextToken(); /* fetch next token */
else
error();
}
program() {
stmt_list();
match(0);
}
stmt_list() {
do {
stmt();
} while (lookahead in {IDENT, HOME, ..., POPSTATE});
}
stmt() {
switch(lookahead) {
case IDENT: assignment(); break;
case HOME:
...
case POPSTATE: action(); break;
default: error();
}
}
assignment() {
4

}
symbol = symbolLookup(token value);
match(IDENT);
match(ASSIGN);
num = expr();
symbol->val = num;
float expr () {
n = term();
while (true)
switch(lookahead) {
case ’+’ : match(’+’); n += term(); break;
case ’-’ : match(’-’); n -= term(); break;
default: return n;
}
}
float term() {
n = factor();
while (true)
switch(lookahead) {
case ’*’ : match(’*’); n *= factor(); break;
case ’/’ : match(’/’); n /= factor(); break;
default: return n;
}
}
float factor() {
switch(lookahead) {
case ’-’: match(’-’); return -factor();
case ’+’: match(’+’); return factor();
case ’(’: match(’(’); n = expr(); match(’)’); return n;
case IDENT : return symbolLookup(value)->val;
case REAL : return val;
default: error();
}
}
action() {
switch(lookahead) {
case HOME: match(HOME); home(); break; /* place turtle in home state */
case PENUP: match(PENUP); turtle.pedown = false; break;
case PENDOWN: match(PENDOWN); turtle.pendown = true; break;
case FORWARD: match(FORWARD); moveForward(expr()); breal;
case RIGHT: match(RIGHT); turn(-expr()); break;
case LEFT: match(LEFT); turn(expr()); break;
case PUSHSTATE: match(PUSHSTATE); pushState(); break;
case POPSTATE: match(POPSTATE); popState(); break;
default: error();
}
}
home() {
turtle.x = turtle.y = 0;
turtle.dir = 90;
}
moveForward(dist) {
turtle.x += dist*cos(turtle.dir);
5

turtle.y += dist*sin(turtle.dir);
}
turn(angle) {
turtle.dir += angle;
while (turtle.dir >= 360) turtle.dir -= 360;
while (turtle.dir < 0) turtle.dir += 360;
}
9. LR(k) parsing
• Read input from left to right while constructing a rightmost derivation of the input stings using a
lookahead of k symbols. The concept of LR parsing was introduced by Donald Knuth in 1965.
• Bottom-up parsers
– Transfer symbols from input to the stack until the uppermost stack symbols match the right side
of a production. These symbols are replaced with the single variable from the left-hand side of the
production.
shift : transfer of token/value from input to stack;
reduce : matching uppermost stack symbols with the RHS of a production and replacing them
with the corresponding symbol on the LHS.
– Strings of terminals and variables on the stack are constantly being replaced with variables “higher”
in the grammar.
– Ultimately the entire stack collapses to the grammar’s start symbol.
• Parsing Turtle Graphics with YACC
– YACC (acronym for “Yet Another Compiler Compiler”) is a tool for building LALR(1) parsers.
– YACC processes an input file that contains:
∗ a list of tokens (i.e. terminals) and variables (i.e. non-terminals) in grammar;
∗ a grammar;
∗ and C code that specifies what to do (as a side effect) as the language is being parsed.
– The output of yacc is C source code for your parser, i.e. yacc creates a function yyparse() that
does the parsing.
– You provide a scanner function called yylex(). You can use a tool called LEX for this or “roll
your own.”
– Associated with each token and variable is a type. As tokens and variables are pushed onto the
stack (e.g. during a shift or reduce operation), an associated value of the appropriate type is also
placed on the stack. For each production in the grammar, we can specify how to combine old stack
values to create a new value for the variable on the left-hand side of the grammar.
– turtle.y
%{
#include
/* other includes and prototypes go here */
%}
%union { /* type for value associated with each token and variable */
float f;
char *s;
}
%token ASSIGN
%token IDENT /* IDENT associated with f field */
%token REAL
%token HOME PENUP PENDOWN FORWARD RIGHT LEFT PUSHSTATE POPSTATE
%type expr /* expr associated with d field */
%left ’+’ ’-’ /* precedence and associativity defined here */
%left ’*’ ’/’
6

%right UMINUS
%%
program : stmt_list {printState();}
;
stmt_list
stmt
: stmt_list stmt
| stmt
;
: assignment
| action
;
assignment : IDENT ASSIGN expr {symLookup($1)->val = $3;}
;
expr : ’-’ expr %prec UMINUS {$$ = -$2;}
| ’+’ expr %prec UMINUS {$$ = $2;}
| expr ’+’ expr {$$ = $1 + $3;}
| expr ’-’ expr {$$ = $1 - $3;}
| expr ’*’ expr {$$ = $1 * $3;}
| expr ’/’ expr {$$ = $1 / $3;}
| ’(’ expr ’)’ {$$ = $2;}
| IDENT {$$ = symLookup($1)->val;}
| REAL
;
action : HOME {home();}
| PENUP {penup();}
| PENDOWN {pendown();}
| FORWARD expr {forward($2);}
| RIGHT expr {left(-$2);}
| LEFT expr {left($2);}
| PUSHSTATE {pushstate();}
| POPSTATE {popstate();}
;
%%
int lineno;
char *filename;
void yyerror(char *msg) { /* called when syntax error encounted */
fprintf(stderr, "%s [%d] : %s\n", filename, lineno, msg);
exit(-1);
}
/* other helper C-code here */
7