4. Definición sintáctica del lenguaje de entrada.

programa → program id {AÑADIR_INST(‘prog’ || id.nom)}

declaraciones
decl_de_subprogs
begin
lista_de_sentencias
end ; {AÑADIR_INST(‘halt’)}

declaraciones → var lista_de_ident : tipo ; declaraciones

{AÑADIR_DECL (tipo.tdat, lista_de_ident.lista_id)}
|ε

lista_de_ident → id resto_lista_id {lista_de_ident.lista_id:=AÑADIR_ID (resto_lista_id.lista_id,

id.nom)}

resto_lista_id→ , id resto_lista_id {resto_lista_id.lista_id:=AÑADIR_ID(resto_lista_id1.lista_id,

id.nom)}
|Ɛ {resto_lista_id.lista_id:= lista_vacia()}

tipo → integer {tipo.tdat:=’int’}

| float {tipo.tdat:=’real’}

decl_de_subprogs → decl_de_subprograma decl_de_subprogs

|ε

decl_de_subprograma →
cabecera declaraciones
begin lista_de_sentencias end ; {AÑADIR_INST(‘finproc’)}

cabecera → procedure id argumentos {AÑADIR_INST(‘proc’||id.nom)}

argumentos → ( lista_de_param )
|ε

lista_de_param → lista_de_ident: clase_par tipo resto_lis_de_param

{AÑADIR_PARAM (lista_de_ident.lista_id, clase_par.tparam, tipo.tdat)}

clase_par →in clasepar’ {clase_par.tparam:=clase_par’.tparam}

| out {clase_par’.tparam:=’ref_’}

clase_par’ → out {clase_par’.tparam:=’ref_’}

|ε {clase_par’.tparam:=’val_’}

resto_lis_de_param → ; lista_de_ident: clase_par tipo resto_lis_de_param

{AÑADIR_PARAM (lista_de_ident.lista_id, clase_par.tparam, tipo.tdat)}
|ε

lista_de_sentencias →sentencia; lista_de_sentencias

{lista_de_sentencias.cont_lista:=UNIR (S.cont_lista, lista_de_sentencias1.cont_lista) ;}

|ε {lista_de_sentencias.cont_lista:= LISTA_VACIA();}
sentencia → variable = expresión_simple ;
| if expresion then M lista_de_sentencias end if M;
{COMPLETA(expresión.true,M 1.ref);
COMPLETA(expresión.false, M2.ref);
S.listaexit:=UNIR(lista_de_sentencias1.listaexit,lista_de_sentencias2.listaexit);}

| repeat M lista_de_sentencias until expresión end repeat; M

{ lista_de_sentencias.href=M1.ref;
COMPLETA(expresión.true,M 2.ref+1);
COMPLETA(expresion.false, M1.ref);
COMPLETA (lista_de_sentencias.listaexit, M1.ref+1);
S.listaexit:=LISTA_VACIA();}

| continue if expresión M ;
{COMPLETA (expresión.true, lista_de_sentencias.href);
COMPLETA (expresión.false, M.ref) ;}

| get (variable); {AÑADIR_INST (‘read’ || variable.nom)}

| put_line (expresion_simple); {AÑADIR_INST (‘write_’ || expresion_simple.nom);

AÑADIR_INST (‘writeln’) ;}

M→ε {M.ref:= obten_ref () ;}

variable →id {variable.nom:= id}

expresión → expresión_simple oprel expresión_simple

{expresión.true:= ini_lista (OBTEN_REF ());
AÑADIR_INST ('if' || expresión_simple1, nom || op_rel.tiporel || expresión_simple2.nom || ‘goto’);
expresión.false:= ini_lista (OBTEN_REF ());
AÑADIR_INST (‘goto’) ;}

oprel → == {oprel.tipo:= ‘== ‘}

| > {oprel.tipo:= ‘> ‘}
| < {oprel.tipo:= ‘<‘}
| >= {oprel.tipo:= ‘>= ‘}
| <= {oprel.tipo:= ‘<= ‘}

expresión_simple → término {expresión_simple’.hnom:=termino.nom}

| expresión_simple’ {expresión_simple.nom:=expresión_simple’.nom}

expresión_simple’ → + termino
{expresión_simple´1.nom=obtener_nuevo_id;
AÑADIR_INST(expresión_simple´1.hnom||”:=”|| expresión_simple´.hnom|| + || termino.nom)}
expresión_simple’ {expresión_simple´.nom=expresión_simple´1.hnom}

| - termino {expresión_simple´1.nom=obtener_nuevo_id;
AÑADIR_INST(expresión_simple´1.hnom||”:=”|| expresión_simple´.hnom|| - || termino.nom)}

expresión_simple’ {expresión_simple´.nom=expresión_simple´1.hnom}

| Ɛ { expresion_simple´.nom= expresión_simple´.hnom}

término → factor {termino’.hnom:=factor.nom}

término’ {termino.nom:=termino’.nom}

término’ → * factor
{termino’1.nom=obtener_nuevo_id;
AÑADIR_INST ( termino’1.hnom||”:=”||termino’.hnom||*||factor.nom)}

término’ {termino’.nom=termino´1.hnom}

| / factor
{termino’1.hnom:=obtener_nuevo_id;
AÑADIR_INST(termino’1.hnom||”:=”||termino’.hnom||/||factor.nom)}

término’ {termino’.nom:=termino´1.hnom}
| Ɛ {termino’.nom:=termino´.hnom}

factor → id {factor.nom:=id.nom}
| num_entero {factor.nom:=num_entero.nom}
| num_real {factor.nom:=num_real.nom}
| (expresión_simple) {factor.nom:=expresión_simple.nom}
Lista de atributos:

id.nom: es un atributo léxico que nos da el nombre del identificador “id”.

tipo.tdat: atributo léxico que nos dice el tipo de datos de una variable, puede ser “int” o “float”

op_rel.tiporel: atributo léxico que indica el tipo de una operación relacional, puede ser
“==”,”<”,”>”,”<=,”>=”.

clase_par.tparam: atributo léxico que indica si el parámetro de entrada del programa es “in”, “out” o
“in out”.

expresión.true: atributo lexico que nos dice si la expresion es verdadera.

expresión.false: atributo lexico que nos dice si la expresion es falsa.

variable.nom: atributo léxico que guarda el nombre de la variable.

termino.nom: atributo léxico que guarda el nombre del término

factor.nom: atributo léxico que guarda el nombre del factor

M.ref: atributo léxico en el que se guarda la dirección de referencia

lista_de_ident.lista_id: atributo sintetizado que guarda en una lista los identificadores que se leen del
programa.

resto_lista_de_ident.lista_id: atributo sintetizado que guarda en una lista los identificadores que se leen
del programa, lista auxiliar para el resto de la lista (hijos de un nodo del árbol)

lista_de_sentencias.lista_sent: atributo sintetizado que guarda en una lista las sentencias que se leen
del programa.

lista_de_sentencias.listaexit: atributo sintetizado

lista_de_sentencias.href: atributo heredado que indicara el punto de retorno para el continue

expresión_simple.hnom: atributo heredado

Lista de abstracciones funcionales:

AÑADIR_INST () → Añade la instrucción al código intermedio

AÑADIR_DECL () → Añade la declaración (tipo, lista de identificadores) al código intermedio
AÑADIR_ID () → Añade un nuevo identificador a la lista de identificadores
AÑADIR_PARAM () → Añade a la lista de identificadores un nuevo parámetro
UNIR () → Concatena dos listas
LISTA_VACIA ( ) → Crea una lista vacía
COMPLETA() → Añade la referencia a M (M.ref) en los casos true y false
OBTEN_REF () → Devuelve la referencia a una instrucción

εε