Proyecto 1
Agregar los siguientes operadores a Tiny, con la
precedencia y asociatividad indicada
Operador
Tipo
**
binario alta
derecha
-, +, not
unario
derecha
*, /, and, mod
binario
izquierda
+, -, or
binario
izquierda
<=, =, <>, >=, <, > binario
Prec Asociatividad
baja
ninguna
Proyecto 1
• Agregar las siguientes constantes a Tiny:
– true, false
• Agregar la siguiente función intrínseca a Tiny:
– eof
• Hacer que la cláusula else sea opcional.
• Permitir expresiones múltiples en la instrucción
output.
Proyecto 2
• Agregar la instrucción de intercambio: x:=:y
• Agregar la instrucción “repeat” a Tiny.
repeat
S1
...
Sn
E
L2(CL?) S1
S2
…
Sn
E
COND L1 L2
L1
• Constrainer: E debe ser booleano; processar S1 , … Sn
• Generador de Código: Hacer cascada con CurrLabel, S1, … Sn
Proyecto 2
Instrucción loop-pool con exit
loop
n=read;
if (n=0)then exit
else output(n);
pool;
loop
S1 ... Sn
exit
Constrainer:
En nodo ’program’: DTEnter(LOOP_CTXT,T,T)
En nodo ‘loop’:
-- Open_Scope;
-- DTEnter(LOOP_CTXT,T,T); // LOOP_CTXT es ‘<loop_ctxt>’
-- Procesar hijos;
-- Close_scope;
-- if (Decoration(T)=0) print (‘Warning: no ‘exit’)
En nodo ‘exit’:
-- Temp = Lookup(LOOP_CTXT);
-- if NodeName(Temp) <> LoopNode then Error
-- Decorate(T,Temp); Decorate(Temp,T);
Proyecto 2
Instrucción loop-pool con exit
loop
L1
n=read;
if (n=0)then exit
else output(n);
pool;
loop
S1
...
L2(CL?) S1
S2
…
Sn
GOTO L2
L1
Sn
Generador de Código:
En nodo ’loop’:
-- Decorate (T, L1=Makelabel);
-- Generar código (ver diagrama);
En nodo ‘exit’:
-- L1=Decoration(Decoration(T));
-- CodeGen1(GOTOOP, L1, Currlabel)
exit
GOTO L1
Proyecto 2: Instrucción ‘for’ de Pascal
(upto y downto)
Siguiente ‘for’
anidado
upto
for i := I to F do S
<id>
Constrainer:
i
I
F
S
No se
permite
exit
En node ‘program’ : DTEnter(FOR_CTXT, T);
En nodo ‘upto’:
Temp = Lookup(FOR_CTXT);
Decorate (T,Temp);
Open_scope;
DTEnter(FOR_CTXT,T);
DTEnter(LOOP_CTXT); // disallows “exit”
Procesar hijos // assumir que <id> tiene el tipo correcto.
while NodeName(Temp) != ProgramNode
// i debe ser distinto
if (NN(FK(FK(Temp)) = NN(FK(FK(T)) then Error // de todas las vcl’s de
Temp = Decoration(Temp)
// loops anidados
Close_scope;
Instrucción ‘for’ de Pascal (cont’d)
Siguiente ‘for’
anidado
upto
for i := I to F do S
<id>
i
I
F
S
Prohibir
assignación
a i!
Constrainer:
En nodo ‘assign’ :
Temp = Lookup(FOR_CTXT);
while NodeName(Temp) != ProgramNode
if (NN(FK(FK(Temp)) = NN(FK(FK(T)) then Error // x (izquierda de assign)
Temp = Decoration(Temp)
// no puede ser igual a la
// vcl de ningun ‘loop’
// anidado
Instrucción ‘for’ de Pascal (cont’d)
for i := I to F do S
upto
<id>
i
CodeGenerator:
I
F
S
CL F
I
ST i
L1 DUP
LD i
BOP BGE
COND L2 L3
L2 S
LD i
UNOP USUCC
ST i
GOTO L1
L3 POP 1
LIT 0
ST i
Generar código (duh, ver diagrama)
Recuerde: ProcessNode siempre devuelve una etiqueta
return Nolabel
Proyecto 2: Instrucción ‘case’
case v of
1..3: S1;
2: S2;
otherwise S3
end;
opcional
case
case_clause . . . case_clause
otherwise
E
CL1
S1
CLn
Sn
..
dos
posibilidades:
S
<integer>
o bien
Constrainer:
Assumir E está correcto,
comparar con los demás
<integer>
<integer>
n
l
u
CL E
CL1
COND L1 L2
L1 POP 1
S1
GOTO LE
L2 CL2
COND L3 L4
L3 POP 1
S2
GOTO LE
Instrucción ‘case’
case_clause . . . case_clause otherwise
E
...
Ln
L2n-1
L2n
CL1
CLn
COND L2n-1 L2n
POP 1
Sn
GOTO LE
POP 1
S
LE
con ‘otherwise’
OR
opcional
case
S1
CLn
Sn
L DUP
DUP
LIT l
BOP BGE
SWAP
Cada CLi es uno de LIT u
BOP BLE
estos dos
BOP BAND
L DUP
LIT n
BOP BEQ
L2n
LE
POP 1
sin ‘otherwise’
S
Descargar

Document