Está en la página 1de 40

LENGUAJES Y TRADUCTORES

Prof. Augusto Cortez Vásquez

PROYECTO DE CURSO:
Especificacion y construccion de un lenguaje y su traductor

Integrantes:

 ABARCA RAMOS ALBERTO JUNIOR


 JUAN CARLOS CCENCHO PARI

CICLO IV – 2017 – II

1
Contenido
Contenido ...................................................................................................................................... 2
INTRODUCCIÓN ............................................................................................................................. 3
OBJETIVOS ..................................................................................................................................... 4
1. ESPECIFICACIÓN DEL LENGUAJE............................................................................................ 5
1.1. Características del Lenguaje .......................................................................................... 5
1.2. Sintaxis del lenguaje ...................................................................................................... 6
2. ESPECIFICACIÓN DEL TRADUCTOR ........................................................................................ 9
2.1. ANALIZADOR LEXICOGRÁFICO....................................................................................... 9
2.1.1. Funciones del Analizador Lexicográfico ................................................................ 9
2.1.2. Componentes Léxicos............................................................................................ 9
2.1.3. Errores Léxicos .................................................................................................... 17
2.2. ANALIZADOR SINTÁCTICO ........................................................................................... 17
2.2.1. Funciones del Analizador Sintáctico .................................................................... 17
2.2.2. Gramática ............................................................................................................ 17
2.2.3. Conversión a la forma normal de Chomsky ........................................................ 20
2.2.4. Construcción de la tabla de análisis sintáctico .................................................... 24
2.2.5. Errores Sintácticos ............................................................................................... 34
2.3. ANALIZADOR SEMÁNTICO ........................................................................................... 35
3. EJEMPLOS DE PROGRAMAS EN LENGUAJE TURING ............................................................ 36
4. MANEJO DE ERRORES.......................................................................................................... 37
5. IMPLEMENTACIÓN .............................................................................................................. 37
CONCLUSIONES ........................................................................................................................... 39
REFERENCIAS BIBLIOGRAFICAS ................................................................................................... 40

2
INTRODUCCIÓN

El actual trabajo referido a la especificacion de un lenguaje creado por


nosotros, el cual esta orientado a la programacion estructurada .

A continuación se desarrollara un detallado informe de las


características de nuestro lenguaje, así como su especificación de los
analizadores lexicográfico, sintáctico .

3
OBJETIVOS

 Especificación de un lenguaje formal

 Especificación y construcción del traductor para dicho lenguaje

4
1. ESPECIFICACIÓN DEL LENGUAJE
1.1. Características del Lenguaje

1) Nombre del Lenguaje: Turing

2) Especificaciones

2.1. Caracteres Validos:

 Mayúsculas (A-Z) y minúsculas (a-z)


 Dígitos (0-9)
 Símbolos (&, %, “, ”, ‘, ’, -, /, *, +, >, <, =, |, ¿, ?, ¡, !, ., :,
coma, ;, paréntesis , [, ])

2.2. Tipos de Sentencias

 Declarativa
 Condicional
 Asignación
 Iterativa
 Lectura y Escritura

2.3. Operaciones

2.3.1. Operaciones Aritméticas: Adición ( + ) ,


sustracción ( - ), Multiplicación ( * ), División (
/ ), Modulo ( % ).

2.3.2. Operaciones Lógicas: Conjunción (&), Disyunción (||), Negación (!)

2.3.3. Operaciones Relacionales: Mayor (>), Menor (<), Mayor


Igual (>=), Menor Igual (<=), Igualdad (=), Diferencia
(<>).

2.3.4. Operaciones de Asignación ( :=: )

2.4. Tipos de Datos

 Constantes  Variables
o Entero o Entero
o Real o Real
o Cadena o Cadena
o Carácter o Carácter
o Booleano o Booleano

2.5. Estructuras de Datos

 Vectores y Matrices

5
2.6. Palabras Reservadas

 PRINCIPIO, INICIO, FIN, ACCION, RETORNAR,


 ENTERO, REAL, CARACT,STRING, BOOLEANO, ARREGLO, DE,
TIPO, REGISTRO
 SI, ENTONCES, SINO, PARA, HASTA, CON, HACER, MIENTRAS
 LEER, ESCRIBIR
 TRUE, FALSE

2.7. Delimitadores

 PUNTO Y COMA (.:) (De Sentencia)


 ESPACION EN BLANCO (𝜆) (De Lexema)//SALTO DE LINEA

1.2. Sintaxis del lenguaje

Q: Programa SI: Sentencia Iterativa


SF: Sección de Funciones Var: Variable
nombre_ID:nombre del procedimiento Oper: Operación
D: declaracion Opndo: Operando

SD: Sección Declaraciones Opdor: Operador

D: Declaración Val_Inicial: Valor Inicial


AS: Asignar Val_Final: Valor Final
SC: Sentencia Condicional cambio: Incremento o Decremento

ESTRUCTURA GENERAL

<PROGRAMA> : SECCION DE FUNCIONES

6
SECCIÓN DE FUNCIONES

SF: PROCEDIMIENTO <nombre_ID> (<PARAMETROS>) : <TIPO>

INICIO

SD

SS

FIN

PARAMETROS : D / D ; PARAMETROS

SECCION DE DECLARACIONES

SD : D / D .: SD

D : TIPO : L_ID

L_ID : ID / ID , L_ID

SECCIÓN DE SENTENCIAS

SS : AS / SC / SI / AS SS / SC SS / SI SS

AS : Var :=: Oper

Oper : Opndo Opdor Opndo .: / Opndo Opdor Oper

SC : SI condición ENTONCES SS FIN / SI condición ENTONCES SS SINO SS FIN

SI : MIENTRAS condicion HACER SS FIN

SI : PARA Val_Inicial HASTA Val_Final CON cambio HACER SS END

7
2. ESPECIFICACIÓN DEL TRADUCTOR

2.1. ANALIZADOR LEXICOGRÁFICO


2.1.1. Funciones del Analizador Lexicográfico

El analizador léxico se encarga de obtener y analizar las palabras que


componen un texto fuente, distinguiendo sí pertenecen o no a un determinado
conjunto, dependiendo de su definición lógica (su descripción).

Un analizador léxico o analizador lexicográfico (en inglés scanner) es la


primera fase de un compilador consistente en un programa que recibe como
entrada el código fuente de otro programa (secuencia de caracteres) y
produce una salida compuesta de tokens (componentes léxicos) o símbolos.
Estos tokens sirven para una posterior etapa del proceso de traducción,
siendo la entrada para el analizador sintáctico (en inglés parser).
La especificación de un lenguaje de programación a menudo incluye un
conjunto de reglas que definen el léxico. Estas reglas consisten comúnmente
en expresiones regulares que indican el conjunto de posibles secuencias de
caracteres que definen un token o lexema.

El fin principal de un analizador léxico una vez que se ha reconocido el


conjunto de caracteres (lexema) que forman el componente léxico (pieza
sintáctica), por medio de un patrón descrito por un mecanismo regular, es
entregado al analizador sintáctico.

2.1.2. Componentes Léxicos

1. Identificadores:

Expresión regular:

r= l(l/d)* ,donde: l:letra, d: digito

Autómata finito:

otro

8
2. Palabras Reservadas:

Expresión regular:

r = PRINCIPIO / INICIO / FIN / ACCION/ RETORNAR / DEFINIR


/ ENTERO / REAL / CARACT / STRING / BOOLEANO / ARREGLO
/ TIPO / REGISTRO / SI / ENTONCES / SINO / PARA / HASTA /
CON / HACER / MIENTRAS / TRUE / FALSE

Autómata finito:

otro

l: letra

Además se usara un registro donde estén almacenadas todas las


palabras reservadas para que el analizador verifique si lo reconocido
por el autómata es o no una palabra reservada.

PRINCIPIO
INICIO
FIN
ACCION
RETORNAR
ENTERO
REAL
CARACT
STRING
BOOLEANO
ARREGLO
DE
TIPO
REGISTRO
SI
ENTONCES
SINO
PARA
HACER
MIENTRAS
HASTA
CON
TRUE
FALSE

9
3. Delimitador de fin de sentencia

Expresión regular:

r = .:

Autómata finito:

.: otro

4. Coma

Expresión regular:

r=,

Autómata finito:

otro

5. Paréntesis Izquierdo

Expresión regular:

r=(

Autómata finito:

otro

10
6. Paréntesis Derecho

Expresión regular:

r=)

Autómata finito:

otro

7. Corchete Izquierdo

Expresión regular:

r=[

Autómata finito:

otro

8. Corchete Derecho

Expresión regular:

r=]

Autómata finito:

otro

11
9. Dos Puntos

Expresión regular:

r=:

Autómata finito:

otro

10. Punto

Expresión regular:

r=.

Autómata finito:

otro

12
11. Operadores Aritméticos

Expresión regular:

r = + / - / */ / / %

Autómata finito:

* otro

12. Operadores Lógicos

Expresión regular:

r = & / ||

otro

13
13. Operadores Relacionales

Expresión regular:

r = < / > / >= / <= / <> / =

Autómata finito:

otro

otro

14. Operador de Asignación

Expresión regular:

r = :=:

Autómata finito:

:
𝜀𝜀0 𝜀𝜀𝑖𝑖 otro
= : 𝜀𝜀𝑖𝑖 𝜀𝜀𝑓𝑓
𝜀𝜀𝑖𝑖

14
15. Constante Numérica

Expresión regular:

r = (-)? d+ (.d+ )? , donde: d: digito

Autómata finito:

otro

16. Constante Alfa-Numerica(numeros y letras)

Expresión regular:

r = ‘(l/d/s)’ , donde: l: letra , d: digito ,


s: símbolo excepto apóstrofos

Autómata finito:

𝜀𝜀0 ‘ ’ otro

15
2.1.3. Errores Léxicos

Los posibles errores léxicos de nuestro lenguaje son básicamente los de


cualquier otro lenguaje de programación:

 Un operador, palabra reservada, operador, etc. mal escritos.


 Un lexema no perteneciente a ninguno de los componentes léxicos
definidos
 Presencia de caracteres no validos (No pertenecientes al alfabeto)

2.2. ANALIZADOR SINTÁCTICO


2.2.1. Funciones del Analizador Sintáctico

 Comprobar si la cadena de componentes léxicos proporcionada por el


analizador léxico puede ser generada por la gramática que define el
lenguaje fuente (Gramática Independiente del Contexto, GIC).

 Construir el árbol de análisis sintáctico que define la estructura


jerárquica de un programa y obtener la serie de derivaciones para
generar la cadena de componentes léxicos. El árbol sintáctico se
utilizara como representación intermedia en la generación de código.

 Informar de los errores sintácticos de forma precisa y significativa y


debería estar dotado de un mecanismo de recuperación de errores para
continuar con el análisis.

El análisis sintáctico se puede considerar como una función que toma como
entrada la secuencia de componentes léxicos producida por el análisis léxico
y produce como salida el árbol sintáctico. En la realidad, el análisis sintáctico
hace una petición al análisis léxico del componente léxico siguiente en la
entrada (los símbolos terminales) conforme lo va necesitando en el proceso
de análisis, conforme se mueve a lo largo de la gramática. [3]

2.2.2. Gramática

Para la creación de la gramática se hizo uso de la teoría desarrollada en clase,


primero se creó una gramática libre de contexto, la cual fue convertida a la
Forma Normal de Chomsky (FNC), y por último se eliminó la recursividad por
la izquierda.

La Gramática resultante de acuerdo a la teoría es una Gramática LL(1), la


cual es una gramática libre de contexto (GLC) que no posee reglas λ y además
no es recursiva por la izquierda. [1]

16
Se decidió utilizar este tipo de gramática porque facilita la definición de los
conjuntos Primero y Siguiente, que ayudaran en la construcción de la Tabla
de Análisis Sintáctico.

La gramática G del lenguaje Turing es definido de la siguiente manera:

G(VN, VT, T, P) ; Donde:

VN = { T, SE, LVE, VE, TIPOE, LONG, TIPOD, SF, LF, FP, F, SP, RT, SD, D,
TIPOV, LID, SS, SA, REF, ASIG, INV, PEI, PARI, OPER, OPDOR,
OPNDO, OA, OL, OR, SC, COND, COMP, CPNDO, SI, VI, VF, INDEC,
SL, SES }

VT = { PRINCIPAL, INICIO, FIN, PROCEDIMIENTO, RETORNAR, ENTERO,


REAL, CARACT, CADENA, BOOLEANO, ARREGLO, DE, TIPO,
REGISTRO, SI, ENTONCES, SINO, PARA, HASTA, CON, HACER,
MIENTRAS, LEER, ESCRIBIR, NE, ; , id , : , [ , ] , ( , ) , const, . , = ,
!,+,-,/,*,%,&,|,<,>,,}

P : { T ⟶ SE SF / SF
SE ⟶ TIPO LVE FIN TIPO ;
LVE ⟶ VE / VE LVE
VE ⟶ id : TIPOE
TIPOE ⟶ REGISTRO SD FIN REGISTRO ;
TIPOE ⟶ ARREGLO LONG DE TIPOD ;
LONG ⟶ [NE] / [NE][NE]
TIPOD ⟶ ENTERO / REAL / CADENA / CARACT / BOOLEANO
SF ⟶ FP / LF FP
LF ⟶ F / F LF
FP ⟶ PROCEDIMIENTO PRINCIPAL ( ) INICIO SP FIN PRINCIPAL ;
F ⟶ PROCEDIMIENTO id ( SD ) : TIPOD INICIO SP RETORNAR RT FIN id ;
F ⟶ PROCEDIMIENTO id ( SD ) INICIO SP FIN id ;
F ⟶ PROCEDIMIENTO id ( ) : TIPOD INICIO SP RETORNAR RT FIN id ;
F ⟶ PROCEDIMIENTO id ( ) INICIO SP FIN id ;
SP ⟶ SD SS / SD SS SP
RT ⟶ const / id / id . id / INV
SD ⟶ D / D ; SD
D ⟶ LID : TIPOV
TIPOV ⟶ TIPOD / id
LID ⟶ id / id , LID
SS ⟶ SA / SL / SES / SC / SI / SA SS / SL SS / SES SS / SC SS / SI SS
SA ⟶ REF := ASIG ;
REF ⟶ id / id . id / id LONG
ASIG ⟶ INV / OPER / const / REF
INV ⟶ id ( PEI ) / id ( )
PEI ⟶ PARI / PARI ; PEI
PARI ⟶ REF / const
OPER ⟶ OPNDO OPDOR OPNDO / ! OPNDO
OPNDO ⟶ const / REF / INV / ( OPER ) / OPER
OPDOR ⟶ OA / OL / OR

17
OA ⟶ + / - / / / * / %
OL ⟶ & / ||
OR ⟶ <> / = / < / > / <= / >=
SC ⟶ SI ( COND ) ENTONCES SS FIN SI ;
SC ⟶ SI ( COND ) ENTONCES SS SINO SS FIN SI ;
COND ⟶ INV / COMP
COMP ⟶ CPNDO OR CPNDO / ! OPNDO
CPNDO ⟶ ( COMP ) / INV / OPER / const / REF / COMP
SI ⟶ MIENTRAS ( COND ) HACER SS FIN MIENTRAS ;
SI ⟶ PARA VI HASTA VF CON INDEC HACER SS FIN PARA ;
VI ⟶ id := ASIG
VF ⟶ id OR CPNDO
INDEC ⟶ id := id OA OPNDO / id ++ / id --
SL ⟶ LEER ( REF ) ;
SES ⟶ ESCRIBIR ( OPNDO ) ; / ESCRIBIR ( OPER ) ; }

Leyenda:

T: Programa en Turing PEI: Parámetros de Entrada en


SE: Sección Estructuras Invocación
LVE: Lista de Variable de PARI: Parámetro en Invocación
Estructura OPER: Operación
VE: Variable de Estructura OPNDO: Operando
TIPOE: Tipo de Estructura OPDOR: Operador
LONG: Longitud OA: Operador Aritmético
TIPOD: Tipo de dato OL: Operador Lógico
SF: Sección Funciones OR: Operador Relacional
LF: Lista de Funciones SC: Sentencia Condicional
FP: Función Principal COND: Condicion
F: Función COMP: Comparacion
SP: Sección del Procedimiento CPNDO: Comparando
RT: Retorno SI: Sentencia Iterativa
SD: Sección Declaraciones VI: Valor Inicial
D: Declaración VF: Valor Final
TIPOV: Tipo de Variable INDEC: Incremento o Decremento
LID: Lista de identificadores SL: Sentencia de Lectura
SS: Sección Sentencias SES: Sentencia de Escritura
SA: Sentencia de Asignación NE: Numero Entero
REF: Referencia id: Identificador
ASIG: Asignación const: Constante
INV: Invocación

18
2.2.3. Conversión a la forma normal de Chomsky

La gramática G es una Gramática Libre del Contexto, entonces podemos


construir la gramática G* en la Forma Normal de Chomsky, a partir de la
gramática G

G*(VN, VT, T, P) ; Donde:

VN = { T, SE, LVE, VE, TIPOE, LONG, TIPOD, SF, LF, FP, F, SP, RT, SD, D,
TIPOV, LID, SS, SA, REF, ASIG, PEI, PARI, OPER, OPDOR,
OPNDO, OA, OR, SC, COND, COMP, CPNDO, SI, VI, VF, INDEC, SL,
SES, N1,…, N46, R1,…, R127 }

VT = { PRINCIPAL, INICIO, FIN, PROCEDIMIENTO, RETORNAR, ENTERO,


REAL, CARACT, CADENA, BOOLEANO, ARREGLO, DE, TIPO,
REGISTRO, SI, ENTONCES, SINO, PARA, HASTA, CON, HACER,
MIENTRAS, LEER, ESCRIBIR, NE, ; , id , : , [ , ] , ( , ) , const, . , = ,
!,+,-,/,*,%,&,|,<,>,,}

P:{
T ⟶ SE SF SF ⟶ N4 R16
T ⟶ N4 R16 SF ⟶ LF FP
T ⟶ LF FP LF ⟶ N4 R23
SE ⟶ N12 R1 LF ⟶ N4 R35
R1 ⟶ LVE R2 LF ⟶ N4 R43
R2 ⟶ N 3 R3 LF ⟶ N4 R54
R3 ⟶ N12 N26 LF ⟶ F LF
LVE ⟶ N27 R4 FP ⟶ N4 R16
LVE ⟶ VE LVE R16 ⟶ N1 R17
VE ⟶ N27 R4 R17 ⟶ N31 R18
R4 ⟶ N28 TIPOE R18 ⟶ N32 R19
TIPOE ⟶ N13 R5 R19 ⟶ N2 R20
R5 ⟶ SD R6 R20 ⟶ SP R21
R6 ⟶ N 3 R7 R21 ⟶ N3 R22
R7 ⟶ N13 N26 R22 ⟶ N1 N26
TIPOE ⟶ N11 R8 F ⟶ N4 R23
R8 ⟶ LONG R9 R23 ⟶ N27 R24
R9 ⟶ N24 R10 R24 ⟶ N31 R25
R10 ⟶ TIPOD N26 R25 ⟶ SD R26
LONG ⟶ N29 R11 R26 ⟶ N32 R27
R11 ⟶ N25 N29 R27 ⟶ N28 R28
LONG ⟶ N29 R12 R28 ⟶ TIPOD R29
R12 ⟶ N25 R13 R29 ⟶ N2 R30
R13 ⟶ N30 R14 R30 ⟶ SP R31
R14 ⟶ N29 R15 R31 ⟶ N5 R32
R15 ⟶ N25 N30 R32 ⟶ RT R33
TIPOD ⟶ ENTERO R33 ⟶ N3 R34
TIPOD ⟶ REAL R34 ⟶ N27 N26
TIPOD ⟶ CARACT F ⟶ N4 R35
TIPOD ⟶ CADENA R35 ⟶ N27 R36
TIPOD ⟶ BOOLEANO R36 ⟶ N31 R37

19
R37 ⟶ SD R38 SS ⟶ N23 R122
R38 ⟶ N32 R39 SS ⟶ N23 R125
R39 ⟶ N2 R40 SS ⟶ N14 R76
R40 ⟶ SP R41 SS ⟶ N14 R83
R41 ⟶ N3 R42 SS ⟶ N21 R94
R42 ⟶ N27 N26 SS ⟶ N17 R101
F ⟶ N4 R43 SS ⟶ SA SS
R43 ⟶ N27 R44 SS ⟶ SL SS
R44 ⟶ N31 R45 SS ⟶ SES SS
R45 ⟶ N32 R46 SS ⟶ SC SS
R46 ⟶ N28 R47 SS ⟶ SI SS
R47 ⟶ TIPOD R48 SA ⟶ REF R66
R48 ⟶ N2 R49 R66 ⟶ N28 R67
R49 ⟶ SP R50 R67 ⟶ N35 R68
R50 ⟶ N5 R51 R68 ⟶ ASIG N26
R51 ⟶ RT R52 REF ⟶ id
R52 ⟶ N3 R53 REF ⟶ N27 R69
R53 ⟶ N27 N26 R69 ⟶ N34 N27
F ⟶ N4 R54 REF ⟶ N27 LONG
R54 ⟶ N27 R55 ASIG ⟶ N27 R70
R55 ⟶ N31 R56 ASIG ⟶ N27 R72
R56 ⟶ N32 R57 ASIG ⟶ OPNDO R74
R57 ⟶ N2 R58 ASIG ⟶ N36 OPNDO
R58 ⟶ SP R59 ASIG ⟶ const
R59 ⟶ N3 R60 ASIG ⟶ id ASIG
R60 ⟶ N27 N26 ⟶ N27 R69
SP ⟶ SD SS ASIG ⟶ N27 LONG
SP ⟶ SD R61 R70 ⟶ N31 R71
R61 ⟶ SS SP R71 ⟶ PEI N32
RT ⟶ const R72 ⟶ N31 N32
RT ⟶ id PEI ⟶ id
RT ⟶ N27 R70 PEI ⟶ N27 R69
RT ⟶ N27 R72 PEI ⟶ N27 LONG
RT ⟶ N27 R62 PEI ⟶ const
R62 ⟶ N34 N27 PEI ⟶ PARI R73
SD ⟶ LID R64 R73 ⟶ N26 PEI
SD ⟶ D R63 PARI ⟶ id
R63 ⟶ N26 SD PARI ⟶ N27 R69
D ⟶ LID R64 PARI ⟶ N27 LONG
R64 ⟶ N28 TIPOV PARI ⟶ const
TIPOV ⟶ ENTERO OPER ⟶ OPNDO R74
TIPOV ⟶ REAL R74 ⟶ OPDOR OPNDO
TIPOV ⟶ CARACT OPER ⟶ N36 OPNDO
TIPOV ⟶ CADENA OPNDO ⟶ const
TIPOV ⟶ BOOLEANO OPNDO ⟶ id
TIPOV ⟶ id OPNDO ⟶ N27 R69
LID ⟶ id OPNDO ⟶ N27 LONG
LID ⟶ N27 R65 OPNDO ⟶ N27 R70
R65 ⟶ N46 LID OPNDO ⟶ N27 R72
SS ⟶ REF R66 OPNDO ⟶ OPNDO R74
SS ⟶ N22 R119 OPNDO ⟶ N36 OPNDO

20
OPNDO ⟶ N31 R75 CPNDO ⟶ N31 R93
R75 ⟶ OPER N32 R93 ⟶ COMP N32
OPDOR ⟶ + CPNDO ⟶ N27 R70
OPDOR ⟶ - CPNDO ⟶ N27 R72
OPDOR ⟶ / CPNDO ⟶ OPNDO R74
OPDOR ⟶ * CPNDO ⟶ N36 OPNDO
OPDOR ⟶ % CPNDO ⟶ const
OPDOR ⟶ & CPNDO ⟶ id
OPDOR ⟶ N43 N43 CPNDO ⟶ N27 R69
OPDOR ⟶ = CPNDO ⟶ N27 LONG
OPDOR ⟶ < CPNDO ⟶ CPNDO R92
OPDOR ⟶ > CPNDO ⟶ N36 CPNDO
OPDOR ⟶ N44 N45 SI ⟶ N21 R94
OPDOR ⟶ N44 N35 R94 ⟶ N31 R95
OPDOR ⟶ N45 N35 R95 ⟶ COND R96
OA ⟶ + R96 ⟶ N32 R97
OA ⟶ - R97 ⟶ N20 R98
OA ⟶ / R98 ⟶ SS R99
OA ⟶ * R99 ⟶ N3 R100
OA ⟶ % R100 ⟶ N21 N26
OR ⟶ = SI ⟶ N17 R101
OR ⟶ < R101 ⟶ VI R102
OR ⟶ > R102 ⟶ N18 R103
OR ⟶ N44 N45 R103 ⟶ VF R104
OR ⟶ N44 N35 R104 ⟶ N19 R105
OR ⟶ N45 N35 R105 ⟶ INDEC R106
SC ⟶ N14 R76 R106 ⟶ N20 R107
R76 ⟶ N31 R77 R107 ⟶ SS R108
R77 ⟶ COND R78 R108 ⟶ N3 R109
R78 ⟶ N32 R79 R109 ⟶ N17 N26
R79 ⟶ N15 R80 VI ⟶ N27 R110
R80 ⟶ SS R81 R110 ⟶ N28 R111
R81 ⟶ N3 R82 R111 ⟶ N35 ASIG
R82 ⟶ N14 N26 VF ⟶ N27 R112
SC ⟶ N14 R83 R112 ⟶ OR CPNDO
R83 ⟶ N31 R84 INDEC ⟶ N27 R113
R84 ⟶ COND R85 R113 ⟶ N28 R114
R85 ⟶ N32 R86 R114 ⟶ N35 R115
R86 ⟶ N15 R87 R115 ⟶ N27 R116
R87 ⟶ SS R88 R116 ⟶ OA OPNDO
R88 ⟶ N16 R89 INDEC ⟶ N27 R117
R89 ⟶ SS R90 R117 ⟶ N37 N37
R90 ⟶ N3 R91 INDEC ⟶ N27 R118
R91 ⟶ N14 N26 R118 ⟶ N38 N38
COND ⟶ N27 R70 SL ⟶ N22 R119
R119 ⟶ N31 R120
COND ⟶ N27 R72
COND ⟶ CPNDO R92 R120 ⟶ REF R121
COND ⟶ N36 OPNDO R121 ⟶ N32 N26
COMP ⟶ CPNDO R92 SES ⟶ N23 R122
R92 ⟶ OR CPNDO R122 ⟶ N31 R123
COMP ⟶ N36 OPNDO R123 ⟶ OPNDO R124

21
R124 ⟶ N32 N26 N22 ⟶ LEER
SES ⟶ N23 R125 N23 ⟶ ESCRIBIR
R125 ⟶ N31 R126 N24 ⟶ DE
R126 ⟶ OPER R127 N25 ⟶ NE
R127 ⟶ N32 N26 N26 ⟶ ;
N1 ⟶ PRINCIPAL N27 ⟶ id
N2 ⟶ INICIO N28 ⟶ :
N3 ⟶ FIN N29 ⟶ [
N4 ⟶ PROCEDIMIENTO N30 ⟶ ]
N5 ⟶ RETORNAR N31 ⟶ (
N6 ⟶ ENTERO N32 ⟶ )
N7 ⟶ REAL N33 ⟶ const
N8 ⟶ CARACT N34 ⟶ .
N9 ⟶ CADENA N35 ⟶ =
N10 ⟶ BOOLEANO N36 ⟶ !
N11 ⟶ ARREGLO N37 ⟶ +
N12 ⟶ TIPO N38 ⟶ -
N13 ⟶ REGISTRO N39 ⟶ /
N14 ⟶ SI N40 ⟶ *
N15 ⟶ ENTONCES N41 ⟶ %
N16 ⟶ SINO N42 ⟶ &
N17 ⟶ PARA N43 ⟶ |
N18 ⟶ HASTA N44 ⟶ <
N19 ⟶ CON N45 ⟶ >
N20 ⟶ HACER N46 ⟶ , }
N21 ⟶ MIENTRAS

En las reglas de producción, podemos observar claramente que cada una de


estas reglas tiene la forma: A → BC ó A → b, donde A,B,C ∈ VN y b ∈ VT.
Entonces, a partir de estas reglas de producción, podemos concluir que la
gramática G* se encuentra en la Forma Normal de Chomsky (FNC)

22
2.2.4. Construcción de la tabla de análisis sintáctico

 Eliminación de la Recursividad por la izquierda

En la gramática G* existen dos reglas que presentan recursividad por la


izquierda:

OPNDO ⟶ OPNDO R74


CPNDO ⟶ CPNDO R92

Para construir la tabla de análisis sintáctico, primero debemos eliminar la


recursividad por la izquierda de estas dos reglas [1], para ello
reemplazaremos estas reglas:

OPNDO ⟶ const CPNDO ⟶ N31 R93


OPNDO ⟶ id CPNDO ⟶ N27 R70
OPNDO ⟶ N27 R69 CPNDO ⟶ N27 R72
OPNDO ⟶ N27 LONG CPNDO ⟶ OPNDO R74
OPNDO ⟶ N27 R70 CPNDO ⟶ N36 OPNDO
OPNDO ⟶ N27 R72 CPNDO ⟶ const
OPNDO ⟶ OPNDO R74 CPNDO ⟶ id
OPNDO ⟶ N36 OPNDO CPNDO ⟶ N27 R69
OPNDO ⟶ N31 R75 CPNDO ⟶ N27 LONG
CPNDO ⟶ CPNDO R92
CPNDO ⟶ N36 CPNDO

Por estas:

OPNDO ⟶ const A’ CPNDO ⟶ N31 R93 B’


OPNDO ⟶ id A’ CPNDO ⟶ N27 R70 B’
OPNDO ⟶ N27 R69 A’ CPNDO ⟶ N27 R72 B’
OPNDO ⟶ N27 LONG A’ CPNDO ⟶ OPNDO R74 B’
OPNDO ⟶ N27 R70 A’ CPNDO ⟶ N36 OPNDO B’
OPNDO ⟶ N27 R72 A’ CPNDO ⟶ const B’
OPNDO ⟶ N36 OPNDO A’ CPNDO ⟶ id B’
OPNDO ⟶ N31 R75 A’ CPNDO ⟶ N27 R69 B’
A’ ⟶ R74 A’ CPNDO ⟶ N27 LONG B’
A’ ⟶ 𝜆 CPNDO ⟶ N36 CPNDO B’
B’ ⟶ R92 B’
B’ ⟶ 𝜆

23
 Definición de los conjuntos PRIMERO y SIGUIENTE

Para construir la Tabla de análisis sintáctico, es necesario construir los


conjuntos PRIMERO (Para cada uno de los símbolos terminales y no
terminales) y SIGUIENTE (Para cada símbolo no terminal)

PRIMERO

A PRIMERO(A)
PRINCIPAL { PRINCIPAL }
INICIO { INICIO }
FIN { FIN }
PROCEDIMIENTO { PROCEDIMIENTO }
RETORNAR { RETORNAR }
ENTERO { ENTERO }
REAL { REAL }
CARACT { CARACT }
CADENA { CADENA }
BOOLEANO { BOOLEANO }
ARREGLO { ARREGLO }
DE { DE }
TIPO { TIPO }
REGISTRO { REGISTRO }
SI { SI }
ENTONCES { ENTONCES }
SINO { SINO }
PARA { PARA }
HASTA { HASTA }
CON { CON }
HACER { HACER }
MIENTRAS { MIENTRAS }
LEER { LEER }
ESCRIBIR { ESCRIBIR }
NE { NE }
; {;}
id { id }
: {:}
[ {[}
] {]}
( {(}
) {)}
const { const }
. {.}
= {=}
! {!}
+ {+}
- {-}
/ {/}
* {*}
% {%}
& {&}
| {|}

24
< {<}
> {>}
, {,}
T { PROCEDIMIENTO, TIPO }
SE { TIPO }
LVE { id }
VE { id }
TIPOE { REGISTRO, ARREGLO }
LONG {[}
TIPOD { ENTERO, REAL, CARACT, CADENA, BOOLEANO }
SF { PROCEDIMIENTO }
LF { PROCEDIMIENTO }
FP { PROCEDIMIENTO }
F { PROCEDIMIENTO }
SP { id }
RT { const, id }
SD { id }
D { id }
TIPOV { ENTERO, REAL, CARACT, CADENA, BOOLEANO, id }
LID { id }
SS { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
SA { id }
REF { id }
ASIG { const, id, (, ! }
PEI { id, const }
PARI { id, const }
OPER { const, id, (, ! }
OPDOR { +, -, /, *, %, &, |, =, <, > }
OPNDO { const, id, (, ! }
OA { +, -, /, *, % }
OR { =, <, > }
SC { SI }
COND { const, id, (, ! }
COMP { const, id, (, ! }
CPNDO { const, id, (, ! }
SI { PARA, MIENTRAS }
VI { id }
VF { id }
INDEC { id }
SL { LEER }
SES { ESCRIBIR }
A’ { +, -, /, *, %, &, |, =, <, >, 𝜆 }
B’ { =, <, >, 𝜆 }
N1 { PRINCIPAL }
N2 { INICIO }
N3 { FIN }
N4 { PROCEDIMIENTO }
N5 { RETORNAR }
N6 { ENTERO }
N7 { REAL }
N8 { CARACT }
N9 { CADENA }

25
N10 { BOOLEANO }
N11 { ARREGLO }
N12 { TIPO }
N13 { REGISTRO }
N14 { SI }
N15 { ENTONCES }
N16 { SINO }
N17 { PARA }
N18 { HASTA }
N19 { CON }
N20 { HACER }
N21 { MIENTRAS }
N22 { LEER }
N23 { ESCRIBIR }
N24 { DE }
N25 { NE }
N26 {;}
N27 { id }
N28 {:}
N29 {[}
N30 {]}
N31 {(}
N32 {)}
N33 { const }
N34 {.}
N35 {=}
N36 {!}
N37 {+}
N38 {-}
N39 {/}
N40 {*}
N41 {%}
N42 {&}
N43 {|}
N44 {<}
N45 {>}
N46 {,}
R1 { id }
R2 { FIN }
R3 { TIPO }
R4 {:}
R5 { id }
R6 { FIN }
R7 { REGISTRO }
R8 {[}
R9 { DE }
R10 { ENTERO, REAL, CARACT, CADENA, BOOLEANO }
R11 { NE }
R12 { NE }
R13 {]}
R14 {[}
R15 { NE }

26
R16 { PRINCIPAL }
R17 {(}
R18 {)}
R19 { INICIO }
R20 { id }
R21 { FIN }
R22 { PRINCIPAL }
R23 { id }
R24 {(}
R25 { id }
R26 {)}
R27 {:}
R28 { ENTERO, REAL, CARACT, CADENA, BOOLEANO }
R29 { INICIO }
R30 { id }
R31 { RETORNAR }
R32 { const, id }
R33 { FIN }
R34 { id }
R35 { id }
R36 {(}
R37 { id }
R38 {)}
R39 { INICIO }
R40 { id }
R41 { FIN }
R42 { id }
R43 { id }
R44 {(}
R45 {)}
R46 {:}
R47 { ENTERO, REAL, CARACT, CADENA, BOOLEANO }
R48 { INICIO }
R49 { id }
R50 { RETORNAR }
R51 { const, id }
R52 { FIN }
R53 { id }
R54 { id }
R55 {(}
R56 {)}
R57 { INICIO }
R58 { id }
R59 { FIN }
R60 { id }
R61 { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R62 {.}
R63 {;}
R64 {:}
R65 {,}
R66 {:}
R67 {=}

27
R68 { const, id, (, ! }
R69 {.}
R70 {(}
R71 { id, const }
R72 {(}
R73 {;}
R74 { +, -, /, *, %, &, |, =, <, > }
R75 { const, id, (, ! }
R76 {(}
R77 { const, id, (, ! }
R78 {)}
R79 { ENTONCES }
R80 { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R81 { FIN }
R82 { SI }
R83 {(}
R84 { const, id, (, ! }
R85 {)}
R86 { ENTONCES }
R87 { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R88 { SINO }
R89 { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R90 { FIN }
R91 { SI }
R92 { =, <, > }
R93 { const, id, (, ! }
R94 {(}
R95 { const, id, (, ! }
R96 {)}
R97 { HACER }
R98 { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R99 { FIN }
R100 { MIENTRAS }
R101 { id }
R102 { HASTA }
R103 { id }
R104 { CON }
R105 { id }
R106 { HACER }
R107 { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R108 { FIN }
R109 { PARA }
R110 {:}
R111 {=}
R112 { =, <, > }
R113 {:}
R114 {=}
R115 { id }
R116 { +, -, /, *, % }
R117 {+}
R118 {-}
R119 {(}

28
R120 { id }
R121 {)}
R122 {(}
R123 { const, id, (, ! }
R124 {)}
R125 {(}
R126 { const, id, (, ! }
R127 {)}

SIGUIENTE

A SIGUIENTE(A)
T {$}
SE { PROCEDIMIENTO }
LVE { FIN }
VE { id }
TIPOE { FIN, id }
LONG { DE, :, ;, ), +, -, /, *, %, &, |, =, <, >, HACER, HASTA, CON }
TIPOD { ;, INICIO }
SF {$}
LF { PROCEDIMIENTO }
FP {$}
F { PROCEDIMIENTO }
SP { FIN, RETORNAR }
RT { FIN }
SD { FIN, ), id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
D {;}
TIPOV { FIN, ), id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, ; }
LID {:}
SS { FIN, RETORNAR, id, SINO }
SA { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
REF { :, ) }
ASIG { ;, HASTA }
PEI {)}
PARI {;}
OPER {)}
OPDOR { const, id, (, ! }
OPNDO { +, -, /, *, %, &, |, =, <, >, ;, ), HACER, HASTA, CON }
OA { const, id, (, ! }
OR { const, id, (, ! }
SC { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
COND {)}
COMP {)}
CPNDO { =, <, >, ), CON }
SI { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
VI { HASTA }
VF { CON }
INDEC { HACER }
SL { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
SES { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
30
A’ { +, -, /, *, %, &, |, =, <, >, ;, ) , HACER, HASTA, CON }
B’ { =, <, >, ) , CON }
N1 { (, ; }
N2 { id }
N3 { TIPO, REGISTRO, PRINCIPAL, id, SI, MIENTRAS, PARA }
N4 { PRINCIPAL, id }
N5 { const, id }
N6 { }
N7 { }
N8 { }
N9 { }
N10 { }
N11 {[}
N12 { id, ; }
N13 { id, ; }
N14 { (, ; }
N15 { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
N16 { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
N17 { id, ; }
N18 { id }
N19 { id }
N20 { id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
N21 { (, ; }
N22 {(}
N23 {(}
N24 { ENTERO, REAL, CARACT, CADENA, BOOLEANO }
N25 { [, ] }
N26 { $, PROCEDIMIENTO, FIN, id, RETORNAR, LEER, ESCRIBIR, SI, MIENTRAS, PARA, const, SINO }
N27 { :, (, ;, ., FIN, , , [, ), +, -, /, *, %, &, |, =, <, >, HACER, HASTA, CON }
N28 { REGISTRO, ARREGLO, ENTERO, REAL, CARACT, CADENA, BOOLEANO, id, = }
N29 { NE, DE, :, ;, ), +, -, /, *, %, &, |, =, <, >, HASTA, HACER, CON }
N30 { [, DE, :, ;, ) , +, -, /, *, %, &, |, =, <, >, HASTA, HACER, CON }
N31 { ), id, const, (, ! }
N32 { INICIO, :, FIN, ;, +, -, /, *, %, &, |, =, <, >, ), ENTONCES, HACER, HASTA, CON }
N33 { }
N34 { id }
N35 { const, id, (, ! }
N36 { const, id, (, ! }
N37 { HACER, + }
N38 { HACER, - }
N39 { }
N40 { }
N41 { }
N42 { }
N43 { |, const, id, (, ! }
N44 { >, = }
N45 { const, id, (, !, = }
N46 { id }
R1 { PROCEDIMIENTO }
R2 { PROCEDIMIENTO }
R3 { PROCEDIMIENTO }
R4 { FIN, id }

31
R5 { FIN, id }
R6 { FIN, id }
R7 { FIN, id }
R8 { FIN, id }
R9 { FIN, id }
R10 { FIN, id }
R11 { DE, :, ;, ), +, -, /, *, %, &, |, =, <, >, HASTA, HACER, CON }
R12 { DE, :, ;, ), +, -, /, *, %, &, |, =, <, >, HASTA, HACER, CON }
R13 { DE, :, ;, ), +, -, /, *, %, &, |, =, <, >, HASTA, HACER, CON }
R14 { DE, :, ;, ), +, -, /, *, %, &, |, =, <, >, HASTA, HACER, CON }
R15 { DE, :, ;, ), +, -, /, *, %, &, |, =, <, >, HASTA, HACER, CON }
R16 {$}
R17 {$}
R18 {$}
R19 {$}
R20 {$}
R21 {$}
R22 {$}
R23 { PROCEDIMIENTO }
R24 { PROCEDIMIENTO }
R25 { PROCEDIMIENTO }
R26 { PROCEDIMIENTO }
R27 { PROCEDIMIENTO }
R28 { PROCEDIMIENTO }
R29 { PROCEDIMIENTO }
R30 { PROCEDIMIENTO }
R31 { PROCEDIMIENTO }
R32 { PROCEDIMIENTO }
R33 { PROCEDIMIENTO }
R34 { PROCEDIMIENTO }
R35 { PROCEDIMIENTO }
R36 { PROCEDIMIENTO }
R37 { PROCEDIMIENTO }
R38 { PROCEDIMIENTO }
R39 { PROCEDIMIENTO }
R40 { PROCEDIMIENTO }
R41 { PROCEDIMIENTO }
R42 { PROCEDIMIENTO }
R43 { PROCEDIMIENTO }
R44 { PROCEDIMIENTO }
R45 { PROCEDIMIENTO }
R46 { PROCEDIMIENTO }
R47 { PROCEDIMIENTO }
R48 { PROCEDIMIENTO }
R49 { PROCEDIMIENTO }
R50 { PROCEDIMIENTO }
R51 { PROCEDIMIENTO }
R52 { PROCEDIMIENTO }
R53 { PROCEDIMIENTO }
R54 { PROCEDIMIENTO }
R55 { PROCEDIMIENTO }
R56 { PROCEDIMIENTO }

32
R57 { PROCEDIMIENTO }
R58 { PROCEDIMIENTO }
R59 { PROCEDIMIENTO }
R60 { PROCEDIMIENTO }
R61 { FIN, RETORNAR }
R62 { FIN }
R63 { FIN, ), id, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R64 { FIN, ), id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, ; }
R65 {:}
R66 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R67 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R68 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R69 { :, ;, ), +, -, /, *, %, &, |, =, <, >, HACER, HASTA, CON }
R70 { FIN, ;, +, -, /, *, %, &, |, =, <, >, ), HACER, HASTA, CON }
R71 { FIN, ;, +, -, /, *, %, &, |, =, <, >, ), HACER, HASTA, CON }
R72 { FIN, ;, +, -, /, *, %, &, |, =, <, >, ), HACER, HASTA, CON }
R73 {)}
R74 { ;, ), +, -, /, *, %, &, |, =, <, >, HASTA, CON }
R75 { +, -, /, *, %, &, |, =, <, >, ;, ), HACER, HASTA, CON }
R76 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R77 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R78 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R79 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R80 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R81 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R82 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R83 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R84 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R85 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R86 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R87 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R88 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R89 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R90 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R91 { FIN, RETORNAR, id, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SINO }
R92 { ), =, <, > }
R93 { =, <, >, ) , CON }
R94 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R95 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R96 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R97 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R98 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R99 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R100 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R101 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R102 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R103 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R104 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R105 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R106 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R107 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R108 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }

33
R109 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R110 { HASTA }
R111 { HASTA }
R112 { CON }
R113 { HACER }
R114 { HACER }
R115 { HACER }
R116 { HACER }
R117 { HACER }
R118 { HACER }
R119 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R120 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R121 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R122 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R123 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R124 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R125 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R126 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }
R127 { FIN, RETORNAR, id, SINO, LEER, ESCRIBIR, SI, MIENTRAS, PARA }

2.2.5. Errores Sintácticos

Los posibles errores sintácticos que se pueden presentar en nuestro


lenguaje son los siguientes:

 El analizador lexicográfico entrega un lexema perteneciente a un


componente léxico no esperado.

 Ausencia de algún lexema esperado

 El programa fuente no satisface la gramática definida

 Ambigüedad de la gramática para algún programa fuente (existencia


de dos o más árboles sintácticos). Nota: Con respecto a este último
error, se ha tratado de construir una gramática de modo tal que este
error no suceda, sin embargo no se descarta que en algún momento
pueda suceder para algún programa fuente dado.

34
2.3. ANALIZADOR SEMÁNTICO

Se compone de un conjunto de rutinas independientes, llamadas por


los analizadores morfológico y sintáctico.

El análisis semántico utiliza como entrada el árbol sintáctico detectado


por el análisis sintáctico para comprobar restricciones de tipo y otras
limitaciones semánticas y preparar la generación de código.

En compiladores de un solo paso, las llamadas a las rutinas semánticas


se realizan directamente desde el analizador sintáctico y son dichas
rutinas las que llaman al generador de código. El instrumento más
utilizado para conseguirlo es la gramática de atributos.

En compiladores de dos o más pasos, el análisis semántico se realiza


independientemente de la generación de código, pasándose
información a través de un archivo intermedio, que normalmente
contiene información sobre el árbol sintáctico en forma linealizada
(para facilitar su manejo y hacer posible su almacenamiento en
memoria auxiliar).

En cualquier caso, las rutinas semánticas suelen hacer uso de una pila
(la pila semántica) que contiene la información semántica asociada a
los operandos (y a veces a los operadores) en forma de registros
semánticos.

35
3. EJEMPLOS DE PROGRAMAS EN LENGUAJE TURING

TIPO
Producto: REGISTRO
codigo, cantidad: ENTERO;
precio: REAL;
FIN

ListaProductos: ARREGLO[50] DE Producto;

PROCEDIMIENTO PRINCIPAL();

INICIO
cod, cant: ENTERO;
prec: REAL;
ret: BOOLEANO;
listaP: ListaProductos;
numProductos: ENTERO;
opc : CADENA;

ESCRIBIR('Desea llenar registros?');


LEER(opc);
MIENTRAS (opc = SI )
ESCRIBIR('Ingrese el codigo: ');
LEER(cod);
ESCRIBIR('Ingrese la cantidad: ');
LEER(cant);
ESCRIBIR('Ingrese el precio: ');
LEER(prec);
ret := registrarProducto(cod, cant, numProductos, prec);
SI ret ENTONCES
ESCRIBIR('EL INGRESO SE HA HECHO CORRECTAMENTE');
SINO
ESCRIBIR('HA OCURRIDO UN ERROR');
FIN;
ESCRIBIR('Desea llenar mas registros?');
LEER(opc);
FIN

FIN PRINCIPAL;

PROCEDIMIENTO registrarProducto (codigo, cantidad, numProductos:


ENTERO; precio: REAL): BOOLEANO;
INICIO
Producto produ;
produ.cantidad := cantidad;
produ.codigo := codigo;
produ.precio := precio;
listaP[numProductos] := produ;
numProductos := numProductos + 1;
RETORNAR VERDAD
FIN registrarProducto;

PROCEDIMIENTO mostrarProducto();
INICIO
PARA i:=1 HASTA numProductos HACER
ESCRIBIR(listaP[i].codigo);
ESCRIBIR(listaP[i].nombre);
ESCRIBIR(listaP[i].precio);
FIN;

36
FIN mostrarProducto;

37
4. MANEJO DE ERRORES

El manejo de errores se maneja en la salida del analizador léxico, cuando el analizador léxico
detecta un token que no pertence a ninguna categoría / componente léxico entonces etiqueta
a este token con “ERROR” y luego te indica el error.

5. IMPLEMENTACIÓN

Se muestra la interfaz con un correcto funcionamiento:

38
Cuando se produce algún error léxico, es decir el token no se encuentra en ninguna categoría,
el programa informa de ello:

39
CONCLUSIONES

40
REFERENCIAS BIBLIOGRAFICAS

1. Guía V – Análisis Sintáctico. Curso Lenguajes y Traductores.


Prof. Augusto Cortez Vásquez. 2014

2. http://www.lpsi.eui.upm.es/webteolp/Documentation/Felix/Tem
a%204.pdf

3. http://informatica.uv.es/docencia/iiguia/asignatu/2000/PL/200
7/tema3.pdf

41