UNIVERSIDAD NACIONAL DE TRUJILLO

Diseño e Implementación de

un Analizador Léxico - Sintáctico

Valdivieso Castillo, Claudia Zárate Florián, Carlos

22/12/2011

DESCRIPCIÓN DEL LENGUAJE:

Descripción Informal del Lenguaje:

1. Sobre el Lexema:

NUMERO: Tipo de dato formado por dígitos del 0-9 que puede incluir el carácter ‘.’

para que indica la parte flotante este tipo de datos incluye tipos numéricos como

Integer, float, long, shortint, double, etc.

CADENA: Tipo de dato formado por caracteres alfanuméricos. No obstante se

excluyen las tildes de los caracteres. Este tipo de dato Word se comienza y finaliza con

comillas simples “ ‘ “.

“IDENT”: conjunto de caracteres alfanuméricos que representa una porción de

memoria.

“LIB”: Define el nombre de la librería y va después de la palabra reservada IMPORT.

“COMMENT”: Conjunto de caracteres alfanuméricos que comienzan con la cadena '#'

que no representan ningún valor en el código más que el servir de anotación.

SIMBOLOS y SIGNOS:

“=”: asigna un valor numérico a una variable definida.

“;”: Indica el final de una sentencia.

“(“, “[“: Caracteres que representa el inicio de un bloque de código.

“)”, “]”: Caracteres que representa el final de un bloque de código.

“+”: carácter especial que representa la operación aritmética de la suma de 2 valores

numéricos que pueden ser reales o enteros.

“*”: carácter especial que representa la operación aritmética de la multiplicación de 2

valores numéricos.

“-”: carácter especial que representa la operación aritmética de la resta de 2 valores

numéricos que pueden ser reales o enteros si este valor se encuentra después de un

asignado representa que el valor numérico consecuente es negativo.

“/”: Carácter especial que representa la operación aritmética de la división de 2

valores numéricos.

“<”: Carácter que represente que el valor numérico antecedente es menor que el valor

numérico consecuente.

“>”: Carácter que represente que el valor numérico antecedente es mayor que el valor

numérico consecuente.

“MENIG”: Cadena de caracteres que representan que el valor numérico antecedente

es de menor o igual que el valor numérico consecuente.

“MAYIG”: Carácter que represente que el valor numérico antecedente es de mayor o

igual que el valor numérico consecuente.

“AND”: Cadena formada por 2 caracteres que representan la conjunción de 2

proposiciones.

“OR”: Cadena formada por 2 caracteres que representan la disyunción de 2

proposiciones.

“IGUAL”: Carácter que represente que el valor numérico antecedente es igual que el

valor numérico consecuente.

TIPOS DE DATOS

NUM: Tipado para los datos NUMERO.

WORD: Tipado para los datos CADENA.

PALABRAS RESERVADAS

“RD”: Palabra reservada que corresponde al flujo de entrada estándar. En el caso, el

flujo de entrada representa al teclado.

“WR”: Palabra reservada que representa el flujo de salida estándar.

“GLOBAL”: Palabra reservada para denominar a una variable como global.

“IMPORT”: Palabra reservada para incluir una librería.

PALABRAS RESERVADAS PARA ESTRUCTURAS DE CONTROL

“IF”: Palabra reservada que indica una sentencia de carácter condicional Si…entonces

hacer...

“ENDIF: Indica el fin del bloque de la estructura de control “IF”

“ELSE”: Palabra reservada que indica una sentencia que se ejecuta al no cumplir la

condición de la sentencia Si no…entonces.

“WHILE”: Palabra reservada que representa un bucle que se ejecutará una cantidad

determinada de veces.

“ENDWHILE”: Indica el fin del bloque de la estructura de control “WHILE”

“FOR”: Palabra reservada para ejecutar un bucle mientras que se cumpla una

condición dada.

“ENDFOR”:Indica el fin del bloque de la estructura de control “FOR”

“SELECTCASE”: Palabra reservada que permite seleccionar ejecutar una sentencia o

serie de sentencias según el parámetro.

“CASE”: Palabra reservada que representa la opción a ejecutar según el parámetro de

entrada de SWITCH.

“DEFAULT”: Palabra reservada que representa una opción por defecto que ejecuta las

sentencias definidas dentro de esta.

“ENDSELECTCASE”:Indica el fin del bloque de la estructura de control “SELECTCASE”

“FUNCTION”: Palabra reservada que indica que una función va a ser definida.

“ENDFUNCTION”: Palabra reservada que indica el fin de una función.

2. Sobre la Sintaxis:

Resumen de la Sintaxis: Esta sintaxis se inicia con el no terminal “Fuente” que estructura

el contenido del código fuente, se permiten declaraciones, como asignaciones o

simplemente identificadores, fuera de las funciones o función principal “MAIN” como

globales, es decir que se utilizarán en más de una función , no se permiten estructuras de

datos.

Fuente: El código fuente está estructurado por una “Cabecera” que debe estar

estrictamente incluida, luego se define "Globalgramatica" que puede o no estar

presente, a continuación se define “Funcion”, que puede o no estar presente y por

último la función principal “MAIN”, en la que se ejecutan las sentencias y llamadas.

Cabecera: Es la primera parte del código fuente y representa la inclusión de librerías,

está formada por 2 partes, la primera la palabra reservada “import” y a continuación

el nombre de la librería con su extensión “libreria.lib”.

Globalgramatica: Es la segunda parte del código fuente, este elemento es opcional, y

es la declaración/asignación de variables fuera de las funciones, comienza con la

palabra reservada "GLOBAL" y termina con un punto y coma (;).

Funcion: Es la tercera parte del código fuente, este elemento puede como no estar

presente en el código fuente, comienza con la palabra reservada "FUNCTION", está

definida por un identificador y a continuación la entrada de parámetros, el contenido

de la función termina con “ENDFUNCTION”. El contenido son sentencias definidas en

la gramática.

Principal: Es la parte fundamental del código fuente y su presencia es de carácter

estricto, su definición comienza con la palabra reservada “FUNCTION”. Esta función

principal tiene un único identificador (MAIN), a continuación se describe los

parámetros de entrada que se encuentran entre paréntesis. El contenido de la función

principal se encuentra delimitado por la palabra reservada “ENDFUNCTION”, éste es

una secuencia de sentencias definidas en la gramática.

Listasentencia: Representa las acciones de una función, incluye también las sentecias

return y break definidas por Returngramatica y Breakgramatica.

Returngramatica: Define la gramática de un retorno de valores, comienza con la

palabra reservada "return" (RET), luego el factor que se va a devolver y por último el

punto y coma.

Breakgramatica: Define la gramática de ruptura o corte de una función, comienza con

la palabra reservada "break" (BREAK) seguida del punto y coma.

Sentencia: Representa las acciones de la función y sólo se permite una sentencia por

línea. Los bloques que representan bucles como el for, while y las sentencias

condicionales if y selectcase incluyen sentencias definidas en la gramática. Las

sentencias incluidas son COMMENT, Ifgramatica, Forgramatica, Whilegramatica,

Selectcasegramatica, Asignacion, ID PI Parametroentrada PD, Escribir, Leer y

Declaracion, serán descritas a continuación.

o Declaracion: Es la declaración de una variable y su definición comienza con el

tipado y a continuación un identificador que puede o no estar acompañado de una

asignación. Se puede declarar varios identificadores de un mismo tipo separado

por comas, si estos no presentan asignaciones en la misma sentencia.

o COMMENT: Representa un comentario.

o Ifgramatica: Sentencia condicional, comienza con la palabra “if” seguida por su

condición lógica encerrada entre paréntesis. Las instrucciones que ejecuta al

cumplirse la condición están limitadas por ENDIF, seguida o no de la sentencia

“Elsegramatica”.

o Elsegramatica: Esta sentencia es parte de Ifgramatica y puede ser vacía o incluir

sentencias para ejecutar.

o Forgramatica: Una sentencia que representa un bucle, se identifica por la palabra

“for” y a continuación parámetros encerrados entre paréntesis. Los parámetros

son una asignación, una condición y una suma o resta. Sus sentencias a ejecutar

están limitadas al "endif" (ENDIF).

o Whilegramatica: Una sentencia que representa un bucle condicional identificado

con la palabra “while” seguida de su condición encerrada entre parénesis. Sus

sentencias a ejecutar estan limitadas por el "endwhile" (ENDWHILE).

o Selectcasegramatica: Sentencia que ejecuta sentencias según el caso. Se identifica

por la palabra “selectcase” acompañada por un parámetro encerrado entre

paréntesis.

o Listacase: Contiene la lista de casos (Casegramatica).

o Casegramatica: Se identifica con la palabra “case” seguida por un factor que

representa el caso, a continuación “:” y la Listasentencia o Sentencia a ejecutar

según el caso. Sus sentencias a ejecutar finalizan con “break;“.

o Defaultcase: Se identifica con la palabra “default” seguida por “:” y la

Listasentencia o Sentencia a ejecutar. Sus sentencias a ejecutar pueden estar o no

encerradas entre llaves y finaliza con “break;“.

o Asignacion: Comienza con un identificador seguida del token de asignación “=” y

una expresión.

o Llamada a una función (“ID '(' Parametroentrada ')'”): Sentencia que hace

llamado a una función definida por un identificador. En esta llamada se utiliza

Parametroentrada que está encerrado entre paréntesis.

o Escribir: Sentencia que define un mensaje en pantalla, identificado con la palabra

“print” seguida de un factor, una asignación o una cadena.

o Leer: Sentencia que define una captura de datos que serán almacenados en un

identificador. Se caracteriza por la palabra “input” seguida por el identificador

encerrado entre paréntesis.

o Retorno (RET Factor ‘;’): Representa el retorno de datos.

Parametros: Este representa un parámetro o una secuencia de parámetros.

Parametro: Este representa la declaración de un parámetro que está formado por el

tipado y un identificador.

Parametroentrada: Representado por un factor, es la entrada que corresponde al

parámetro de la llamada de una función.

Condición: Puede ser lógica, AND u OR.

Condicionlogica: Compara expresiones según sea MAYOR, MENOR, MAYIG, MENIG,

IGUAL, DIF.

CondicionAND: Une dos Condicionlogica a través de un AND.

CondicionOR: Une dos Condicionlogica a través de un OR.

Expresion: Representa una expresión matemática, que puede ser una suma, una resta

o un Termino.

Termino: Representa una expresión matemática, que puede ser una multiplicación,

una división o un Factor.

Factor: Es un terminal, puede ser NUMERO, CaDENA o ID.

Tipo: Representa los tipos NUM Y WORD.

Descripción Formal del Lenguaje:

1. Sobre el Lexema:

Lexema Significado

NUMERO {digito}+

{digito}+"."{digito}+

CADENA "’’"({letra}|{digito})+"’’"

"'"{letra}"'"

IDENT {letra}({letra}|{digito})*

NUM “num”

WORD “word”

SUMA “+”

RESTA “-“

MULT “*”

DIV “/”

MENOR “<”

MAYOR “>”

MENIG “<=”

MAYIG “>=”

AND “&&”

OR “||”

IGUAL “==”

IF “if”

ELSE “else”

ENDIF “endif”

WHILE “while”

ENDWHILE “endwhile”

FOR “for”

ENDFOR “endfor”

SELECTCASE “selectcase”

CASE “case”

DEFAULT “default”

ENDSELECTCASE “endselectcase”

RD “input”

WR “print”

ASIG “=”

PC “;”

PD “)”

CD “]”

PI “(“

CI “[“

COMMENT "#"({letra}|{digito})*

IMPORT “import”

LIB {letra}+.lib

GLOBAL “global”

FUNCTION “function”

ENDFUNCTION “endfunction”

MAIN "main"

RET "return"

BREAK "break"

DIF "!="

COMA “,”

DP “:”

2. Sobre la Sintaxis:

Fuente ::= Cabecera Funcion Principal {: :}

| Cabecera Globalgramatica Funcion Principal {: :}

| Cabecera Principal {: :}

;

Globalgramatica ::= GLOBAL:g Declaracion PC:pc {: :}

;

Cabecera ::= IMPORT:i LIB:l PC:pc Cabecera {: :}

| IMPORT:i LIB:l PC:pc{: :}

;

Funcion ::= FUNCTION:function ID:id PI:pi Parametros PD:pd DP:dp Listasentencia

ENDFUNCTION:endfunction {: :}

| FUNCTION:function ID:id PI:pi Parametros PD:pd DP:dp Listasentencia RET:ret

Factor PC:pc ENDFUNCTION:endfunction {: :}

;

Principal ::= FUNCTION:function MAIN:main PI:pi Parametros PD:pd DP:dp Listasentencia

RET:ret Factor PC:pc ENDFUNCTION:endfunction {: :}

| FUNCTION:function MAIN:main PI:pi Parametros PD:pd DP:dp Listasentencia

ENDFUNCTION:endfunction {: :}

;

Listasentencia ::= Sentencia {: :}

| Listasentencia Sentencia {: :}

| Returngramatica {: :}

| Breakgramatica {: :}

;

Sentencia ::= COMMENT:comment {: :}

| Ifgramatica {: :}

| Forgramatica {: :}

| Whilegramatica {: :}

| Selectcasegramatica {: :}

| Asignacion PC:pc {: :}

| ID:id PI:pi Parametroentrada PD:pd PC:pc {: :}

| Escribir PC:pc {: :}

| Leer PC:pc {: :}

| Declaracion PC:pc {: :}

;

Returngramatica ::= RET:ret Factor PC:pc {: :}

;

Breakgramatica ::= BREAK:breakg PC:pc {: :}

;

Declaracion ::= Tipo Identificadores {: :}

| Tipo Asignacion {: :}

;

Identificadores ::= ID:id {: :}

| Identificadores COMA:coma ID:id {: :}

;

Parametros ::= /* vacio */

| Parametro {: :}

;

Parametro ::= Tipo ID:id {: :}

| Parametro COMA:coma Tipo ID:id {: :}

;

Parametroentrada ::= /* vacio */

| Factor {: :}

| Parametroentrada COMA:coma Factor {: :}

;

Ifgramatica ::= IF:ifg PI:pi Condicion PD:pd DP:dp Listasentencia ENDIF:endif {: :}

| IF:ifg PI:pi Condicion PD:pd DP:dp Listasentencia Elsegramatica ENDIF:endif

{: :}

;

Elsegramatica ::= ELSE:elseg DP:dp Listasentencia {: :}

;

Whilegramatica ::= WHILE:whileg PI:pi Condicion PD:pd DP:dp Listasentencia

ENDWHILE:endwhile {: :}

;

Forgramatica ::= FOR:forg PI:pi ID:id ASIG:asig Factor PC:pc Condicion PC:pc1 ID:id1

SUMA:suma Factor PD:pd DP:dp Listasentencia ENDFOR:endfor {: :}

| FOR:forg PI:pi ID:id ASIG:asig Factor PC:pc Condicion PC:pc1 ID:id1

RESTA:resta Factor PD:pd DP:dp Listasentencia ENDFOR:endfor {: :}

;

Selectcasegramatica ::= SELECTCASE:selectcase PI:pi Factor PD:pd DP:dp Listacase

ENDSELECTCASE:endselectcase {: :}

| SELECTCASE:selectcase PI:pi Factor PD:pd DP:dp Listacase

Defaultcase ENDSELECTCASE:endselectcase {: :}

;

Listacase ::= Casegramatica {: :}

| Listacase Casegramatica {: :}

;

Casegramatica ::= CASE:caseg Factor DP:dp Listasentencia BREAK:breakg PC:pc {: :}

;

Defaultcase ::= DEFAULT:defaultg DP:dp Listasentencia BREAK:breakg PC:pc {: :}

;

Asignacion ::= ID:id ASIG:asig Expresion {: :}

| ID:id ASIG:asig RESTA:resta NUMERO:numero {: :}

| ID:id CI:ci NUM:num CD:cd ASIG:asig CADENA:cadena {: :}

;

Condicion ::= Condicionlogica {: :}

| CondicionAND {: :}

| CondicionOR {: :}

;

Condicionlogica ::= Expresion MAYOR:mayor Expresion {: :}

| Expresion MENOR:menor Expresion {: :}

| Expresion MAYIG:mayig Expresion {: :}

| Expresion MENIG:menig Expresion {: :}

| Expresion IGUAL:igual Expresion {: :}

| Expresion DIF:dif Expresion {: :}

;

CondicionAND ::= Condicionlogica AND:and Condicionlogica {: :}

;

CondicionOR ::= Condicionlogica OR:or Condicionlogica {: :}

;

Escribir ::= WR:wr PI:pi Factor PD:pd {: :}

| WR:wr PI:pi Asignacion PD:pd {: :}

| WR:wr PI:pi CADENA:cadena PD:pd {: :}

;

Leer ::= RD:rd PI:pi ID:id PD:pd {: :}

;

Expresion ::= PI:pi Expresion PD:pd {: :}

| Expresion SUMA:suma Termino {: :}

| Expresion RESTA:resta Termino {: :}

| Termino {: :}

;

Termino ::= Termino MULT:mult Factor {: :}

| Termino DIV:div Factor {: :}

| Factor {: :}

;

Factor ::= NUMERO:num {: :}

| ID:id

;

Tipo ::= NUM:num {: :}

| WORD:word {: :}

;

Declaraciones Java implementadas:

1. En Lexer.flex:

package analizador;

import java_cup.runtime.Symbol;

2. En Paser.cup:

package analizador;

import java_cup.runtime.*;

Código Java implementado:

1. En Parser.cup:

parser code{:

public void syntax_error( Symbol s )

{

interfaz.resultado = interfaz.resultado + "Error de Sintaxis -> Línea: " + s.left + ",

Columna: " + s.right + "\n";

}

public void unrecovered_syntax_error( Symbol s ) throws java.lang.Exception

{

}

:}

Autómata:

digito

letra

#

+

-

*

/

<

>

=

&

|

!

‘

;

,

(

)

[

]

:

b

c

d

e

e

f

f

g

i

CASOS DE PRUEBA:

Caso 1: import hola.lib; function main (): endfunction Caso 2: import hola.lib; import iostream.lib; function dos(num i): print(''hola''); endfunction function main (): dos(j); endfunction

i

i

m

n

p

r

s

w

w

EOF

p

r

Caso 3: import hola.lib; import iostream.lib; function uno(num i):

int b=0; if(b>i) print(''hola''); else print(b);

endfunction function main ():

word c[1]=''a''; selectcase(c):

case ''a'': print('a'); break; case ''b'' print('b'); break; default: break;

endselectcase funcion(j);

endfunction Caso 4 import hola.lib; function main ():

#hola este es un comentario endfunction Caso 5 import hola; import iostream.lib; function tres(num i){

print(''hola''); endfunction else function main ():

tres(j); endfunction

Caso 6: import hola.lib import iostream.lib function cuatro(num i):

&num b=0; if(b>i) print('hola''); else print(b);

endfunction function main ():

word c[1]=''a''; selectcase(c):

case ''a'': print(''a''); case ''b'': print(''b''); break; default: break;

endselectcase funcion(j);

endfunction