TEMA 2: PARSERS Y CONSTRUCCIÓN DEL ÁRBOL DE SINTAXIS ABSTRACTA PARA L-0

Transcripción

1 TEMA 2: PARSERS Y CONSTRUCCIÓN DEL ÁRBOL DE SINTAXIS ABSTRACTA PARA L-0 En este tema se divide en tres secciones: (1) la definición el analizador léxico de L-0, (2) el conjunto de reglas sintácticas de L-0 y (3) el analizador sintáctico extendido para la construcción del árbol de sintaxis abstracta del lenguaje L-0. En las tres secciones usamos ANTLR. 1.- ANÁLISIS LÉXICO DE L-0 class Analex extends Lexer options{ // Importación del vocabulario de tokens desde el analizador // sintáctico (Anasint.g) importvocab=anasint // Por defecto no se activa la comprobación de literales // declarados en la sección tokens testliterals=false //2 símbolos de anticipación para tomar decisiones //(los tokens DP y ASIG justifican su necesidad) k=2 } tokens{ // Palabras reservas (unidad de programa) MODULO="modulo" // Palabras reservadas (instrucciones compuestas) // palabras reservadas en condicionales SI="si" ENTONCES="entonces" SINO="sino" FINSI="finsi" // palabras reservadas en iteraciones MIENTRAS="mientras" HACER="hacer" FINMIENTRAS="finmientras" // Palabras reservadas (devolución resultado) DEV="dev" // Palabras reservadas (visibilidad) OCULTO="oculto" // Palabras reservadas (clase instanciable) INST="inst"

2 // Palabras reservas (tipos predefinidos simples) ENTERO="entero" REAL="real" LOGICO="logico" CARACTER= caracter // Palabras reservas (tipos predefinidos compuestos) FORMACION="formacion" // Palabras reservas (tipos no predefinidos) CLASE="clase" // Palabras reservadas (literales lógicos) CIERTO="cierto" FALSO="falso" } // Palabras reservadas (operadores lógicos) Y="y" O="o" NO="no" //Tokens inútiles para el análisis sintáctico //(B)lancos y (T)abuladores BT : (' ' '\t') {$settype(token.skip)} //(S)altos de (L)inea SL : "\r\n" {newline()$settype(token.skip)} // Comentario de línea COMENT_LIN: "//" (('\r')+ ~('\n') ~('\r') )* "\r\n" {newline()$settype(token.skip)} // Signos de puntuación DOS_PUNTOS : ':' //(D)os (P)untos PARENTESIS_ABIERTO : '(' // (P)arentesis (A)bierto PARENTESIS_CERRADO : ')' // (P)arentesis (C)errado LLAVE_ABIERTA: '{' // (LL)ave (A)bierta LLAVE_CERRADA: '}' // (LL)ave (C)errada CORCHETE_ABIERTO: '[' // (COR)chete (A)bierto CORCHETE_CERRADO: ']' // (COR)chete (C)errado COMA: ',' // (CO)ma PUNTO_Y_COMA: '' // (PU)nto y (C)oma PUNTO:'.' // (PU)nto // Operadores aritméticos MAS: '+' MENOS: '-' POR: '*' DIVISION: '/' // Operadores relacionales MENOR:'<'

3 MENOR_IGUAL:"<=" MAYOR:'>' MAYOR:IGUAL:">=" IGUAL: '=' DISTINTO: "!=" // Asignación ASIGNACION : ":=" // Lexemas auxiliares protected DIGITO: ('0'..'9') protected LETRA: ('a'..'z' 'A'..'Z') // Literales Enteros y Reales NUMERO : ((DIGITO)+ '.') => (DIGITO)+ '.' (DIGITO)+ {$settype(lit_real)} ((DIGITO)+) => (DIGITO)+ {$settype(lit_entero)} //Literales Carácter LIT_CAR: \! (~( \ \n \r \t )) \! // Lexema IDENT (Identificadores) // Se activa la comprobación de palabras reservadas. // Las palabras reservadas tienen preferencia a cualquier otro identificador. IDENT options {testliterals=true}: LETRA(LETRA DIGITO)*

4 2.- REGLAS PARA EL ANÁLISIS SINTÁCTICO DE L-0 ///////////////////////////////////////////////////////// // DECLARACION DE MODULO ///////////////////////////////////////////////////////// declaracion_modulo : nombre_modulo definicion_modulo EOF nombre_modulo : MODULO IDENT definicion_modulo : lista_declaraciones_clases lista_declaraciones_clases : (declaracion_clase)+ // DECLARACIÓN DE CLASE declaracion_clase : cualificador_clase nombre_clase definicion_clase cualificador_clase: INST nombre_clase : CLASE IDENT definicion_clase : LLAVE_ABIERTA declaraciones_elemento_clase LLAVE_CERRADA // La definición de la clase se completa con declaraciones de // atributos y métodos. declaraciones_elemento_clase : (declaracion_elemento_clase)* declaracion_elemento_clase : cualificador_elemento_clase

5 ((IDENT PARENTESIS_ABIERTO) => declaracion_metodo tipo IDENT PUNTO_Y_COMA cualificador_elemento_clase: OCULTO // Declaración de método consta de prototipo y definición // Prototipo o perfil de la operación. // Definición de método compuesto de declaración de // variables locales e instrucciones. declaracion_metodo : prototipo_metodo definicion_metodo prototipo_metodo: IDENT PARENTESIS_ABIERTO declaracion_parametros PARENTESIS_CERRADO (DEV tipo)? declaracion_parametros : declaracion_parametro (COMA declaracion_parametro)* declaracion_parametro : tipo IDENT definicion_metodo : LLAVE_ABIERTA declaraciones_variables_locales bloque LLAVE_CERRADA declaraciones_variables_locales : (declaracion_variables_locales tipo IDENT) => declaracion_variables_locales declaraciones_variables_locales (declaracion_variables_locales) => declaracion_variables_locales declaracion_variables_locales : tipo lista_nombres_variables_locales PUNTO_Y_COMA

6 lista_nombres_variables_locales : nombre_variable_local (COMA nombre_variable_local)* nombre_variable_local : IDENT // INSTRUCCIONES // Instrucciones simples en L-0: asignacion, retorno, // llamada a método // Instrucciones compuestas en L-1: condicional e iteración instrucciones : (instruccion)* instruccion: instruccion_simple PUNTO_Y_COMA instruccion_compuesta instruccion_simple : (expresion ASIGNACION) => asignacion llamada_metodo retorno instruccion_compuesta : condicion iteracion // Asignación. asignación : expresion ASIGNACION expresion // Devolución de resultado. retorno : DEV expresion // Llamada a método (procedimiento) llamada_metodo : acceso PARENTESIS_ABIERTO lista_expresiones PARENTESIS_CERRADO

7 // Lista de expresiones lista_expresiones : expresion (COMA expresion)* // Condicional: si condicion entonces... en otro caso... condicion : SI PARENTESIS_ABIERTO expresion PARENTESIS_CERRADO ENTONCES bloque (SINO bloque)? FINSI // Iteración: mientras condicion hacer... iteracion : MIENTRAS PARENTESIS_ABIERTO expresion PARENTESIS_CERRADO HACER bloque FINMIENTRAS // Bloque de instrucciones en instrucciones compuestas y métodos bloque: instrucciones // // EXPRESIONES / // Reglas para cubrir estructuralmente una expresión en L-0 // Las expresiones pueden ser: lógicas, aritméticas (enteras // o reales) o de carácter / expresion : expresion_nivel_1 (O expresion_nivel_1)* expresion_nivel_1 : expresion_nivel_2 (Y expresion_nivel_2)* expresion_nivel_2 : NO expresion_nivel_2 expresion_nivel_3 expresion_nivel_3 : expresion_nivel_4 ((MAYOR MAYOR_IGUAL MENOR MENOR_IGUAL IGUAL DISTINTO) expresion_nivel_4)? expresion_nivel_4 : expresion_nivel_5 ((MAS MENOS) expresion_nivel_5)* expresion_nivel_5 : expresion_nivel_6 ((POR DIVISION) expresion_nivel_6)* expresion_nivel_6 : MENOS expresion_nivel_6

8 expresion_nivel_7 expresion_nivel_7 : PARENTESIS_ABIERTO expresion PARENTESIS_CERRADO (acceso PARENTESIS_ABIERTO) => llamada_metodo (acceso CORCHETE_ABIERTO) => acceso_tabla acceso LIT_ENTERO LIT_REAL LIT_CAR CIERTO FALSO // Acceso a un elemento de una formación acceso_tabla: acceso CORCHETE_ABIERTO lista_expresiones_nv CORCHETE_CERRADO // Accesos simples y a objetos (máximo un nivel) acceso: (IDENT PUNTO) => IDENT PUNTO IDENT IDENT // Lista no vacía de expresiones lista_expresiones_nv : expresion (COMA expresion)* ////////////////////////////////////////////////////////// // TIPOS ///////////////////////////////////////////////////////// // L-0 dispone de tipos predefinidos básicos, tipos // predefinidos compuestos y clases definidas por el // programador. ///////////////////////////////////////////////////////// tipo : tipo_predefinido_simple tipo_predefinido_compuesto IDENT // Los tipos básicos o predefinidos en L-0 son: // entero, real, carácter y lógico tipo_predefinido_simple : ENTERO REAL

9 LOGICO CARACTER tipo_predefinido_compuesto : formacion formacion : FORMACION lista_enteros (tipo_predefinido_simple IDENT) lista_enteros : LIT_ENTERO (COMA LIT_ENTERO)*

10 3.- ANÁLISIS SINTÁCTICO Y CONSTRUCCIÓN DEL ASA DE L-0 header{ import java.util.* import antlr.* } class Anasint extends Parser options{ buildast=true } tokens{ } { } PROGRAMA VISIBLE NO_INST ATRIBUTO METODO PROTOTIPO PARAMETRO PARAMETROS EXPRESIONES RESULTADO DEFINICION VACIO VARIABLE_LOCAL VARIABLES_LOCALES INSTRUCCION INSTRUCCIONES MENOSUNARIO LLAMADA ACCESO_TABLA ACCESO_OBJETO ACCESO_SIMPLE LISTA_ENTEROS ///////////////////////////////////////////////////////// // DECLARACION DE MODULO /////////////////////////////////////////////////////////

11 MODULO IDENT CLASE + declaracion_modulo! : n:nombre_modulo d:definicion_modulo EOF { #declaracion_modulo = #(#[MODULO,"modulo"],#n, #d) } nombre_modulo : MODULO! IDENT definicion_modulo : lista_declaraciones_clases lista_declaraciones_clases : (declaracion_clase)+ // DECLARACIÓN DE CLASE CLASE IDENT INST / NO INST * METODO/ATRIBUTO declaracion_clase! : c:cualificador_clase n:nombre_clase d:definicion_clase { #declaracion_clase = #(#[CLASE,"clase"],#n,#c,#d) } cualificador_clase! : INST {#cualificador_clase = #(#[INST])} {#cualificador_clase = #(#[NO_INST,"no_inst"])} nombre_clase : CLASE! IDENT definicion_clase :

12 LLAVE_ABIERTA! declaraciones_elemento_clase LLAVE_CERRADA! declaraciones_elemento_clase : (declaracion_elemento_clase)* ////////////////////////////////////////////////// // DECLARACIÓN DE ELEMENTO CLASE: MÉTODO O ATRIBUTO ////////////////////////////////////////////////// METODO PROTOTIPO DEFINICION OCULTO/VISIBLE IDENT PARAMETROS RESULTADO VARIABLES_LOCALES INSTRUCCIONES PARAMETRO * * * tipo / VACIO VARIABLE_LOCAL INSTRUCCION ATRIBUTO IDENT tipo OCULTO/VISIBLE declaracion_elemento_clase! : c:cualificador_elemento_clase ((IDENT PARENTESIS_ABIERTO) => a:declaracion_metodo { #declaracion_elemento_clase = #(#[METODO,"metodo"],#a,#c) } t:tipo i:ident PUNTO_Y_COMA { #declaracion_elemento_clase = #(#[ATRIBUTO,"atributo"],#i,#t,#c) }) // Cualificador de visibilidad cualificador_elemento_clase! : OCULTO {#cualificador_elemento_clase = #(#[OCULTO])}

13 {#cualificador_elemento_clase = #(#[VISIBLE,"visible"])} declaracion_metodo : prototipo_metodo definicion_metodo prototipo_metodo! : i:ident PARENTESIS_ABIERTO p:declaracion_parametros PARENTESIS_CERRADO (DEV t:tipo {#prototipo_metodo = #(#[PROTOTIPO, prototipo ],#i,#(#[parametros,"parametros"],#p), #(#[RESULTADO,"resultado"],#t))} {#prototipo_metodo = #(#[PROTOTIPO, prototipo ],#i,#(#[parametros,"parametros"],#p), #(#[RESULTADO,"resultado"],#[VACIO, vacio ]))} ) declaracion_parametros : declaracion_parametro (COMA! declaracion_parametro)* // DECLARACIÓN DE PARÁMETRO PARAMETRO IDENT tipo declaracion_parametro!: t:tipo i:ident {#declaracion_parametro = #(#[PARAMETRO, parametro ],#i,#t)} definicion_metodo! : LLAVE_ABIERTA d: declaraciones_variables_locales b: bloque LLAVE_CERRADA {#definicion_metodo= #(#[DEFINICION, definicion ],#(#[VARIABLES_LOCALES, variables_locales ],#d), #b)}

14 declaraciones_variables_locales : (declaracion_variables_locales tipo IDENT) => declaracion_variables_locales declaraciones_variables_locales (declaracion_variables_locales) => declaracion_variables_locales declaracion_variables_locales : t:tipo! lista_nombres_variables_locales[#t] PUNTO_Y_COMA! lista_nombres_variables_locales [AST t] : nombre_variable_local[#t] (COMA! nombre_variable_local[#t])* ////// // DECLARACIÓN DE VARIABLE LOCAL /////// VARIABLE_LOCAL IDENT tipo nombre_variable_local! [AST t] : i:ident { #nombre_variable_local = #(#[VARIABLE_LOCAL,"variable_local"],#i,#t) } // INSTRUCCIONES instrucciones : (instruccion)* instruccion! : i:instruccion_simple PUNTO_Y_COMA {#instruccion=#(#[instruccion,"instruccion"],#i)} j:instruccion_compuesta {#instruccion=#(#[instruccion,"instruccion"],#j)} instruccion_simple : (expresion ASIGNACION) => asignacion llamada_metodo retorno

15 instruccion_compuesta : condicion iteracion ASIGNACION expresion expresion asignacion! : e1:expresion ASIGNACION e2:expresion { #asignacion = #(#[ASIGNACION],#e1,#e2) } DEV expresion retorno! : DEV e:expresion { #retorno = #(#[DEV],#e) } LLAMADA acceso EXPRESIONES expresion * llamada_metodo! : i:acceso PARENTESIS_ABIERTO s:lista_expresiones PARENTESIS_CERRADO { #llamada_metodo = #(#[LLAMADA,"llamada"],#i,#(#[EXPRESIONES, expresiones ],#s)) }

16 lista_expresiones : expresion (COMA! expresion)* SI expresion INSTRUCCIONES INSTRUCCIONES INSTRUCCION * INSTRUCCION * condicion : SI^ PARENTESIS_ABIERTO! expresion PARENTESIS_CERRADO! ENTONCES! bloque (SINO! bloque)? FINSI! MIENTRAS expresion INSTRUCCIONES INSTRUCCION * iteracion : MIENTRAS^ PARENTESIS_ABIERTO! expresion PARENTESIS_CERRADO! HACER! bloque FINMIENTRAS! bloque!: i:instrucciones {#bloque=#(#[instrucciones, instrucciones ],#i)} // // EXPRESIONES / expresion : expresion_nivel_1 (O^ expresion_nivel_1)*

17 expresion_nivel_1 : expresion_nivel_2 (Y^ expresion_nivel_2)* expresion_nivel_2 : NO^ expresion_nivel_2 expresion_nivel_3 expresion_nivel_3 : expresion_nivel_4 ((MAYOR^ MAYOR_IGUAL^ MENOR^ MENOR_IGUAL^ IGUAL^ DISTINTO^) expresion_nivel_4)? expresion_nivel_4 : expresion_nivel_5 ((MAS^ MENOS^) expresion_nivel_5)* expresion_nivel_5 : expresion_nivel_6 ((POR^ DIVISION^) expresion_nivel_6)* expresion_nivel_6 : MENOS i:expresion_nivel_6 {#expresion_nivel_6=#(#[menosunario,"menosunario"],#i)} j:expresion_nivel_7 {#expresion_nivel_6=#j} expresion_nivel_7 : PARENTESIS_ABIERTO! expresion PARENTESIS_CERRADO! (acceso PARENTESIS_ABIERTO) => llamada_metodo (acceso CORCHETE_ABIERTO) => acceso_tabla acceso LIT_ENTERO LIT_REAL LIT_CAR CIERTO FALSO ////////////////////// // ACCESOS A ELEMENTOS DE FORMACIONES //////////////////////

18 ACCESO_TABLA acceso EXPRESIONES expresion + acceso_tabla! : c:acceso CORCHETE_ABIERTO d:lista_expresiones_nv CORCHETE_CERRADO {#acceso_tabla =#(#[ACCESO_TABLA,"acceso_tabla"], #c, #(#[EXPRESIONES, expresiones ],#d))} /// // ACCESOS SIMPLES Y A OBJETOS /// ACCESO_SIMPLE ACCESO_OBJETO IDENT ACCESO_SIMPLE IDENT IDENT acceso: (IDENT PUNTO)=> i1:ident PUNTO i2:ident {#acceso=#(#[acceso_objeto,"acceso_objeto"],#(#[acceso_simple],#i1),#i2)} i:ident {#acceso=#(#[acceso_simple,"acceso_simple"],#i)} lista_expresiones_nv : expresion (COMA! expresion)* ////////////////////////////////////////////////////////// // TIPOS ///////////////////////////////////////////////////////// tipo : tipo_predefinido_simple tipo_predefinido_compuesto IDENT

19 tipo_predefinido_simple : ENTERO REAL LOGICO CARACTER tipo_predefinido_compuesto : formacion FORMACION LISTA_ENTEROS Tipo * LIT_ENTERO formación! : FORMACION l:lista_enteros ( t:tipo_predefinido_simple {#formacion = #(#[FORMACION],#(#[LISTA_ENTEROS, lista_enteros ],#l),#t)} i:ident {#formacion = #(#[FORMACION],#(#[LISTA_ENTEROS, lista_enteros ],#l),#i)} ) lista_enteros : LIT_ENTERO (COMA! LIT_ENTERO)*