TEMA 6: ANÁLISIS SEMÁNTICO DE EXPRESIONES E INSTRUCCIONES EN L-0

Transcripción

1 TEMA 6: ANÁLISIS SEMÁNTICO DE EXPRESIONES E INSTRUCCIONES EN L-0 En este tema vamos a mostrar una estrategia para llevar a cabo, partiendo del ASA obtenido en el tema 4, el resto de comprobaciones semánticas (además de la resolución de nombres) a las que es necesario someter a L-0, y que son: comprobación de tipos, L/R value y otras comprobaciones semánticas. 1.- TIPOS Y EXPRESIONES El sistema de tipos de un lenguaje de programación suele constar de 5 componentes: (a) un conjunto de tipos predefinidos simples, (b) constructores de nuevos tipos a partir de los existentes, (c) reglas de equivalencia de tipos, (d) reglas de inferencia de tipo para expresiones y (e) reglas de compatibilidad de tipos. Estos componentes en L-0 presentan la siguiente forma: (a) Los tipos predefinidos simples en L-0 son: entero, real, logico, caracter. (b) Los constructores de nuevos tipos en L-0 se clasifican en: I. tipos predefinidos compuestos: formacion. II. tipos no predefinidos: clase. Los tipos predefinidos compuestos permiten construir nuevos tipos anónimos (tipos sin nombre). (c) Las reglas de equivalencia 1. Cuándo dos tipos son equivalentes? La respuesta a esta pregunta define lo que se denomina las reglas de equivalencia de tipos del lenguaje. La equivalencia de tipos se puede considerar desde dos puntos de vista: Equivalencia por Nombre: Se dice que dos tipos T y T son equivalentes por nombre sii el nombre de T coincide con el nombre de T. Equivalencia por Estructura: Se dice que dos tipos T y T son equivalentes por estructura sii T y T tienen definiciones con estructuras equivalentes. EJEMPLO: inst clase Elemento real e consultar() dev real 1 No debemos confundir la equivalencia de tipos con la compatibilidad de tipos, concepto este último que veremos posteriormente.

2 dev e modificar(real n) e:=consultar() inst clase Elemento oculto entero e consultar() dev entero dev e modificar(entero n) e:=n Las declaraciones anteriores en L-0 definen dos tipos equivalentes si se aplica equivalencia por nombre y dos tipos no equivalentes si se aplica equivalencia estructural. EJEMPLO : inst clase Elemento1 real e consultar() dev real dev e modificar(real n) e:=consultar() inst clase Elemento2 real e consultar() dev real dev e modificar(real n) e:=consultar() Las declaraciones anteriores en L-0 definen dos tipos equivalentes si se aplica equivalencia estructural o dos tipos no equivalentes si se aplica equivalencia por nombre.

3 Cada aproximación tiene pros y contras. La equivalencia por nombre tiene una implementación más simple porque sólo necesita comparar nombres para decidir si los tipos implicados son equivalentes. La equivalencia estructural requiere almacenar la estructura de los tipos para compararlos. L-0 dispone de tipos con nombres y de tipos anónimos. Al diseñar el sistema de tipos del lenguaje L-0, tomamos las siguientes decisiones: Dos tipos anónimos L-0 son equivalentes sii tienen la misma Estructura. Dos tipos con nombre L-0 son equivalentes sii tienen el mismo Nombre. (d) Las reglas para inferir el tipo 2 de una expresión en L-0 son: a. (Base) Si v es una variablelocal/parámetro/literal de tipo T entonces v es una expresión bien formada de tipo T. b. (Base) Si atr es un atributo visible de tipo T declarado en una clase C no instanciable entonces la expresión C.atr usada es una expresión bien formada de tipo T. c. (Base) Si atr es un atributo visible de tipo T declarado en una clase C instanciable entonces la expresión o.atr es una expresión bien formada de tipo T siendo o una instancia de C. d. (Base) Si atr es un atributo de tipo T declarado en una clase C entonces la expresión atr usada en la propia clase/objeto es una expresión bien formada de tipo T. e. (Inducción) Sean exp1,..., expk un conjunto de expresiones bien formadas de tipo ENTERO y t una expresión Base bien formada de tipo FORMACION de dimensión k y tipo base T, entonces t[exp1,...,expk] es una expresión bien formada de tipo T. f. (Inducción) Sean exp1,..., expk un conjunto de expresiones bien formadas de tipo T T1,...Tk respectivamente y f un método visible con dominio T1,...Tk y rango T declarado en una clase C no instanciable entonces C.f(exp1,...,expk) es una expresión bien formada de tipo T. g. (Inducción) Sean exp1,..., expk un conjunto de expresiones bien formadas de tipo T T1,...Tk respectivamente y f un método visible con dominio T1,...Tk y rango T declarado en una clase C instanciable entonces o.f(exp1,...,expk) es una expresión bien formada de tipo T siendo o una instancia de C. h. (Inducción) Sean exp1,..., expk un conjunto de expresiones bien formadas de tipo T T1,...Tk respectivamente y f un método con dominio T1,...Tk y rango T declarado en una clase C entonces f(exp1,...,expk) usada en la propia clase/objeto es una expresión bien formada de tipo T. i. (Inducción) Sean exp1,..., expk un conjunto de expresiones bien formadas de tipo T1,...Tk respectivamente y f una función definida en un tipo predefinido de L-0 con dominio T1,...,Tk y rango T entonces la expresión f(exp1,...,expk) es una expresión bien formada de tipo T. 2 Siempre teniendo en cuenta que en L-0 no se permiten referencias adelantadas.

4 El conjunto de reglas anteriores nos permite determinar el tipo y la corrección de las expresiones bases de L-0. Entendiendo por expresiones bases los accesos a variables (atributos, parámetros y variables locales), literales y llamadas a métodos. Sin embargo, también debemos dotar al sistema con el conjunto de reglas que nos permita inferir los tipos de expresiones compuestas, como las que incluyen operadores binarios y unarios. Puesto que una expresión compuesta involucra a más de una expresión (base o no), debemos establecer también un conjunto de reglas que nos especifique que tipos pueden combinarse mediante un operador (compatibilidad de tipos). (e) Las reglas de compatibilidad. Cuándo dos tipos son compatibles? La pregunta está mal planteada, ya que dos tipos pueden ser compatibles cuando se combinan con un operador e incompatibles con otro. La compatibilidad de tipos siempre se hace respecto a los operadores y depende de la definición del lenguaje. En L-0 la regla de compatibilidad es muy simple, ya que L-0 no acepta coerciones de tipos, es decir, los tipos de las expresiones que forman una expresión compuesta deben ser equivalentes. Hay que decir que L-0 presenta un tipado estático (la inferencia y chequeo de tipos se realiza en tiempo de compilación) y fuerte (toda expresión bien formada tiene un único tipo). Ejercicio.- Partiendo del ejemplo del capítulo anterior, vamos a calcular tipos de distintas expresiones: p, p.apilar y p.apilar(i). (Solución en clase) 2.- EVALUACIÓN L/R EN LAS ASIGNACIONES La asignación es la instrucción fundamental de cualquier lenguaje de programación imperativo con la siguiente semántica informal: expresion de tipo T + lugar de almacenamiento := expresion de tipo T Adoptamos dos visiones diferentes al evaluar las expresiones situadas a izquierda y a la derecha del símbolo :=. La evaluación a de la parte izquierda produce lugares de almacenamiento (Lvalues) y la evaluación de la parte derecha produce valores funcionales clásicos (R-values). Desde el punto de vista sintáctico no hay diferencias entre la expresión de la izquierda y la expresión de la derecha. Por ejemplo, sean x e y variables enteras y la asignación x := y está compuesta de una expresión a la izquierda de tipo entero y una expresión a la derecha de tipo entero. Sin embargo, y adicionalmente, la expresión a la izquierda denota un L-value, es decir, un lugar donde ubicar el valor producido por la evaluación de la expresión y (R-value). Por ejemplo, la siguiente asignación sería incorrecta 1 := y aunque las expresiones a la izquierda y derecha concuerden en tipo porque 1 no denota lugar de almacenamiento. Concluyendo, para que una asignación sea correcta desde un punto de vista semántico debe ocurrir que las expresiones a izquierda y derecha coincidan en tipo y además que la expresión

5 de la izquierda denote un lugar para almacenar. Por lo tanto, al procesar asignaciones en L-0 es necesario realizar no sólo un test de equivalencia de tipos entre las expresiones a la izquierda y derecha del símbolo := sino un test para decidir si la expresión a la izquierda es un atributo (visible) o variable local. 3.- TREEPARSER PARA EL ANÁLISIS SEMÁNTICO EN L-0 En este apartado nos vamos a limitar a mostrar el treeparser para el análisis semántico de L-0. En las siguientes secciones describiremos tantos las estructuras de datos usadas como las funciones auxiliares. header... class AnaSem extends TreeParser options buildast=true int cont_dev // variable contador del número de instrucciones DEV en un método // Incluir todas las funciones de Análisis Semántico declaracion_modulo: #(MODULO nombre_modulo definicion_modulo) nombre_modulo : IDENT definicion_modulo: lista_declaraciones_clases lista_declaraciones_clases: (declaracion_clase)* declaracion_clase : #(CLASE nombre_clase cualificador_clase definicion_clase) cualificador_clase : INST NO_INST nombre_clase : IDENT definicion_clase : declaraciones_elementos_clase declaraciones_elementos_clase : (declaracion_elemento_clase)* declaracion_elemento_clase : #(METODO declaracion_metodo cualificador_elemento_clase) #(ATRIBUTO IDENT tipo cualificador_elemento_clase) cualificador_elemento_clase: OCULTO VISIBLE declaracion_metodo AST tipodev : tipodev =prototipo_metodo definicion_metodo[tipodev] if (cont_dev == 0)

6 error // método funcional que no devuelve nada prototipo_metodo returns [AST tipodev]: #(PROTOTIPO IDENT #(PARAMETROS declaracion_parametros) #(RESULTADO ( t: tipo cont_dev = 0 // inicializa el contador de instrucciones DEV tipodev = t v: VACIO cont_dev = -1 // marca a -1 para indicar que es un procedimiento tipodev = v ))) declaracion_parametros : (declaracion_parametro)* declaracion_parametro : #(PARAMETRO IDENT tipo) definicion_metodo [AST tipodev]: #(DEFINICION #(VARIABLES_LOCALES declaracion_variables_locales) #(INSTRUCCIONES instrucciones[tipodev]) declaracion_variables_locales : (declaracion_variable_local)* declaracion_variable_local : #(VARIABLE_LOCAL IDENT tipo) instrucciones [AST tipodev] : (instrucción[tipodev])* instruccion [AST tipodev] : #(INSTRUCCION ( instruccion_simple[tipodev] instruccion_compuesta[tipodev]) instruccion_simple [AST tipodev] : llamada_metodo asignacion retorno [tipodev] instruccion_compuesta [AST tipodev] : condicion [tipodev] iteracion [tipodev] asignacion Atr_Expr e1, e2: #(ASIGNACION e1=expresion e2=expresion ) AS_Asignacion(e1,e2) retorno [AST tipodev] Atr_Expr e: #(DEV e=expresion) cont_dev=as_devolucion( tipodev, e, cont_dev) llamada_metodo Atr_Expr a, res LinkedList l: #(LLAMADA a=acceso #(EXPRESIONES l=lista_expresiones)) res=as_llamada( a, l) if (res.gettipo().gettype()!= VACIO) error // No es un procedimiento lista_expresiones returns [LinkedList l= new LinkedList()] Atr_Expr e: (e=expresion l.add(e))*

7 condicion [AST tipodev] Atr_Expr e : #(SI e=expresion #(INSTRUCCIONES instrucciones[tipodev]) #(INSTRUCCIONES instrucciones[tipodev])) AS_Condicion( e) iteracion [AST tipodev] Atr_Expr e : #(MIENTRAS e=expresion #(INSTRUCCIONES instrucciones[tipodev])) AS_Condicion( e) expresion returns [Atr_Expr res] Atr_Expr e1,e2 LinkedList l: #(O e1=expresion e2=expresion) res=as_exp_bin_log( e1, e2) #(Y e1=expresion e2=expresion) res=as_exp_bin_log( e1, e2) #(NO e1=expresion) res=as_exp_una_log( e1) #(MAYOR e1=expresion e2=expresion) res=as_exp_bin_rel( e1, e2) #(MAYOR_IGUAL e1=expresion e2=expresion) res=as_exp_bin_rel( e1, e2) #(MENOR e1=expresion e2=expresion) res=as_exp_bin_rel( e1, e2) #(MENOR_IGUAL e1=expresion e2=expresion) res=as_exp_bin_rel( e1, e2) #(IGUAL e1=expresion e2=expresion) res=as_exp_bin_rel( e1, e2) #(DISTINTO e1=expresion e2=expresion) res=as_exp_bin_rel( e1, e2) #(MAS e1=expresion e2=expresion) res=as_exp_bin_arit( e1, e2) #(MENOS e1=expresion e2=expresion) res=as_exp_bin_arit( e1, e2) #(MENOSUNARIO e1=expresion) res=as_exp_una_arit( e1) #(POR e1=expresion e2=expresion) res=as_exp_bin_arit( e1, e2) #(DIVISION e1=expresion e2=expresion) res=as_exp_bin_arit( e1, e2) #(LLAMADA e1=acceso #(EXPRESIONES l=lista_expresiones)) res=as_llamada( e1, l) if (res.gettipo().gettype() == VACIO) error // No es un método funcional #(ACCESO_TABLA e1=acceso #(EXPRESIONES l=lista_expresiones_nv)) res=as_acceso_tabla( e1, l) e1=acceso res=e1 i:lit_entero res=as_literal( i) j:lit_real res=as_literal( j) k:lit_car res=as_literal( k) m:cierto res=as_literal( m) n:falso res=as_literal( n) acceso returns [Atr_Expr res] Atr_Expr e: e=acceso_simple res=e #(ACCESO_OBJETO r:e=acceso_simple a:ident) res=as_acceso_objeto( e, r, a) acceso_simple returns [Atr_Expr res]: #(ACCESO_SIMPLE IDENT d:declaracion_acceso) res=as_acceso_simple(d) declaracion_acceso: declaracion_modulo declaracion_clase_1 declaracion_elemento_clase_1 declaracion_parametro_1 declaracion_variable_local_1

8 lista_expresiones_nv returns [LinkedList l= new LinkedList()] Atr_Expr e: (e=expresion l.add(e))+ tipo : tipo_predefinido_simple tipo_predefinido_compuesto declaracion_clase_1 tipo_predefinido_simple : ENTERO REAL LOGICO CARACTER tipo_predefinido_compuesto : formacion formacion : #(FORMACION #(LlSTA_ENTEROS lista_enteros) (tipo_predefinido_simple declaracion_clase_1)) lista_enteros : (LIT_ENTERO)+ // DECLARACION DE CLASES EN ACCESOS SIMPLES E IDENTIFICADORES DE TIPO. NO ES NECESARIO EL ANÁLISIS SEMÁNTICO EN ESTOS ÁRBOLES. declaracion_clase_1 : #(CLASE nombre_clase_1 cualificador_clase_1 definicion_clase_1) cualificador_clase_1 : INST NO_INST nombre_clase_1 : IDENT definicion_clase_! : declaraciones_elementos_clase_1 declaraciones_elementos_clase_1 : (declaracion_elemento_clase_1)* declaracion_elemento_clase_1 : #(METODO declaracion_metodo_1 cualificador_elemento_clase_1) #(ATRIBUTO IDENT tipo_1 cualificador_elemento_clase_1) cualificador_elemento_clase_1: OCULTO VISIBLE declaracion_metodo_1: prototipo_metodo_1 definicion_metodo_1 prototipo_metodo_1: #(PROTOTIPO IDENT #(PARAMETROS declaracion_parametros_1) #(RESULTADO ( tipo_1 VACIO_1))) declaracion_parametros_1 : (declaracion_parametro_1)*

9 declaracion_parametro_1 : #(PARAMETRO IDENT tipo_1) definicion_metodo_1: #(DEFINICION #(VARIABLES_LOCALES declaracion_variables_locales_1) #(INSTRUCCIONES instrucciones_1) declaracion_variables_locales_1 : (declaracion_variable_local_!)* declaracion_variable_local_1 : #(VARIABLE_LOCAL IDENT tipo_1) instrucciones_1: (instrucción_1)* instruccion_1 : #(INSTRUCCION ( instruccion_simple_1 instruccion_compuesta_1) instruccion_simple_1 : llamada_metodo_1 asignacion_1 retorno_1 instruccion_compuesta_1 : condicion_1 iteracion_1 asignacion_1: #(ASIGNACION expresion_1 expresion_1 ) retorno_1: #(DEV expresion_1) llamada_metodo_1: #(LLAMADA acceso_1 #(EXPRESIONES lista_expresiones_1)) lista_expresiones_1: (expresion_1)* condicion_1 : #(SI expresion_1 #(INSTRUCCIONES instrucciones_1) #(INSTRUCCIONES instrucciones_1)) iteracion_1: #(MIENTRAS expresion_1 #(INSTRUCCIONES instrucciones_1)) expresion_1: #(O expresion_1 expresion_1) #(Y expresion_1 expresion_1) #(NO expresion_1) #(MAYOR expresion_1 expresion_1) #(MAYOR_IGUAL expresion_1 expresion_1) #(MENOR expresion_1 expresion_1) #(MENOR_IGUAL expresion_1 expresion_1) #(IGUAL expresion_1 expresion_1) #(DISTINTO expresion_1 expresion_1) #(MAS expresion_1 expresion_1) #(MENOS expresion_1 expresion_1) #(MENOSUNARIO expresion_1) #(POR expresion_1 expresion_1)

10 #(DIVISION expresion_1 expresion_1) #(LLAMADA acceso_1 #(EXPRESIONES lista_expresiones_1)) #(ACCESO_TABLA acceso_1 #(EXPRESIONES lista_expresiones_nv_1)) acceso_1 LIT_ENTERO LIT_REAL LIT_CAR CIERTO FALSO acceso_1: acceso_simple_1 #(ACCESO_OBJETO acceso_simple_1 IDENT) acceso_simple_1: #(ACCESO_SIMPLE IDENT declaracion_acceso_1) declaracion_acceso_1: declaracion_clase_1 declaracion_elemento_clase_1 declaracion_parametro_1 declaracion_variable_local_1 lista_expresiones_nv_1: (expresion )+ tipo_1 : tipo_predefinido_simple_1 tipo_predefinido_compuesto_1 declaracion_clase_1 tipo_predefinido_simple_1 : ENTERO REAL LOGICO CARACTER tipo_predefinido_compuesto_1 : formacion_1 formacion_1 : #(FORMACION #(LlSTA_ENTEROS lista_enteros_1) (tipo_predefinido_simple_1 declaracion_clase_1)) lista_enteros_1 : (LIT_ENTERO)+ 4.- ESTRUCTURA DE DATOS Vamos a usar una clase, a la que denominaremos Atr_Expr, para almacenar la información del tipo, L-val y R-val de cada expresión que aparezca en el programa. La información del tipo es necesaria para realizar las comprobaciones de tipos en los distintos contextos, y las

11 características de L-val y R-val son requeridas si la expresión se encuentra dentro del ámbito de una asignación. Veamos los atributos métodos de esta clase. Atr_Expr.- Atributos: o tipo (AST) AST del tipo de la expresión. o Lval (boolean) Indica la expresión tiene L-value. o Rval (boolean) Indica si la expresión tiene R-value. Métodos: o Atr_Expr() Constructor de la clase vacía. o AST gettipo() Devuelve el AST del tipo de la expresión. o boolean getlval() Devuelve el valor del atributo LVal. o boolean getrval() Devuelve el valor del atributo RVal. o settipo(ast tipo) Establece el AST del tipo de la expresión. o setlval(boolean lval) Establece el valor del atributo LVal. o setrval(boolean rval) Establece el valor del atributo RVal. 5.- FUNCIONES PARA EL ANÁLISIS SEMÁNTICO DE LAS EXPRESIONES EN L ANÁLISIS SEMÁNTICO DE LOS LITERALES Esta rutina se limita a calcular el tipo, Lval y Rval de los literales (entero, real, carácter y lógico) que aparezcan. Atr_Expr As_Literal(AST lit) Atr_Expr result=new Atr_Expr() AST tipo=null switch(lit.gettype()) case LIT_ENTERO: tipo=#(#[entero,"entero"]) break case LIT_REAL: tipo=#(#[real,"real"]) break case LIT_CAR: tipo=#(#[caracter,"caracter"]) break case CIERTO: case FALSO: tipo=#(#[logico,"logico"]) break result.settipo(tipo) result.setlval(false) result.setrval(true) return result ANÁLISIS SEMÁNTICO DE LOS ACCESOS SIMPLES

12 Esta función calcula el tipo, Lval y Rval de los accesos simples en función de la declaración que se le asoció en la etapa de resolución de nombres. Recibe como parámetro el árbol de declaración de acceso simple. Atr_Expr As_Acceso_Simple(AST dec) Atr_Expr result=new Atr_Expr() AST tipo=null switch(dec.gettype()) case MODULO: System.out.println("ERROR ) break case CLASE: tipo=dec result.setlval(false) result.setrval(false) break case ATRIBUTO: tipo=dec.getfirstchild().getnextsibling() result.setlval(true) result.setrval(true) break case METODO: tipo=dec.getfirstchild() result.setlval(false) result.setrval(false) break case PARAMETRO: tipo=dec.getfirstchild().getnextsibling() result.setlval(false) result.setrval(true) break case VARIABLE_LOCAL: tipo=dec.getfirstchild().getnextsibling() result.setlval(true) result.setrval(true) break result.settipo(tipo) return result ANÁLISIS SEMÁNTICO DE LOS ACCESOS A OBJETOS La estructura sintáctica de un acceso a objeto es la siguiente: raiz. atrib En el ASA de la expresión, raiz es un acceso simple (cuyo Atr_Expr se ha calculado con al función del apartado anterior) y atrib es un nodo IDENT.

13 La función que lleva a cabo el análisis semántico de los accesos a objeto, al igual que todas las rutinas de análisis semántico de expresiones, calcula el tipo, Lval y Rval de la expresión. Pero además realiza otros chequeos semánticos. Esta función hace lo siguiente: 1. Comprobar que la expresión raiz sea de tipo clase. 2. Si la raiz es una clase, entonces se debe comprobar que sea no instanciable. Si la raiz es un objeto, entonces se debe comprobar que sea de una clase instanciable. 3. Comprobar que atrib es un atributo/método visible del tipo clase de la raiz. 4. Resultado (Atr_Expr que devuelve la función): Si atrib es un atributo: el tipo es el tipo del atributo, Lval y Rval son true. Si atrib es un método: el tipo es el prototipo del método, Lval y Rval son false. Recibe los siguientes parámetros: Atr_Expr de la raiz (necesario para 1,2,3 y 4), AST de la raiz (necesario para 2) y el AST del atrib (necesario para 3). Atr_Expr As_Acceso_Objeto(Atr_Expr atrraiz, AST raiz, AST atrib) Atr_Expr result=new Atr_Expr() AST tiporaiz, aux, tipo // 1 tiporaiz=atrraiz.gettipo() if (tiporaiz.gettype()!= CLASE) System.out.println("ERROR ") // 2 If (raiz.getfirstchild().getnextsibling().gettype() == CLASE) if (tiporaiz.getfirstchild().getnextsibling().gettype()!= NO_INST) System.out.println("ERROR ) else if (tiporaiz.getfirstchild().getnextsibling().gettype()!= INST) System.out.println("ERROR ) // 3 aux = tiporaiz.getfirstchild().getnextsibling().getnextsibling() while(aux!= null) if (aux.gettype() == METODO) if(aux.getfirstchild().getfirstchild().equals(atrib)) break else if(aux.getfirstchild().equals(atrib)) break aux = aux.getnextsibling() if(aux==null)

14 System.out.println("ERROR ") if(aux.getfirstchild().getnextsibling().getnextsibling().gettype()!= VISIBLE) System.out.println("ERROR ") // 4 if(aux.gettype()==atributo) tipo=aux.getfirstchild().getnextsibling() result.setlval(true) result.setrval(true) else tipo=aux.getfirstchild() result.setlval(false) result.setrval(false) result.settipo(tipo) return result ANÁLISIS SEMÁNTICO DE LLAMADAS A MÉTODOS La estructura sintáctica de una llamada a un método es la siguiente: raiz ( expresiones ) En el ASA de la expresión, raiz es un acceso simple o un acceso a objeto (cuyo Atr_Expr se ha calculado con alguna de las funciones de los apartados anteriores) y expresiones es una lista de expresiones (cuyos Atr_Expr están calculados y almacenados en una LinkedList durante el treeparser). Esta función hace lo siguiente: 1. Comprobar que la expresión raiz sea de tipo método (prototipo). 2. Comprobar que los parámetros formales (descritos en el prototipo del método) coinciden en número y tipo con los parámetros reales ( expresiones ). 3. Resultado (Atr_Expr que devuelve la función): El tipo es el rango del método, Lval es false y Rval es true. Recibe los siguientes parámetros: Atr_Expr de la raiz (necesario para 1,2 y 3), LinkedList con los Atr_Expr de todos los parámetros reales (necesario para 2). Atr_Expr As_Llamada(Atr_Expr atr_raiz, LinkedList expresiones) Atr_Expr res=new Atr_Expr() Atr_Expr par_r AST par_f Iterator it=expresiones.iterator() // 1

15 if(atr_raiz.gettipo().gettype()!=prototipo) System.out.println("ERROR ") // 2 par_f=atr_raiz.gettipo().getfirstchild().getnextsibling().getfirstchild() while(par_f!= null && it.hasnext()) par_r=(atr_expr) it.next() if(!par_r.gettipo().equalstree(par_f.getfirstchild().getnextsibling())) System.out.println("ERROR ") par_f=par_f.getnextsibling() if(par_f == null && it.hasnext()) System.out.println("ERROR ") if(par_f!= null &&! it.hasnext()) System.out.println("ERROR ") // 3 res.settipo(atr_raiz.gettipo().getfirstchild().getnextsibling().getnextsibling().getfirstchild()) res.setlval(false) res.setrval(true) return res ANÁLISIS SEMÁNTICO DE LOS ACCESOS A TABLAS La estructura sintáctica de un acceso a tabla es la siguiente: raiz [ expresiones ] En el ASA de la expresión, raiz es un acceso simple o un acceso a objeto (cuyo Atr_Expr se ha calculado con alguna de las funciones de los apartados anteriores) y expresiones es una lista de expresiones (cuyos Atr_Expr están calculados y almacenados en una LinkedList durante el treeparser). Esta función hace lo siguiente: 1. Comprobar que la expresión raiz sea de tipo formación. 2. Comprobar que las expresiones son de tipo entero y que coinciden en número con las dimensiones de la formación. 3. Resultado (Atr_Expr que devuelve la función): El tipo es el tipo base de la formación, Lval y Rval lo heredan de la raiz. Recibe los siguientes parámetros: Atr_Expr de la raiz (necesario para 1,2 y 3), LinkedList con los Atr_Expr de todas las expresiones (necesario para 2). Atr_Expr As_Acceso_Tabla(Atr_Expr atr_raiz, LinkedList expresiones) Atr_Expr res=new Atr_Expr() Atr_Expr aux Iterator it=expresiones.iterator()

16 // 1 if(atr_raiz.gettipo().gettype()!=formacion) System.out.println("ERROR ") // 2 while(it.hasnext()) aux=(atr_expr) it.next() if(aux.gettipo().gettype()!= ENTERO) System.out.println("ERROR ") if(expresiones.size()!= atr_raiz.gettipo().getfirstchild().getnumberofchildren()) System.out.println("ERROR ") // 3 res.settipo(atr_raiz.gettipo().getfirstchild().getnextsibling()) res.setlval(atr_raiz.getlva()) res.setrval(atr_raiz.getrval()) return res ANÁLISIS SEMÁNTICO DE LAS EXPRESIONES BINARIAS ARITMÉTICAS La estructura sintáctica de una expresión binaria aritmética es la siguiente: expresion1 operador_aritmético expresion2 En el ASA de la expresión, expresion1 y expresion2 son expresiones bien formadas de L-0 (cuyos Atr_Expr se han calculado durante el treeparser). Esta función hace lo siguiente: 1. Comprobar que expresion1 y expresion2 tienen Rval. 2. Comprobar que los tipos de expresion1 y expresion2 son compatibles respecto al operador binario aritmético (en L-0 habría que comprobar la equivalencia de tipos de ambas expresiones). Además hay que comprobar que tanto expresion1 como expresion2 sean de tipo numérico (entero o real). 3. Resultado (Atr_Expr que devuelve la función): El tipo es el tipo de expresion1 o expresion2, Lval es false y Rval es true. Recibe los siguientes parámetros: Atr_Expr de los dos operandos (necesarios para 1,2 y 3). Atr_Expr As_Exp_Bin_Arit(Atr_Expr e1,atr_expr e2) Atr_Expr res=new Atr_Expr() // 1 if(!e1.getrval()!e2.getrval()) System.out.println("ERROR")

17 // 2 if(!e1.gettipo().equals(e2.gettipo())) System.out.println("ERROR") if(e1.gettipo().gettype()!= ENTERO && e1.gettipo().gettype()!= REAL) System.out.println("ERROR") // 3 res.settipo(e1.gettipo()) res.setlval(false) res.setrval(true) return res ANÁLISIS SEMÁNTICO DE LAS EXPRESIONES BINARIAS LÓGICAS La estructura sintáctica de una expresión binaria lógica es la siguiente: expresion1 operador_lógico expresion2 En el ASA de la expresión, expresion1 y expresion2 son expresiones bien formadas de L-0 (cuyos Atr_Expr se han calculado durante el treeparser). Esta función hace lo siguiente: 1. Comprobar que expresion1 y expresion2 tienen Rval. 2. Comprobar que los tipos de expresion1 y expresion2 son compatibles respecto al operador binario lógico (en L-0 habría que comprobar que los tipos de ambas expresiones sean lógicos). 3. Resultado (Atr_Expr que devuelve la función): El tipo es el tipo de expresion1 o expresion2, Lval es false y Rval es true. Recibe los siguientes parámetros: Atr_Expr de los dos operandos (necesarios para 1,2 y 3). Atr_Expr As_Exp_Bin_Log (Atr_Expr e1,atr_expr e2) Atr_Expr res=new Atr_Expr() // 1 if(!e1.getrval()!e2.getrval()) System.out.println("ERROR") // 2 if(e1.gettipo().gettype()!= LOGICO e2.gettipo().gettype()!= LOGICO) System.out.println("ERROR") // 3 res.settipo(e1.gettipo()) res.setlval(false) res.setrval(true) return res

18 5.8.- ANÁLISIS SEMÁNTICO DE LAS EXPRESIONES BINARIAS RELACIONALES La estructura sintáctica de una expresión binaria relacional es la siguiente: expresion1 operador_relacional expresion2 En el ASA de la expresión, expresion1 y expresion2 son expresiones bien formadas de L-0 (cuyos Atr_Expr se han calculado durante el treeparser). Esta función hace lo siguiente: 1. Comprobar que expresion1 y expresion2 tienen Rval. 2. Comprobar que los tipos de expresion1 y expresion2 son compatibles respecto al operador binario relacional (en L-0 habría que comprobar la equivalencia de tipos de ambas expresiones). 3. Comprobar que si los operandos son de tipo clase, lógico o formación, el operador que se aplica sea igual o distinto. 4. Resultado (Atr_Expr que devuelve la función): El tipo es lógico, Lval es false y Rval es true. Recibe los siguientes parámetros: Atr_Expr de los dos operandos (necesarios para 1,2, 3 y 4) y el AST del operador_relacional (necesario para 3). Atr_Expr As_Exp_Bin_Rel (Atr_Expr e1,atr_expr e2, AST op) Atr_Expr res=new Atr_Expr() AST tipo // 1 if(!e1.getrval()!e2.getrval()) System.out.println("ERROR") // 2 if(! e1.gettipo().equalstree(e2.gettipo())) System.out.println("ERROR") // 3 if ((e1.gettipo().gettype() == CLASE e1.gettipo().gettype() == LOGICO e1.gettipo().gettype() == FORMACION) && (op.gettype()!= IGUAL && op.gettype()!= DISTINTO) ) System.out.println("ERROR") // 4 tipo = #(#[LOGICO,"logico"]) res.settipo(tipo) res.setlval(false) res.setrval(true) return res

19 5.9.- ANÁLISIS SEMÁNTICO DE LAS EXPRESIONES UNARIAS ARITMÉTICAS La estructura sintáctica de una expresión unaria aritmética es la siguiente: operador_aritmético expresion En el ASA de la expresión, expresion es una expresión bien formada de L-0 (cuyo Atr_Expr se ha calculado durante el treeparser). Esta función hace lo siguiente: 1. Comprobar que expresion tiene Rval. 2. Comprobar que el tipo de expresión es compatible respecto al operador unario aritmético (en L-0 habría que comprobar que sea de tipo numérico). 3. Resultado (Atr_Expr que devuelve la función): El tipo es el tipo de expresion, Lval es false y Rval es true. Recibe el siguiente parámetro: Atr_Expr del operando (necesario para 1,2 y 3). Atr_Expr As_Exp_Una_Arit( Atr_Expr e) Atr_Expr res=new Atr_Expr() // 1 if(!e.getrval()) System.out.println("ERROR") // 2 if(e.gettipo().gettype()!= ENTERO && e.gettipo().gettype()!= REAL) System.out.println("ERROR") // 3 res.settipo(e.gettipo()) res.setlval(false) res.setrval(true) return res ANÁLISIS SEMÁNTICO DE LAS EXPRESIONES UNARIAS LÓGICAS La estructura sintáctica de una expresión unaria lógica es la siguiente: operador_unario expresion En el ASA de la expresión, expresion es una expresión bien formada de L-0 (cuyo Atr_Expr se ha calculado durante el treeparser). Esta función hace lo siguiente:

20 1. Comprobar que expresion tiene Rval. 2. Comprobar que el tipo de expresión es compatible respecto al operador unario lógico (en L-0 habría que comprobar que sea de tipo lógico). 3. Resultado (Atr_Expr que devuelve la función): El tipo es lógico, Lval es false y Rval es true. Recibe el siguiente parámetro: Atr_Expr del operando (necesario para 1,2 y 3). Atr_Expr As_Exp_Una_Log( Atr_Expr e) Atr_Expr res=new Atr_Expr() // 1 if(!e.getrval()) System.out.println("ERROR") // 2 if(e.gettipo().gettype()!= LOGICO) System.out.println("ERROR") // 3 res.settipo(e.gettipo()) res.setlval(false) res.setrval(true) return res 6.- FUNCIONES PARA EL ANÁLISIS SEMÁNTICO DE LAS INSTRUCCIONES EN L ANÁLISIS SEMÁNTICO DE LA ASIGNACIÓN La estructura sintáctica de una instrucción asignación es la siguiente: expresion1 ASIGNACION expresion2 En el ASA de la instrucción, expresion1 y expresion2 son expresiones bien formadas de L-0 (cuyos Atr_Expr se han calculado durante el treeparser). Esta función hace lo siguiente: 1. Comprobar que expresion1 tiene Lval. 2. Comprobar que expresion2 tiene Rval. 3. Comprobar que los tipos de expresion1 y expresion2 son equivalentes. Recibe los siguientes parámetros: Atr_Expr de los dos operandos (necesarios para 1,2, 3). void AS_Asignacion (Atr_Expr e1,atr_expr e2)

21 // 1 y 2 if(!e1.getlval()!e2.getrval()) System.out.println("ERROR") // 3 if(! e1.gettipo().equals(e2.gettipo())) System.out.println("ERROR") if(e1.gettipo().gettype() == FORMACION &&! e1.gettipo().equalstree(e2.gettipo())) System.out.println("ERROR") if(e1.gettipo().gettype() == CLASE &&! e1.gettipo()..getfirstchild(). equals(e2.gettipo().getfirstchild())) System.out.println("ERROR") ANÁLISIS SEMÁNTICO DE LA ITERACIÓN Y CONDICIONAL Esta función se limita a comprobar que la condición de un bucle o condicional es una expresión que tiene Rval y es de tipo Lógico. Su implementación es la siguiente: void AS_Condicion (Atr_Expr e) if(!e.getrval()) System.out.println("ERROR") if(e.gettipo().gettype() == LOGICO) System.out.println("ERROR") ANÁLISIS SEMÁNTICO DE LA DEVOLUCIÓN La estructura sintáctica de una instrucción devolución es la siguiente: DEV expresion En el ASA de la instrucción, expresión es una expresión bien formada de L-0 (cuyo Atr_Expr se ha calculado durante el treeparser). Esta función hace lo siguiente: 1. Comprobar que el método que incluye la instrucción sea un método funcional. 2. Comprobar que expresion tiene Rval. 3. Comprobar que el rango del método sea equivalente al tipo de expresión 4. Incrementa el contador de instrucciones de devolución del método y lo devuelve.

22 Recibe los siguientes parámetros: AST del rango del método (necesario para 3), Atr_Expr de la expresión (necesario para 2 y 3) y el contador de instrucciones de devolución (necesario para 1 y 4). int AS_Devolucion (AST tipo_dev, Atr_Expr e, int cont) // 1 if (cont == -1) System.out.println("ERROR") // 2 if(!e.getrval()) System.out.println("ERROR") // 3 if(! tipo_dev.equals(e.gettipo())) System.out.println("ERROR") if( tipo_dev.gettype() == FORMACION &&! tipo_dev.equalstree(e.gettipo())) System.out.println("ERROR") if( tipo_dev.gettype() == CLASE &&! tipo_dev..getfirstchild(). equals(e.gettipo().getfirstchild())) System.out.println("ERROR") // 4 return cont+1