Está en la página 1de 100

UNIVERSIDAD AUTONOMA DE COLOMBIA

FACULTAD DE INGENIERIA
PROGRAMA INGENIERIA DE SISTEMAS

APUNTES DE CLASE DE COMPILADORES LENGUAJE ARTIFICIAL


DNDA No. 10-823-186
27-sep-2019

DOCENTE: MARIO DUSTANO CONTRERAS CASTRO


HORA CATEDRA

BOGOTA, SEPTIEMBRE 2019


ETAPAS EN LA COMPILACION

Desde un punto de vista lógico, la Compilación se puede dividir en dos partes


principales: el análisis del programa fuente y la síntesis del programa objeto. En casi
todos los compiladores estas etapas no están claramente separadas.

Análisis del programa fuente


Para el compilador, el programa fuente es una larga secuencia de símbolos. Durante la
Compilación debe construir, carácter por carácter, un análisis de la estructura del
programa.
Análisis Léxico: La tarea fundamental de este componente es agrupar esta serie de
caracteres en sus componentes elementales: identificadores, delimitadores, símbolos de
operadores, palabras clave, palabras opcionales, espacios, comentarios, etc.
El analizador léxico debe identificar el tipo de cada elemento léxico (tokens) y adjuntar
una marca de naturaleza. Además, se suele hacer la conversión a una representación
interna de elementos como números, identificadores (que se guardan en unas tabla de
símbolos y se usa la dirección de entrada a la tabla en lugar de la cadena de caracteres).
Análisis Sintáctico: (parsing). En esta etapa se identifican estructuras de programa más
grandes (instrucciones, declaraciones, expresiones, etc.) usando los elementos léxicos
entregados por el analizador léxico. Las etapas del analizador sintáctico son:
- Etapa Recursiva. Búsqueda de Palabras Reservadas dentro de una instrucción o
sentencia.
- Etapa Nivel. Relaciona las sentencias recursivas con un nivel de lenguaje (
enunciado de programa, declaración, cuerpo de programa, etc.)
- Etapa Bloque. Orientado al cuerpo del programa, donde, las sentencias que
indican el inicio de un bloque de sentencias deben poseer un final del mismo. Por
lo general, el analizador sintáctico introduce una pila (automáta de pila)
- Etapa de Cadena Sintáctica. Se analiza la secuencia de elementos léxicos
(tokens) dentro de un sentencia (reglas basadas en gramáticas formales).
Análisis Semántico: Aquí se procesan las estructuras sintácticas y comienza a tomar
forma el código objeto. El análisis y la síntesis de la Compilación.
El analizador semántico se divide, generalmente, en un conjunto de analizadores más
pequeños cada uno de los cuales maneja un tipo particular de estructura sintáctica.
Las funciones exactas de los analizadores semánticos varían considerablemente,
según el lenguaje y la organización lógica del traductor.
Algunas de las funciones más comunes son:
1.- Mantenimiento de tablas de símbolos.
Las tablas de símbolos tienen una entrada por identificador; las entradas son creadas
por el analizador léxico, pero otros datos como tipo (variable simple, nombre de arreglo,
nombre de subprograma, parámetro formal, etc.), tipo de valor, entorno de referencia
(global local) y cualquier otra información obtenida de las declaraciones. Los analizadores
semánticas introducen esta información a medida que se encuentran declaraciones,
encabezados de subprogramas, comandos, etc. Normalmente la tabla de símbolos se
desecha después de la Compilación, pero en algunos lenguajes interpretados se puede
guardar para la ejecución.
2.- Inserción de información implícita. Información, que debe hacerse explícita en
lenguajes de más bajo nivel; normalmente está basada en convenciones. Ej. En
FORTRAN variables enteras y reales se declaran implícitamente, su tipo depende de la
letra inicial.
3.- Detección de errores; por ejemplo el uso de tres subíndices en una variable declarada
con dos dimensiones.
4.- Procesamiento de macro y operaciones en tiempo de compilación. No todos los
lenguajes incluyen estas capacidades, pero cuando están presentes, el procesamiento se
maneja comúnmente en el análisis semántico. Ej. Operación en tiempo compilación " #
define " de C.
Síntesis del Programa Objeto
Esta fase implica necesariamente generación de código y también puede incluir
optimización. Si los subprogramas se traducen por separado entonces también se debe
incluir una etapa de encadenamiento.
Optimización: El analizador semántico produce como salida el programa ejecutable en
algún código intermedio, una representación interna como una cadena de operadores y
operandos; a partir de la cual se genera el código objeto. Pero antes de generar el cógido
final se realiza una optimización de la representación interna. Típicamente, el analizador
semántico genera el programa interno en forma irregular, conforme se analiza cada
segmento, lo que puede producir código extremadamente ineficiente; por ejemplo
almacenar un dato al final de un segmento y cargarlo al inicio del segmento
inmediatamente siguiente.
Generación de código: después que se ha optimizado la representación interna se debe
generar el código de salida.

Código Interno
* ( id2, id3, temp1)
+ ( temp1, id4, temp2 )
: = ( id1, temp2 )
Assembler Código objeto
LOAD B LOAD B
MULT C MULT C
STORE T1 ADD D
LOAD T1 STORE A
ADD D
STORE T2
LOAD T2
STORE A
ETAPA LEXICA

APUNTES DE CLASE DE COMPILADORES LENGUAJE ARTIFICIAL


UNIVERSIDAD AUTONOMA
ELECTIVA: COMPILADORES
LEXICO

ANTECEDENTE
Para describir la gramática del compilador se utilizara la Forma Backus Neur (BNF). El
profesor hace uso de las siguientes formas:
< > Elemento No Terminal – Compuesto de ó define
:- Se Define como ó compuesto de
… Sucesión
() Agrupa
max


min
Ind

ESTRUCTURA SIMBOLO
SIMBOLO: CHAR
NIVEL: ENTERO
SIG: *SIMBOLO
FIN ESTRUCTURA SIMBOLO

TABLA DE SIMBOLOS POR NIVEL

NIVEL <SIMBOLO>
0 <blanco>:-
1 <mayuscula>:-|A|B|...|Z|
2 <minuscula>:-|a|b|...|z|
3 <digito>:-|0|1|...|9|
4 <Aritmeticos>:- |+|-|*|/
5 <Relacion>:- |<|>
6 <Logicos>:- | & | |(Alt 124)
7 <Asignacion>:- =
8 (
9 )
NODO DE SIMBOLO

VOCABULARIO COMO UNA LISTA DE SIMBOLOS

CONTENIDO DEL ARCHIVO LEXICO

0A1B1C1D1E1F1G1H1I1J1K1L1M1N1O1P1Q1R1S1T1U1V1W1X1Y1Z1a2b2c2d2e2f2g2
h2i2j2k2l2m2n2o2p2q2r2s2t2u2v2w2x2y2z203132333435363738393+4-
4*4/4<5>5&6|6=7(8)9
Se interpreta como una sucesión de símbolo nivel ejemplo: A1

ESTRUCTURA LINEAS
LINEA: ENTERO
CONTEO: ENTERO
NUMERO: ENTERO
CAB: *SIMBOLO
SIG: *LINEAS
FIN ESTRUCTURA LINEAS
Dónde:
LINEA: NUMERO DE LINEA
CONTEO: CONTADOR DE CARACTERES DEL PROGRAMA
NUMERO: CONTADOR POR SIMBOLOS POR LINEA
CAB: APUNTADOR LISTA DE SIMBOLOS
SIG: APUNTADOR A LA SIGUIENTE LINEA

NODO DE LINEAS
PROGRAMA FUENTE VISTO COMO UNA MULTILISTA DE SIMBOLOS

VARIABLES
CAB, P, ULT: *SIMBOLO // APUNTADORES DE SIMBOLOS (CAB: APUNTA AL PRIMER
SIMBOLO, P: NUEVO SIMBOLO, ULT: ULTIMO SIMBOLO ADICIONADO)
CABL, ULTL, PL: *LINEAS // APUNTADORES DE LINEAS (CABL: APUNTA A LA
PRIMERA LINEA, PL: NUEVA LINEA, ULTL: ULTIMA LINEA ADICIONADA)
ULTS, PS: *SIMBOLO // APUNTADORES DE SIMBOLOS POR LINEA, donde se
representa como:
PL->CAB: APUNTA AL PRIMER SIMBOLO DE LA LINEA
PS: NUEVO SIMBOLO DE LA LINEA
ULTS: ULTIMA SIMBOLO ADICIONADO EN LA LINEA
S: ENTERO //CONTADOR DE CARACTERES DEL PROGRAMA FUENTE
L: ENTERO // CONTADOR DE LINEAS DEL PROGRAMA FUENTE
E: ENTERO // CONTADOR DE ERRORES
NOTA. El símbolo \n se toma como salto de línea
SUBPROGRAMAS

SUBPROGRAMA CARGARLEXICO(ARCHIVO) //CARGA EL ARCHIVO LEXICO.TXT


EN LA LISTA DE SIMBOLOS
CAB=P=ULT=NULL
SIMB=VERDAD //SIMB=TRUE ES SIMBOLO SIMB=FALSE ES NIVEL
ABRIR(ARCHIVO)
MIENTRAS QUE NOT EOF(ARCHIVO) HAGA
C=LECTURA(ARCHIVO,1) //SE LEE CARÁCTER A CARACTER
SI SIMB ENTONCES
PEDIR(P) //SI ESTA EN ESTADO DE SIMBOLO SE CREA UN NODO Y SE COLOCA
EL SIMBOLO
SI CAB==NULL ENTONCES
CAB=P
SINO
ULT->SIG=P
FINSI
P->SIG=NULL
P->SIMBOLO=C
SINO //SI NO ESTA EN ESTADO SIMBOLO SE COLOCA NIVEL
P->NIVEL=C
FINSI
NEGAR(SIMB)
FIN MIENTRASQUE
FINSUBPROGRAMA

SUBPROGRAMA EXISTE (CHAR C)//VERIFICA SI EL CHAR C ESTA EN LA LISTA DE


SIMBOLOS
P = CAB
MIENTRAS QUE P NOT IGUAL A NULL && P->SIMBOLO NOT IGUAL A C
P= P->SIG
FIN - MIENTRAS QUE
SI P NOT IGUAL A NULL ENT
RETURN P->NIVEL //RETORNA EL NIVEL SI EL SIMBOLO EXISTE
SINO
RETURN -1 //RETORNA -1 SI EL SIMBOLO NO EXISTE
FIN - SI
FINSUBPROGRAMA

SUBPROGRAMA AGREGARLINEA ()
PEDIR (PL)
SI CABL == NULL ENT
CABL = PL
SINO
ULTL ->SIG = PL
FIN -SI
ULTL = PL
PL->SIG=NULL
L=L+1
PL->LINEA=L
PL->CONTEO=S
PL->NUMERO = 0
PL ->SIG = NULL
PL->CAB= ULTS= PS=NULL // SE INICIALIZA LA LISTA DE SIMBOLOS DE LA LINEA
FIN SUBPROGRAMA

SUBPROGRAMA AGREGARSIMBOLO (CHAR C)


S=S+1
PL->NUMERO=PL->NUMERO+1
PEDIR(PS)
SI PL->CAB==NULL ENT
PL->CAB= PS
SINO
ULTS->SIG= PS
FINSI
ULTS= PS
PS->SIG=NULL
PS->SIMBOLO=C
PS->NIVEL=EXISTE(C)
SI PS->NIVEL==-1 ENT
E=E+1
ESCRIBA “SIMBOLO: “, C,” LINEA: “,L,” CARÁCTER NUMERO: “,PL->NUMERO,”
NO ES VALIDO”
FINSI
FIN SUBPROGRAMA

SUBPROGRAMA LECTURAFUENTE(ARCHIVO)
ABRIR(ARCHIVO)
MIENTRAS QUE NOT EOF (ARCHIVO)
MIENTRAS QUE NOT EOF (ARCHIVO) && (C=LECTURA(ARCHIVO,1))==\n HAGA
L=L+1
FIN - MIENTRAS QUE
SI NOT EOF (ARCHIVO) ENT
AGREGARLINEA()
AGREGARSIMBOLO( C )
MIENTRAS QUE NOT EOF (ARCHIVO) && (C=LECTURA(ARCHIVO,1)) NOT IGUAL
A \n HAGA
AGREGARSIMBOLO( C )
FIN - MIENTRAS QUE
FINSI
FIN - MIENTRAS QUE
FIN SUBPROGRAMA

PROGRAMAPRINCIPAL ()
S=L=E=0
SI NO EXISTE(“LEXICO.TXT”) || NO EXISTE(“FUENTE.TXT”)ENT
SALIR()
FIN SI
CARGARLEXICO(“LEXICO.TXT”)
LECTURAFUENTE(“FUENTE.TXT”)
FIN PROGRAMAPRINCIPAL
ETAPA MORFOLOGICA

APUNTES DE CLASE DE COMPILADORES LENGUAJE ARTIFICIAL


UNIVERSIDAD AUTONOMA
ELECTIVA: COMPILADORES
MORFOLOGIA
MORFOLOGIA PASO 1

ANTECEDENTE LEXICO

ESTRUCTURA SIMBOLO
SIMBOLO: CHAR
NIVEL: ENTERO
SIG: *SIMBOLO
FIN ESTRUCTURA SIMBOLO

TABLA DE SIMBOLOS POR NIVEL

NIVEL <SIMBOLO>
0 <blanco>:-
1 <mayuscula>:-|A|B|...|Z|
2 <minuscula>:-|a|b|...|z|
3 <digito>:-|0|1|...|9|
4 <Aritmeticos>:- |+|-|*|/
5 <Relacion>:- |<|>
6 <Logicos>:- | & | |(Alt 124)
7 <Asignacion>:- =
8 (
9 )

NODO DE SIMBOLO
VOCABULARIO COMO UNA LISTA DE SIMBOLOS

CONTENIDO DEL ARCHIVO LEXICO

0A1B1C1D1E1F1G1H1I1J1K1L1M1N1O1P1Q1R1S1T1U1V1W1X1Y1Z1a2b2c2d2e2f2g2
h2i2j2k2l2m2n2o2p2q2r2s2t2u2v2w2x2y2z203132333435363738393+4-
4*4/4<5>5&6|6=7(8)9
Se interpreta como una sucesión de símbolo nivel ejemplo: A1

ESTRUCTURA LINEAS
LINEA: ENTERO
CONTEO: ENTERO
NUMERO: ENTERO
CAB: *SIMBOLO
SIG: *LINEAS
FIN ESTRUCTURA LINEAS

Dónde:
LINEA: NUMERO DE LINEA
CONTEO: CONTADOR DE CARACTERES DEL PROGRAMA
NUMERO: CONTADOR POR SIMBOLOS POR LINEA
CAB: APUNTADOR LISTA DE SIMBOLOS
SIG: APUNTADOR A LA SIGUIENTE LINEA
NODO DE LINEAS

PROGRAMA FUENTE VISTO COMO UNA MULTILISTA DE SIMBOLOS

VARIABLES
CAB, P, ULT: *SIMBOLO // APUNTADORES DE SIMBOLOS (CAB: APUNTA AL PRIMER
SIMBOLO, P: NUEVO SIMBOLO, ULT: ULTIMO SIMBOLO ADICIONADO)
CABL, ULTL, PL: *LINEAS // APUNTADORES DE LINEAS (CABL: APUNTA A LA
PRIMERA LINEA, PL: NUEVA LINEA, ULTL: ULTIMA LINEA ADICIONADA)
ULTS, PS: *SIMBOLO // APUNTADORES DE SIMBOLOS POR LINEA, donde se
representa como:
PL->CAB: APUNTA AL PRIMER SIMBOLO DE LA LINEA
PS: NUEVO SIMBOLO DE LA LINEA
ULTS: ULTIMA SIMBOLO ADICIONADO EN LA LINEA
S: ENTERO //CONTADOR DE CARACTERES DEL PROGRAMA FUENTE
L: ENTERO // CONTADOR DE LINEAS DEL PROGRAMA FUENTE
E: ENTERO // CONTADOR DE ERRORES
NOTA. El símbolo \n se toma como salto de línea

INICIO DE MORFOLOGIA

ESTRUCTURA PALABRA
CONTEO: ENTERO
NIVEL: ENTERO
CAB: *SIMBOLO
SIG: *PALABRA
FIN ESTRUCTURA PALABRA

NODO PALABRA

PALABRA COMO UNA LISTA DE SIMBOLOS

Ejemplo:
B1

Dónde:
CONTEO: Contador de Símbolos
NIVEL: Nivel del Primer Símbolo
CAB: APUNTADOR LISTA DE SIMBOLOS

ESTRUCTURA FILA
LINEA: ENTERO
CONTEO: ENTERO
CAB: *PALABRA
SIG: *FILA
FIN ESTRUCTURA FILA

NODO FILA

Dónde:
LINEA: Numero de línea
CONTEO: Contador de Palabras
CAB: APUNTADOR A LA PRIMERA PALABRA DE LA LISTA DE PALABRAS
SIG: APUNTADOR A LA SIGUIENTE FILA
UNA FILA COMO LISTA DE PALABRAS
a=b1

PROGRAMA COMO UNA MULTILISTA DE FILAS


Programa Fuente:
/n
/n
/n
a=b1/n
/n
/n
LEA a/n

DESCRIPCION DE LA MORFOLOGIA
- PRIMERA PASO. SE CONSTRUYEN MULTILISTA DE FILAS A PARTIR DE LA
MULTILISTA LINEAS. CONSTRUCCION DE PALABRAS (LEXEMAS) DE DOS
TIPOS: OPERANDO (NIVEL >=1 AND NIVEL <=3) Y OPERADOR (NIVEL>=4).
VARIABLES
CABL, PL: *LINEAS // APUNTADORES DE LINEAS (CABL: APUNTA A LA PRIMERA
LINEA, PL: APUNTADOR A LINEA ACTUAL)
PS: *SIMBOLO // APUNTADORES DE SIMBOLOS POR LINEA, donde se puede
describir:
PL->CAB: APUNTA AL PRIMER SIMBOLO DE LA LINEA
PS: APUNTADOR A SIMBOLO ACTUAL DE LINEA
CABF, PF, ULTF: *FILA // APUNTADORES DE FILA, donde se puede describir:
CABF: APUNTA A LA PRIMERA FILA
PF: APUNTADOR A LA NUEVA FILA
ULTF: APUNTADOR ULTIMA FILA ADICIONADA
ULTP, PP: *PALABRA // APUNTADORES DE PALABRAS POR FILA, donde:
PF->CAB: APUNTA A LA PRIMERA PALABRA
PP: NUEVA PRIMERA PALABRA DE LA FILA
ULTP: ULTIMA PALABRA ADICIONADA EN LA FILA
PP->CAB,P, ULT: *SIMBOLO // APUNTADORES DE SIMBOLOS PARA LA PALABRA,
donde se puede describir:
PP->CAB: APUNTA PRIMER SIMBOLO
P: NUEVO SIMBOLO
ULT: ULTIMO SIMBOLO ADICIONADO)
SUBPROGRAMA RECORRERLINEAS()
CABF=NULL
PL=CABL
MIENTRAS QUE PL NOT IGUAL A NULL HAGA
PS=PL->CAB // PRIMER SIMBOLO DE LA LINEA
NUEVA=VERDAD
MIENTRAS QUE PS NOT IGUAL A NULL HAGA
MIENTRAS QUE PS NOT IGUAL A NULL && PS->NIVEL==0 // AUTOMATA DEL
ESPACIO EN BLANCO
PS=PS->SIG
FINMIENTRAS QUE
SI PS NOT IGUAL A NULL && PS->NIVEL NOT IGUAL A 0 ENT //INGRESO AL
AUTOMATA DEL OPERANDO U OPERADOR
SI NUEVA ENT
AGREGARFILA()//CADA FILA LE CORRESPONDE UNA LINEA
FINSI
NUEVA=FALSO
AGREGARPALABRA()
SI PS->NIVEL>=1 AND PS->NIVEL <=3 ENT
OPERANDO()
SINO
OPERADOR()
FINSI
FINSI
FIN MIENTRAS QUE
FIN MIENTRAS QUE
FIN SUBPROGRAMA
SUBPROGRAMA AGREGARFILA ()
PEDIR (PF)
SI CABF == NULL ENT
CABF = PF
SINO
ULTF ->SIG = PF
FIN -SI
ULTF = PF
PF->LINEA=PL->LINEA
PF->CONTEO = 0
PF ->SIG = NULL
PF->CAB = ULTP = PP = NULL// SE INICIALIZA LOS APUNTADORES DE LA LISTA DE
PALABRAS
FIN SUBPROGRAMA

SUBPROGRAMA AGREGARPALABRA ()
PF->CONTEO=PF->CONTEO+1
PEDIR (PP)
SI PF->CAB == NULL ENT
PF->CAB = PP
SINO
ULTP->SIG= PP
FIN SI
ULTP=PP
PP->NIVEL=PS->NIVEL
PP->CONTEO = 0
PP->SIG=NULL
PP->CAB = ULT = P = NULL // SE INICIALIZA LA LISTA DE SIMBOLOS DE LA
PALABRA
FIN SUBPROGRAMA
SUBPROGRAMA OPERANDO ()
MIENTRAS QUE PS NOT IGUAL A NULL AND (PS->NIVEL>=1 AND PS->NIVEL <=3) //
AUTOMATA DEL OPERANDO
AGREGARSIMBOLO()
PS=PS->SIG
FIN MIENTRAS QUE
FIN SUBPROGRAMA

SUBPROGRAMA OPERADOR ()
MIENTRAS QUE PS NOT IGUAL A NULL AND PS->NIVEL>=4 // AUTOMATA DEL
OPERADOR
AGREGARSIMBOLO()
PS=PS->SIG
FIN MIENTRAS QUE
FIN SUBPROGRAMA

SUBPROGRAMA AGREGARSIMBOLO()
PP->CONTEO=PP->CONTEO+1
PEDIR(P)
SI PP->CAB==NULL ENT
PP->CAB=P
SINO
ULT->SIG=P
FINSI
ULT=P
P->NIVEL=PS->NIVEL
P->SIMBOLO=PS->SIMBOLO
P->SIG=NULL
FIN SUBPROGRAMA
RECORDEMOS
Para describir la gramática del compilador se utilizara la Forma Backus Neur (BNF). El
profesor hace uso de las siguientes formas:
< > Elemento No Terminal – Compuesto de ó define
:- Se Define como ó compuesto de
… Sucesión
() Agrupa
max


min
Ind

PROPUESTA DE PROFESOR
Token: es una Unidad Sintáctica. Eso quiere decir que:
- Ocupa un lugar dentro de una sentencia
- Debe ser reconocida por su naturaleza

Un Token se puede definir de naturaleza:


<Token>:- <Operador><Operando>
Nota. Esta propuesta se trabajó en la construcción de Lexemas
<operador>:- ><relación><lógicos><aritméticos><asignación>

<Relación>:- <(menor que) >(mayor que) == (igual) <=(menor o igual) >=(mayor o igual)
<> (diferente)
Reglas:
R1. Después de un < debe venir = o >
R2. Después de un > debe venir =
R3. Después de un = debe venir = (Cambio de Nivel de 7 a 5)

Como Mínimo 1 y como Máximo 2. Debe empezar con símbolo relación (Nivel 5)
<Lógicos >:- || (or) && (and)
R1. Después de un & debe venir &
R2. Después de un | debe venir |

Como Mínimo 2 y como Máximo 2 Símbolos Lógicos (Nivel 6)

<Aritméticos>:- + - * /

Como Mínimo 1 y como Máximo 1 Símbolos Aritméticos (Nivel 4)


<Asignación>:- =

Como Mínimo 1 y como Máximo 1 Símbolo Asignación (Nivel 7)

<operando>:- <variable> < reservada> <numero>

Como Mínimo 1 y como Máximo 6 Símbolos Minúscula (Nivel 2)


Como Mínimo 2 y como Máximo 6 Símbolos Mayúscula (Nivel 1)

Como Mínimo 1 y como Máximo 6 Símbolos Digito (Nivel 3)


DESCRIPCION DE LA MORFOLOGIA
- SEGUNDO PASO. A PARTIR DE LOS LEXEMAS (MULTILISTA FILA) SE
VERIFICA SI ES TOKEN O NO.
VARIABLES
CABF, PF: *FILA // APUNTADORES DE FILA, donde se puede describir:
CABF: APUNTA A LA PRIMERA FILA
PF: APUNTADOR FILA ACTUAL
PF->CAB, PP: *PALABRA // APUNTADORES DE PALABRAS POR FILA, donde:
PF->CAB: APUNTA A LA PRIMERA PALABRA DE LA FILA
PP: APUNTADOR A LA PALABRA ACTUAL DE LA FILA
PP->CAB,P: *SIMBOLO // APUNTADORES DE SIMBOLOS PARA LA PALABRA, donde
se puede describir:
PP->CAB: APUNTA PRIMER SIMBOLO DE CADA PALABRA
P: SIMBOLO ACTUAL DE LA PALABRA

SUBPROGRAMA PASO2MORFOS( )
PF=CABF
E=0
MIENTRAS QUE PF NOT IGUAL A NULL
PP= PF->CAB
MIENTRAS QUE PP NOT IGUAL A NULL
SWITCH ( PP - > NIVEL )
CASE 1…3: OPERANDOMORFOS2 ( )
CASE 4…7: OPERADORMOROFS2 ( )
FIN SWITCH
PP = PP ->SIG
FIN MIENTRASQUE
PF = PF -> SIG
FIN MIENTRASQUE
FIN SUBPROGRAMA
SUBPROGRAMA OPERANDOMORFOS2 ( )
SI PP - > CONTEO > 6 ENT
E=E+1
ESCRIBA " ERROR: SE EXCEDE LONGUITUD PERMITIDA”
FSI
P = PP -> CAB
MIENTRAS QUE P NOT IGUAL A NULL
SI P - > NIVEL NOT IGUAL A PP -> NIVEL ENT
E=E+1
ESCRIBA " ERROR: NO CORRESPONDE A LA NATURALEZA DE
TOKEN”
FSI
P = P -> SIG
FIN MIENTRASQUE
FIN SUBPROGRAMA

SUBPROGRAMA OPERADORMOROFS2 ( )
SWITCH ( PP - > NIVEL )
CASE 4: OPERADORARITMETICO ( )
CASE 5: OPERADORRELACION ( )
CASE 6: OPERADORLOGICO( )
CASE 7: OPERADORASIGNACION ( )
FIN SWITCH
FIN SUBPROGRAMA

SUBPROGRAMA OPERADORARITMETICO ( )
SI PP - > CONTEO > 1 ENT
E=E+1
ESCRIBA " OPERADOR ARITMETICO SE EXCEDE LONGUITUD DE 1”
FINSI
FIN SUBPROGRAMA
SUBPROGRAMA OPERADORLOGICO ( )
SI PP - > CONTEO NOT IGUAL A 2 ENT
E=E+1
ESCRIBA " SE EXCEDE LONGUITUD DE 2”
FINSI
SI PP - > CONTEO =2 ENT
P = PP -> CAB
AND=FALSO
SI P->SIMBOLO IGUAL A ‘&’ ENT
AND=VERDAD
FINSI
P=P->SIG
SI AND ENT // SI ES SIMBOLO & VA DE PRIMERO
SI P->SIMBOLO NOT IGUAL A ‘& ‘ ‘ ENT
E=E+1
ESCRIBA " ERROR: SE ESPERABA &”
FINSI
SINO SI ES SIMBOLO | VA DE PRIMERO
SI P->SIMBOLO NOT IGUAL A ‘| ‘ ENT
E=E+1
ESCRIBA " ERROR: SE ESPERABA |”
FINSI
FINSI
FINSI
FIN SUBPROGRAMA
SUBPROGRAMA OPERADORRELACION ( )
SI PP - > CONTEO > 2 ENT
E=E+1
ESCRIBA " ERROR: OPERADOR DE RELACION SE EXCEDE LONGUITUD
PERMITIDA”
FINSI
SI PP - > CONTEO =2 ENT
P = PP -> CAB
MENOR=FALSO
SI P->SIMBOLO IGUAL A ‘<’ ENT
MENOR=VERDAD
FINSI
P=P->SIG
SI MENOR ENT // SI ES SIMBOLO < VA DE PRIMERO
SI P->SIMBOLO NOT IGUAL A ‘= ‘ && P->SIMBOLO NOT IGUAL A ‘> ‘ ENT
E=E+1
ESCRIBA " ERROR: SE ESPERABA > O =”
FINSI
SINO SI ES SIMBOLO > VA DE PRIMERO
SI P->SIMBOLO NOT IGUAL A ‘= ‘ ENT
E=E+1
ESCRIBA " ERROR: SE ESPERABA =”
FINSI
FINSI
FINSI
FIN SUBPROGRAMA
SUBPROGRAMA OPERADORASIGNACION ( )
SI PP - > CONTEO > 2 ENT
E=E+1
ESCRIBA " ERROR: OPERADOR DE ASIGNACION SE EXCEDE LONGUITUD
PERMITIDA”
FINSI
SI PP - > CONTEO =2 ENT
P=PP->CAB
P=P->SIG
SI P->SIMBOLO NOT IGUAL A ‘= ‘ ENT
E=E+1
ESCRIBA " ERROR: SE ESPERABA =”
SINO // EL TOKEN ASIGNACION SE CONVIERTE EN TOKEN RELACION
PP->NIVEL=5
FINSI
FINSI
FIN SUBPROGRAMA
ETAPA INTERMEDIA MORFOLOGIA-SINTAXIS
APUNTES DE CLASE DE COMPILADORES LENGUAJE ARTIFICIAL
UNIVERSIDAD AUTONOMA
ELECTIVA: COMPILADORES
MORFOLOGIA
INTERMEDIO MORFOLOGIA-SINTAXIS

ANTECEDENTE MORFOLOGIA

ESTRUCTURA PALABRA
CONTEO: ENTERO
NIVEL: ENTERO
CAB: *SIMBOLO
SIG: *PALABRA
FIN ESTRUCTURA PALABRA

NODO PALABRA

PALABRA COMO UNA LISTA DE SIMBOLOS

Ejemplo:
B1
Dónde:
CONTEO: Contador de Símbolos
NIVEL: Nivel del Primer Símbolo
CAB: APUNTADOR LISTA DE SIMBOLOS

ESTRUCTURA FILA
LINEA: ENTERO
CONTEO: ENTERO
CAB: *PALABRA
SIG: *FILA
FIN ESTRUCTURA FILA

NODO FILA

Dónde:
LINEA: Numero de línea
CONTEO: Contador de Palabras
CAB: APUNTADOR A LA PRIMERA PALABRA DE LA LISTA DE PALABRAS
SIG: APUNTADOR A LA SIGUIENTE FILA
UNA FILA COMO LISTA DE PALABRAS
a=b1

PROGRAMA COMO UNA MULTILISTA DE FILAS


Programa Fuente:
/n
/n
/n
a=b1/n
/n
/n
LEA a/n

Descripción BNF
Para describir la gramática del compilador se utilizara la Forma Backus Neur (BNF). El
profesor hace uso de las siguientes formas:
< > Elemento No Terminal – Compuesto de ó define
:- Se Define como ó compuesto de
… Sucesión
() Agrupa
max


min
Ind

PROPUESTA DE PROFESOR
Token: es una Unidad Sintáctica. Eso quiere decir que:
- Ocupa un lugar dentro de una sentencia
- Debe ser reconocida por su naturaleza

Un Token se puede definir de naturaleza:


<Token>:- <Operador><Operando>
Nota. Esta propuesta se trabajó en la construcción de Lexemas
<operador>:- ><relación><lógicos><aritméticos><asignación>

<Relación>:- <(menor que) >(mayor que) == (igual) <=(menor o igual) >=(mayor o igual)
<> (diferente)
Reglas:
R1. Después de un < debe venir = o >
R2. Después de un > debe venir =
R3. Después de un = debe venir = (Cambio de Nivel de 7 a 5)

Como Mínimo 1 y como Máximo 2. Debe empezar con símbolo relación (Nivel 5)

<Lógicos >:- || (or) && (and)


R1. Después de un & debe venir &
R2. Después de un | debe venir |

Como Mínimo 2 y como Máximo 2 Símbolos Lógicos (Nivel 6)

<Aritméticos>:- + - * /

Como Mínimo 1 y como Máximo 1 Símbolos Aritméticos (Nivel 4)


<Asignación>:- =

Como Mínimo 1 y como Máximo 1 Símbolo Asignación (Nivel 7)


<operando>:- <variable> < reservada> <numero>

Como Mínimo 1 y como Máximo 6 Símbolos Minúscula (Nivel 2)

Como Mínimo 2 y como Máximo 6 Símbolos Mayúscula (Nivel 1)

Como Mínimo 1 y como Máximo 6 Símbolos Digito (Nivel 3)


PASO INTERMEDIO MORFOLOGIA-SINTAXIS

ESTRUCTURA TOKENS
CONTEO: ENTERO
NIVEL: ENTERO
TOKEN: CADENA[1..6]
SIG: *TOKENS
FIN ESTRUCTURA TOKENS

NODO TOKENS

PALABRA COMO UNA LISTA DE SIMBOLOS

Ejemplo:

Dónde:
CONTEO: Contador de Símbolos
NIVEL: Nivel del Token
NIVEL <SIMBOLO>
1 Reservada
2 Variable
3 Numero
4 Operador Aritmético
5 Operador de Relación
6 Operador Lógico
7 Operador Asignación

TOKEN: Cadena de Símbolos de longitud 1 a 6


SIG: APUNTADOR SIGUIENTE TOKEN

ESTRUCTURA SENTENCIA
LINEA: ENTERO
CONTEO: ENTERO
CAB: *TOKENS
SIG: *SENTENCIA
FIN ESTRUCTURA SENTENCIA

Entonces, se define a una Sentencia como un Conjunto de Token

NODO SENTENCIA

Dónde:
LINEA: Numero de línea
CONTEO: Contador de Tokens
CAB: APUNTADOR AL PRIMER TOKEN
SIG: APUNTADOR A LA SIGUIENTE SENTENCIA
UNA SENTENCIA COMO LISTA DE TOKENS
SI a>=12345

PROGRAMA COMO UNA MULTILISTA DE SENTENCIAS


Programa Fuente:
/n
/n
/n
LEA a
/n
/n
SI a>=12345
VARIABLES
CABO, PO, ULTO: *SENTENCIA // APUNTADORES DE SENTENCIA, donde se puede
describir:
CABO: APUNTA A LA PRIMERA SENTENCIA
PO: APUNTADOR A LA NUEVA SENTENCIA
ULTO: APUNTADOR ULTIMA SENTENCIA ADICIONADA
CABO->CAB, PT, ULTT: *TOKENS // APUNTADORES DE TOKENS, donde se puede
describir:
CABO->CAB: APUNTA AL PRIMER TOKEN DE LA SENTENCIA
PT: APUNTADOR AL NUEVO TOKEN
ULTT: APUNTADOR ULTIMO TOKEN
CABF, PF: *FILA // APUNTADORES DE FILA, donde se puede describir:
CABF: APUNTA A LA PRIMERA FILA
PF: APUNTADOR FILA ACTUAL
PF->CAB, PP: *PALABRA // APUNTADORES DE PALABRAS POR FILA, donde:
PF->CAB: APUNTA A LA PRIMERA PALABRA DE LA FILA
PP: APUNTADOR A LA PALABRA ACTUAL DE LA FILA
PP->CAB,P: *SIMBOLO // APUNTADORES DE SIMBOLOS PARA LA PALABRA, donde
se puede describir:
PP->CAB: APUNTA PRIMER SIMBOLO DE CADA PALABRA
P: SIMBOLO ACTUAL DE LA PALABRA

DESCRIPCION DEL PRIMER PASO


A PARTIR DE LA MULTILISTA FILA (MULTILISTA DE LEXEMAS) SE CONTRUYE EL
PROGRAMA SINTACTICO COMO UNA MULTILISTA DE SENTENCIAS

SUBPROGRAMA RECORRER FILA( )


PF=CABF
CABO=NULL
MIENTRAS QUE PF NOT IGUAL A NULL
PP= PF->CAB
CREARSENTENCIA()
MIENTRAS QUE PP NOT IGUAL A NULL
CREARTOKENS()
PP=PP->SIG
FIN MIENTRASQUE
PF = PF -> SIG
FIN MIENTRASQUE
FIN SUBPROGRAMA
SUBPROGRAMA CREARSENTENCIA( )
PEDIR (PO)
SI CABO == NULL ENT
CABO = PO
SINO
ULTO ->SIG = PO
FIN -SI
ULTO = PO
PO->LINEA=PF->LINEA
PO->CONTEO = PF->CONTEO
PO ->SIG = NULL
PO->CAB = ULTT = PT = NULL// SE INICIALIZA LOS APUNTADORES DE LA LISTA DE
TOKENS
FIN SUBPROGRAMA

SUBPROGRAMA CREARTOKENS( )
PEDIR (PT)
SI PO->CAB == NULL ENT
PO->CAB = PT
SINO
ULTT ->SIG = PT
FIN -SI
ULTT = PT
PT->SIG=NULL
PT->NIVEL=PP->NIVEL
PT->CONTEO=PP->CONTEO
// SE CONCATENAN LOS SIMBOLOS COMO CADENA
PT->TOKEN=””
P=PP->CAB
MIENTRAS QUE P NOT IGUAL A NULL
PT->TOKEN=PT->TOKEN+P->SIMBOLO
P = P -> SIG
FIN MIENTRASQUE
FIN SUBPROGRAMA
DESCRIPCION DEL SEGUNDO PASO
CREAR LA LISTA DE PALABRAS RESERVADAS

ESTRUCTURA RESERVADA
NOMBRE: CADENA[6]
TIPO: DIGITO
NIVEL: DIGITO
MIN: DIGITO
MAX: DIGITO
APILA: DIGITO
VERIFICA: DIGITO
DESEMPILA: DIGITO
MENSAJE: CADENA[5]
NIVEL: ENTERO
SIG: *RESERVADA
FIN ESTRUCTURA RESERVADA

DESCRIPCION DE RESERVADA
NOMBRE: Nombre de la Palabra Reservada
TIPO: Tipo de Sentencia 0:: Vacia 1::Unica 2:: Asignación 3:: Condición
NIVEL: Numero de Nivel
MIN: Mínimo Nivel Próximo
MAX: Máximo Nivel Próximo
APILA: Tipo bloque de Apilamiento(1:: Si 2:: MQ 3:: PARA)
VERIFICA: Tipo bloque de Verificación (Solo para el SINO)
DESEMPILA: Tipo bloque de Desempilamiento(1:: Si 2:: MQ 3:: PARA)
MENSAJE: Mensaje de Error
SIG: Apuntador a Siguiente Palabra Reservada

RESERVADA COMO UN NODO

COMO ESTA EN EL ARCHIVO reserva.txt


PROGcc1122000ccccc
INTccc1223000ccccc
INICIO0344000ccccc
ASIGNE2445000ccccc
LEAccc1445000ccccc
ESCRcc1445000ccccc
SIcccc3445100ccFSI
SINOcc0445010cccSI
FSIccc0445001cccSI
PARAcc3445300FPARA
FPARAc1445003cPARA
MQcccc3445200ccFMQ
FMQccc0445002cccMQ
FINccc0566000ccccc
Nota. La Longitud de descripción de cada palabra reservada es de 19 caracteres. El
carácter c expresa espacio en blanco.

EL SENTIDO DE LAS PALABRAS RESERVADAS


Para el compilador que se está desarrollando toda sentencia debe comenzar por una de
estas palabras reservadas (parsing prefijo).
NOMBRE
PROG
INT
INICIO
ASIGNE
LEA
ESCR
SI
SINO
FSI
PARA
FPARA
MQ
FMQ
FIN
No existen palabras reservadas complementarias como HASTA o ENT para sentencias
como:
PARA <operación> HASTA <numero>
SI <condición> ENT
Pero en el momento del análisis se deben incluir como palabras reservadas HASTA o
ENT.
En el desarrollo de este compilador no se tendrá encuentra las palabras reservadas
complementarias.

UN EJEMPLO DE UN NODO DE PALABRA RESERVADA

VARIABLES
CABR, PR, TR: * RESERVADA
CABR: APUNTA A LA PRIMERA PALABRA RESERVADA
PR: NUEVA PARALABRA RESERVADA
TR: ULTIMA PALABRA RESERVADA
SUBPROGRAMA CARGARRESERVADA(ARCHIVO)
c:CADENA[19] // CADENA QUE POSEE LA PALABRA RESERVADA
i: ENTERO // INDICE DENTRO DE C
ABRIR(ARCHIVO)
CABR=NULL
MIENTRAS QUE NOT EOF(ARCHIVO)
C=LEA(ARCHIVO,19) // SE LEE DE 19 CARACTERES
PEDIR(PR)
SI CABR==NUU
CABR=PR
SINO
ULTR->SIG=PR
FINSI
ULTR=PR
PR->SIG=NULL
PARA i=1 HASTA 6
SI c[i]=='c' ENT //ESPACIOS EN BLANCO
PR->NOMBRE[i]=' '
SINO
PR->NOMBRE[i]=c[i]
FINSI
FIN PARA
PR->TIPO=c[i]
i=i+1
PR->NIVEL=c[i]
i=i+1
PR->MIN=c[i]
i=i+1
PR->MIN=c[i]
i=i+1
PR->APILA=c[i]
i=i+1
PR->VERIFICA=c[i]
i=i+1
PR->DESEMPILA=c[i]
i=i+1
PARA Y=1 HASTA 5 //PARA EL MENSAJE DE ERROR
SI c[i]=='c' ENT //ESPACIOS EN BLANCO
PR->MENSAJE[y]=' '
else
PR->MENSAJE[y]=c[i]
FINSI
i=i+1
FINPARA
FIN MIENTRAS QUE
FIN SUBPROGRAMA
DESCRIPCION DEL TERCER PASO
SE VERIFICA EN EL PROGRAMA SINTACTICO (MULTILISTA DE SENTENCIAS) SI
LOS TOKENS DE NIVEL 1 SON PALABRAS RESERVADAS (CONSTRATAR CON LA
LISTA DE RESERVADAS)

VARIABLES
CABR, PR, TR: * RESERVADA, donde se puede describir:
CABR: APUNTA A LA PRIMERA PALABRA RESERVADA
PR: PARALABRA RESERVADA ACTUAL
CABO, PO, ULTO: *SENTENCIA // APUNTADORES DE SENTENCIA, donde se puede
describir:
CABO: APUNTA A LA PRIMERA SENTENCIA
PO: APUNTADOR A LA SENTENCIA ACTUAL
CABO->CAB, PT, ULTT: *TOKENS // APUNTADORES DE TOKENS, donde se puede
describir:
CABO->CAB: APUNTA AL PRIMER TOKEN DE LA SENTENCIA
PT: APUNTADOR AL TOKEN ACTUAL
E: ERROR

SUBPROGRAMA BUSCARESERVADA(CADENA T)//BUSQUEDA DE CADENA T


COMO PALABRA RESERVADA
PR=CABR
MIENTRAS QUE PR NOT IGUAL A NULL && PR->NOMBRE NOT IGUAL A T
PR=PR->SIG
FIN MIENTRASQUE
RETORNA PR
FIN SUBPROGRAMA
SUBPROGRAMA RECORRERPROGRAMA()
R:*RESERVADA
PO=CABO
MIENTRAS QUE PO NOT IGUAL A NULL
PT= CABO->CAB
MIENTRAS QUE PT NOT IGUAL A NULL
SI PT->NIVEL==1 ENT //ENCONTRO UN TOKEN RESERVADA
R= BUSCARESERVADA(PT->TOKEN)
SI R==NULL ENT //NO LA ENCONTRO COMO PALABRA RESERVADA
E=E+1
ESCR PT->TOKEN, “ NO ES PALABRA RESERVADA”
FINSI
FINSI
PT=PT->SIG
FIN MIENTRASQUE
PO = PO -> SIG
FIN MIENTRASQUE
FIN SUBPROGRAMA

PROGRAMA PRINCIPAL
E=0
SI EXISTEARCHIVO(“RESERVA.TXT) ENT
CARGARRESERVADA(ARCHIVO)
SINO
ESCRIBA “NO ENCONTRO ARCHIVO DE PALABRAS RESERVADAS”
SALIR()
FINSI
RECORRERPROGRAMA()
FIN PROGRAMA
ETAPA SINTAXIS
APUNTES DE CLASE DE COMPILADORES LENGUAJE ARTIFICIAL
UNIVERSIDAD AUTONOMA
ELECTIVA: COMPILADORES
SINTAXIS

ANTECEDENTE LEXICO-MORFOLOGICA

ESTRUCTURA TOKENS
CONTEO: ENTERO
NIVEL: ENTERO
TOKEN: CADENA[1..6]
SIG: *TOKENS
FIN ESTRUCTURA TOKENS

NODO TOKENS

PALABRA COMO UNA LISTA DE SIMBOLOS

Ejemplo:
Dónde:
CONTEO: Contador de Símbolos
NIVEL: Nivel del Token
NIVEL <SIMBOLO>
1 Reservada
2 Variable
3 Numero
4 Operador Aritmético
5 Operador de Relación
6 Operador Lógico
7 Operador Asignación

TOKEN: Cadena de Símbolos de longitud 1 a 6


SIG: APUNTADOR SIGUIENTE TOKEN

ESTRUCTURA SENTENCIA
LINEA: ENTERO
CONTEO: ENTERO
CAB: *TOKENS
SIG: *SENTENCIA
FIN ESTRUCTURA SENTENCIA

Entonces, se define a una Sentencia como un Conjunto de Token

NODO SENTENCIA

Dónde:
LINEA: Numero de línea
CONTEO: Contador de Tokens
CAB: APUNTADOR AL PRIMER TOKEN
SIG: APUNTADOR A LA SIGUIENTE SENTENCIA
UNA SENTENCIA COMO LISTA DE TOKENS
SI a>=12345
PROGRAMA COMO UNA MULTILISTA DE SENTENCIAS
Programa Fuente:
/n
/n
/n
LEA a
/n
/n
SI a>=12345
ESTRUCTURA RESERVADA
NOMBRE: CADENA[6]
TIPO: DIGITO
NIVEL: DIGITO
MIN: DIGITO
MAX: DIGITO
APILA: DIGITO
VERIFICA: DIGITO
DESEMPILA: DIGITO
MENSAJE: CADENA[5]
NIVEL: ENTERO
SIG: *RESERVADA
FIN ESTRUCTURA RESERVADA

DESCRIPCION DE RESERVADA
NOMBRE: Nombre de la Palabra Reservada
TIPO: Tipo de Sentencia 0:: Vacia 1::Unica 2:: Asignación 3:: Condición
NIVEL: Numero de Nivel
MIN: Mínimo Nivel Próximo
MAX: Máximo Nivel Próximo
APILA: Tipo bloque de Apilamiento(1:: Si 2:: MQ 3:: PARA)
VERIFICA: Tipo bloque de Verificación (Solo para el SINO)
DESEMPILA: Tipo bloque de Desempilamiento(1:: Si 2:: MQ 3:: PARA)
MENSAJE: Mensaje de Error
SIG: Apuntador a Siguiente Palabra Reservada

RESERVADA COMO UN NODO


COMO ESTA EN EL ARCHIVO reserva.txt
PROGcc1122000ccccc
INTccc1223000ccccc
INICIO0344000ccccc
ASIGNE2445000ccccc
LEAccc1445000ccccc
ESCRcc1445000ccccc
SIcccc3445100ccFSI
SINOcc0445010cccSI
FSIccc0445001cccSI
PARAcc3445300FPARA
FPARAc1445003cPARA
MQcccc3445200ccFMQ
FMQccc0445002cccMQ
FINccc0566000ccccc
Nota. La Longitud de descripción de cada palabra reservada es de 19 caracteres. El
carácter c espacio en blanco.

EL SENTIDO DE LAS PALABRAS RESERVADAS


Para el compilador que se está desarrollando toda sentencia debe comenzar por una de
estas palabras reservadas (parsing prefijo).
NOMBRE
PROG
INT
INICIO
ASIGNE
LEA
ESCR
SI
SINO
FSI
PARA
FPARA
MQ
FMQ
FIN
No existen palabras reservadas complementarias como HASTA o ENT para sentencias
como:
PARA <operación> HASTA <numero>
SI <condición> ENT
Pero en el momento del análisis se deben incluir como palabras reservadas HASTA o
ENT

UN EJEMPLO DE UN NODO DE PALABRA RESERVADA

UNA MUESTRA DE LAS LISTA DE RESERVADAS


VARIABLES DISPONIBLES
CABR, PR, TR: * RESERVADA, donde se puede describir:
CABR: APUNTA A LA PRIMERA PALABRA RESERVADA
PR: PARALABRA RESERVADA ACTUAL
CABO, PO, ULTO: *SENTENCIA // APUNTADORES DE SENTENCIA, donde se puede
describir:
CABO: APUNTA A LA PRIMERA SENTENCIA
PO: APUNTADOR A LA SENTENCIA ACTUAL
CABO->CAB, PT, ULTT: *TOKENS // APUNTADORES DE TOKENS, donde se puede
describir:
CABO->CAB: APUNTA AL PRIMER TOKEN DE LA SENTENCIA
PT: APUNTADOR AL TOKEN ACTUAL
E: ERROR

SUBPROGRAMA BUSCARESERVADA(CADENA T)//BUSQUEDA DE CADENA T


COMO PALABRA RESERVADA
PR=CABR
MIENTRAS QUE PR NOT IGUAL A NULL && PR->NOMBRE NOT IGUAL A T
PR=PR->SIG
FIN MIENTRASQUE
RETORNA PR
FIN SUBPROGRAMA

SINTAXIS
Es la manera correcta de escribir una sentencia.

EXPLORADOR PARSING
Toda Sentencia debe iniciarse con una Palabra Reservada que se encuentra en la Lista
de Reservadas. Eso quiere decir que el primer token de cada sentencia debe ser una de
estas palabras:
NOMBRE
PROG
INT
INICIO
ASIGNE
LEA
ESCR
SI
SINO
FSI
PARA
FPARA
MQ
FMQ
FIN

SUBPROGRAMA MENSINT(ENTERO FILA , CADENA MENSAJE) //MENSAJE


SINTACTICO
E=E+1
ESCR “ERROR EN LA FILA: “+FILA+” “+MENSAJE
FIN SUBPROGRAMA
SUBPROGRAMA PARSING()
R:*RESERVADA
PO=CABO
MIENTRAS QUE PO NOT IGUAL A NULL
PT= PO->CAB
R= BUSCARESERVADA(PT->TOKEN)
SI R==NULL ENT //NO LA ENCONTRO COMO PALABRA RESERVADA
E=E+1
MENSINT(PO->PO->LINEA, “NO INICIA CON PALABRA RESERVADA”)
FIN SI
PO = PO -> SIG
FIN MIENTRASQUE
FIN SUBPROGRAMA
EXPLORADOR NIVEL SINTACTICO

La Tabla de Niveles de Palabras Reservadas es la siguiente:


SIGUIENTE
NOMBRE NIVEL MIN MAX
PROG 1 2 2
INT 2 2 3
INICIO 3 4 4
ASIGNE 4 4 5
LEA 4 4 5
ESCR 4 4 5
SI 4 4 5
SINO 4 4 5
FSI 4 4 5
PARA 4 4 5
FPARA 4 4 5
MQ 4 4 5
FMQ 4 4 5
FIN 5 6 6
Regla:: El nivel sintáctico de la sentencia debe estar dentro de dos variables(MINIMO Y
MAXIMO)
SUBPROGRAMA NIVEL()
R:*RESERVADA
PO=CABO
MINIMO=1
MAXIMO=1
MIENTRAS QUE PO NOT IGUAL A NULL
PT= PO->CAB
R= BUSCARESERVADA(PT->TOKEN)
SI R->NIVEL >= MINIMO && R->NIVEL <= MAXIMO ENT
MINIMO=R->MIN
MAXIMO=R->MAX
SINO
E=E+1
MENSINT (PO->PO->LINEA ,”No le corresponde Nivel")
Si R->NIVEL > MAXIMO ENT
MINIMO=R->MIN
MAXIMO=R->MAX
FIN SI
FIN SI
PO = PO -> SIG
FIN MIENTRASQUE
SI MINIMO NOT IGUAL A 6 ENT
MENSINT (PO->PO->LINEA ,”No Tiene Fin de Programa")
FINSI
ESCRIBA "Verificador de NIVEL SINTACTICO Errores: ",E
FIN SUBPROGRAMA
BLOQUE SINTACTICO
La regla del bloque sintáctico se fundamenta en la siguiente tabla:
NOMBRE APILA VERIFICA DESEMPILA MENSAJE
PROG 0 0 0
INT 0 0 0
INICIO 0 0 0
ASIGNE 0 0 0
LEA 0 0 0
ESCR 0 0 0
SI 1 0 0 FSI
SINO 0 1 0 SI
FSI 0 0 1 SI
PARA 3 0 0 FPARA
FPARA 0 0 3 PARA
MQ 2 0 0 FMQ
FMQ 0 0 2 FMQ
FIN 0 0 0
Explicación:
- El bloque SI apila en la pila de bloques porque es el comienzo de un bloque
(Apila>0). El número de bloque es el 1. El mensaje una terminado de recorrer el
programa fuente no se ha desempilado este bloque indica ERROR FALTA UN FSI
PARA LA LINEA….
- El bloque SINO verifica (verifica>0) si en el tope de la pila el número de bloque es
1 ,sino es así, muestra un mensaje de ERROR FALTA UN SI PARA LA LINEA….
- El bloque FSI desempila siempre y cuando en el tope de la pila el número del
bloque sea 1, sino es así, muestra un mensaje de ERROR FALTA UN SI PARA LA
LINEA….
- El bloque PARA apila en la pila de bloques porque es el comienzo de un bloque
(Apila>0). El número de bloque es el 3. El mensaje una terminado de recorrer el
programa fuente no se ha desempilado este bloque indica ERROR FALTA UN
FPARA PARA LA LINEA….
- El bloque FPARA desempila siempre y cuando en el tope de la pila el número del
bloque sea 3, sino es así, muestra un mensaje de ERROR FALTA UN PARA
PARA LA LINEA….
- El bloque MQ apila en la pila de bloques porque es el comienzo de un bloque
(Apila>0). El número de bloque es el 2. El mensaje una terminado de recorrer el
programa fuente no se ha desempilado este bloque indica ERROR FALTA UN
FMQ PARA LA LINEA….
- El bloque FMQ desempila siempre y cuando en el tope de la pila el número del
bloque sea 3, sino es así, muestra un mensaje de ERROR FALTA UN MQ PARA
LA LINEA….
El análisis sintáctico requiere de un autómata de pila(LIFO). Para eso se diseña una
estructura como unos métodos para implantar el autómata.
ESTRUCTURA BLOQUE
ESTADO: ENTERO // NUMERO DE BLOQUE SINTÁCTICO A APLICAR
PO->LINEA: ENTERO // NUMERO DE PO->LINEA DONDE INICIA EL BLOQUE
MENSAJE: CADENA // MENSAJE DE POSIBLE ERROR
SIG:: *BLOQUE //APUNTADOR AL SIGUIENTE BLOQUE
FIN ESTRUCTURA BLOQUE

VARIABLES
CABB, PB: *BLOQUE // APUNTADORES DE BLOQUE, donde se puede describir:
CABB: APUNTA AL ULTIMO BLOQUE
PB: APUNTADOR AL NUEVO BLOQUE

SUBPROGRAMA DESEMPILARBLOQUE()
PB=CABB
CABB=CABB->SIG
LIBERE(PB)
FIN SUBPROGRAMA

SUBPROGRAMA APILARBLOQUE()
PEDIR(PB)
PB->SIG=CABB
CABB=PB
PB->PO->LINEA=PO->PO->LINEA
PB->ESTADO=R->APILA
PB->MENSAJE=R->MENSAJE
FIN SUBPROGRAMA
PROGRAMA BLOQUE()
CABB=NULL
R:*RESERVADA
PO=CABO
MIENTRAS QUE PO NOT IGUAL A NULL
PT= PO->CAB
R= BUSCARESERVADA(PT->TOKEN)
SI R->APILA>0 ENT
APILARBLOQUE()
FSI
SI R->VERIFICA>0
SI CABB == NULL || CABB->ESTADO NOT IGUAL A R->VERIFICA ENT
E=E+1
MENSINT(PO->LINEA,”FALTA UN “+R->MENSAJE)
FIN SI
FIN SI
SI R->DESEMPILA>0
SI CABB == NULL || CABB->ESTADO NOT IGUAL A R->DESEMPILA
ENT
E=E+1
MENSINT(PO->LINEA,”FALTA UN “+R->MENSAJE)
SINO
DESEMPILARBLOQUE()
FIN SI
FIN SI
PO = PO -> SIG
FIN MIENTRASQUE
MIENTRAS QUE CABB NOT IGUAL A NULL
MENSINT(CABB ->PO->LINEA,”FALTA UN “+CABB->MENSAJE)
DESEMPILARBLOQUE()
FIN MIENTRASQUE
FIN PROGRAMA
CADENA SINTACTICA
La regla de la Cadena Sintáctica se fundamenta en la siguiente tabla:
NOMBRE TIPO
PROG 1
INT 1
INICIO 0
ASIGNE 2
LEA 1
ESCR 1
SI 3
SINO 0
FSI 0
PARA 3
FPARA 1
MQ 3
FMQ 0
FIN 0
La explicación:
Tipo:: 0 No posee Parámetros
Tipo:: 1 El único parámetro es una <variable>
Tipo:: 2 <variable> = <operación>
Tipo:: 3 <variable> <operador_relacion> <operación>
<operador_relacion>:: <,>,<=,>=,==,<> (Nivel 5)
<operador_aritmetico>:: +,-,*,/ (Nivel 4)
<OPERANDO>:: <variable> | <numero> o sea <Nivel 2> | <Nivel 3>


<operación> :: <OPERANDO>   operador _ aritmetico  operando  , entonces:
0

<operación>::
Una cadena sintáctica se expresa como:
<PALABRA RESERVADA> + <DESPUES>
Casos de estudio:
PALABRA DESPUES
RESERVADA
PROG <Nivel 2>
INT <Nivel 2>
INICIO
ASIGNE

LEA <Nivel 2>


ESCR <Nivel 2>
SI

<Nivel 2> <Nivel 5>


SINO
FSI
PARA

<Nivel 2> <Nivel 5>


FPARA <Nivel 2>
MQ

Nivel 2> <Nivel 5>


FMQ
FIN
SUBPROGRAMA OPERACION()
OPERANDO = VERDAD
PT=PT->SIG
MQ PT NO ES NULL
SI OPERANDO ENT
SI PT->NIVEL NO ES 2 OR 3 ENT
MENSINT(PO->LINEA,”LA PALABRA “+PT->TOKEN+ “ DEBE SER UN
OPERANDO”)
FIN SI
SINO
SI PT->NIVEL NO ES 4 ENT
MENSINT(PO->LINEA,”FALTA UN OPERANDOR +,-,*,/ EN EL
TOKEN “+PT->TOKEN)
FIN SI
FIN SI
OPERANDO = NOT OPERANDO
PT = PT->SIG
FIN MQ
SI OPERANDO
MENSINT(PO->LINEA,”DEBE TERMINAR CON OPERANDO “)
FIN SI
FIN SUBPROGRMA

SUBPROGRAMA ASIGNACION()
PT=PT->SIG
SI PT->NIVEL NO ES 2 ENT
MENSINT(PO->LINEA,”EN EL TOKEN “+PT->TOKEN +” ESPERABA UNA
VARIABLE “)
FIN SI
PT=PT->SIG
SI PT->NIVEL NO ES 7 ENT
MENSINT(PO->LINEA,”EN EL TOKEN “+PT->TOKEN +” ESPERABA UN = “)
FIN SI
OPERACION()
FIN SUBPROGRAMA
SUBPROGRAMA CONDICION()
PT=PT->SIG
SI PT->NIVEL NO ES 2 ENT
MENSINT(PO->LINEA,”EN EL TOKEN “+PT->TOKEN +” ESPERABA UNA
VARIABLE “)
FIN SI
PT=PT->SIG
SI PT->NIVEL NO ES 5 ENT
MENSINT(PO->LINEA,”EN EL TOKEN “+PT->TOKEN +” ESPERABA UN
>,<,>=,<= “)
FINSI
OPERACION()
FIN SUBPROGRAMA
PROGRAMA CADENASINTACTICA()
R:*RESERVADA
PO=CABO
MIENTRAS QUE PO NOT IGUAL A NULL
PT= PO->CAB
R= BUSCARESERVADA(PT->TOKEN)
SWITCH (PT->TIPO)
CASO 0: // CADENA SINTACTICA VACIA
SI PO->CONTEO>1 ENT
MENSINT(PO->LINEA,” NO DEBE POSEER
PARAMETROS”)
FIN SI
CASO 1: // CADENA SINTACTICA UNICA
SI PO->CONTEO NO IGUAL A 2 ENT
MENSINT(PO->LINEA,” DEBE POSEER UN SOLO
PARAMETRO”)
SINO
SI (PT->SIG)->NIVEL NO ES 2 ENT
MENSINT (PO->LINEA,”EL SEGUNDO
PARAMETRO DEBE SER VARIABLE “)
FIN SI
FIN SI
CASO 2: // CADENA SINTACTICA ASIGNACION
SI PO->CONTEO < 4 ENT
MENSINT (PO->LINEA, ” DEBE POSEER MINIMO 4
PARAMETROS”)
SINO
ASIGNACION ()
FIN SI
CASO 3: // CADENA SINTACTICA CONDICION
SI PO->CONTEO < 4 ENT
MENSINT (PO->LINEA, ” DEBE POSEER MINIMO 4
PARAMETROS”)
SINO
CONDICION()
FIN SI
FIN SWITCH
PO=PO->SIG
FIN MIENTRAS QUE
FIN PROGRAMA
ETAPA SEMANTICA
APUNTES DE CLASE DE COMPILADORES LENGUAJE ARTIFICIAL
UNIVERSIDAD AUTONOMA
COMPILADORES
ANALIZADOR SEMANTICO

PARTE 1. CREACION DE LA LISTA DE VARIABLES


Estructura variable
Cadena Simbolo[6] . Nombre de Variable
Variable *sig . Apuntador Siguiente
Fin Estructura
Se genera una Lista denominada Lista de Variables
Con los siguientes apuntadores:
Cabv, pv, ultv

Errores de Compilación:
Nivel 2. Redefinición de Variable
Nivel 4. No ha Sido Declarada la Variable

Métodos
Esvar:: Método Bolean que retorna si existe o no variable.
Boolean esvar(cadena c)
Pv=cabv
Boolean existe=falso
Mientra que pv!=NULL AND no existe
Si Pv->símbolo==c Entonces
Existe=verdad
Sino
Pv=pv->sig
FSI
FMQ
Retorne existe
Fin esvar

Imprpal():: Método que copia el nombre de variable como una cadena


ps=pp->cab
PARA i=0 HASTA 5
SI ps!=NULL Entonces
MENSAJE2[i]=ps->c[0]
Ps=ps->sig
SINO
MENSAJE2[i]=’ ‘
FSI
FPARA
FIN
Adicionvar:: Método que adiciona variable al final de la lista.
Adicionvar()
Pv=pedir()
Si Cabv==NULL Entonces
Cabv=pv
Sino
Ultv->sig=pv
Fsi
Ultv=Pv
Pv->sig=NULL
Pv->símbolo=MENSAJE2
Fin Adicionvar

Semántica de Variable
linea=0
pf=cabf
Mientras que (pf!=NULL)
pp=pf->cab
pres= esres()
pp=pp->sig
linea++
SI pres->nivel==2 OR pres->nivel==4 Entonces
Mientras que (pp!=NULL)
SI pp->Tipo==2 Entonces
Imprpal()
SI pres->Nivel==2 ENT ONCES
Si esvar(MENSAJE2) ENTONCES
Mensint( linea, “Variable: “+MENSAJE2+” Redefinida”)
Sino
AdicionVar()
FSI
FSI
SI pres->Nivel==4 ENT ONCES
Si No es esvar(MENSAJE2) ENTONCES
Mensint( linea, “Variable: “,MENSAJE2,” No Esta definida”)
FSI
FSI
FSI
pp=pp->sig
FIN MQ
FSI
pf=pf->sig
FIN MQ
ESCRIBA "Verificador de Semántica Variable Errores: ",error
Fin Semántica Variable
PARTE 2. CREACION DE LA LISTA DE SINO

NOMBRE APILA VERIFICA DESEMPILA


SI 1 0 0
SINO 0 1 0
FSI 0 0 1

Es necesario identificar la presencia o ausencia de un SINO por cada SI.


Entonces a continuación se propone:
a) Creación de una Estructura SINO
b) Creación de una Estructura Autómata de Pila del Sino
c) Aplicación de la Lista y Autómata de pila del SINO

Paso a: Creación de una Estructura SINO

ESTRUCTURA SINO
CONTEO: ENTERO
ESTADO: BOOLEAN
SIG; *SINO
FIN ESTRUCTURA

Paso b: Creación de una Estructura Autómata de Pila del Sino

ESTRUCTURA SI
CONTEO: ENTERO
APUNTA: *SINO
SIG: *SI
FIN ESTRUCTURA

Paso c: Declaración de Variables asociadas a la estructura sino


CABSINO, PSINO, ULTSINO: *SINO
CABSI, PSI: *SI
C_SI: ENTERO

Paso c: Aplicación del Explorador semántico SINO

CREARLISTASINO ()
PSINO=PEDIR ()
SI CABSINO == NULL ENT
CABSINO=PSINO
SINO
ULTSINO->SIG=PSINO
FSI
ULTSINO = PSINO
PSINO->SIG = NULL
PSINO->CONTEO=C_SI
PSINO->ESTADO = FALSE
FIN-CREARLISTA
DESEMPILASI ()
PSI=CABSI
CABSI=CABSI->SIG
LIBERE (PSI)
FIN

CREARPILASI ()
PSI=PEDIR ()
PSI->SIG=CABSI
PSI->CONTEO=PSINO->CONTEO
PSI->APUNTA=PSINO
CABSI=PSI
FIN

SEMANTICA_SINO()
linea=0
pf=cabf
Mientras que (pf!=NULL)
pp=pf->cab
pres= esres()
linea++
SI pres->apila==1 Entonces
c-si++
crearlistasino()
crearpilasi()
FSI
SI pres->verifica==1 Entonces
SI (cabsi->apunta)->estado Entonces
Mensint( linea, “ duplicidad de sino”)
SINO
(cabsi->apunta)->estado = Verdad
FSI
FSI
SI pres->desempila==1 Entonces
desempilasi()
FSI
Pf=pf->sig
FMQ
ESCRIBA "Verificador de Semántica del SINO Errores: ",error
FIN SEMANTICA DEL SINO
PARTE 3. CREACION DE LA LISTA DE INDICES

NOMBRE APILA VERIFICA DESEMPILA


PARA 3 0 0
FPARA 0 0 3

Es necesario identificar los índices de cada ciclo PARA


Entonces a continuación se propone:
1. Creación de una Estructura INDICE
2. Creación de una Estructura Autómata de Pila del PARA
3. Aplicación de la Lista y Autómata de pila del PARA

Paso a: Creación de una Estructura INDICE


ESTRUCTURA INDICE
CADENA SIMBOLO [6] NOMBRE DE INDICE
ENTERO CONTEO CONTADOR DEL PARA
INDICE *SIG APUNTADOR SIGUIENTE
FIN ESTRUCTURA

Paso b: Creación de una Estructura Autómata de Pila del PARA

ESTRUCTURA PARA
CONTEO: ENTERO
APUNTA: *INDICE
SIG: *PARA
FIN ESTRUCTURA

Paso c: Declaración de Variables asociadas a la estructura PARA


CABIND, PIND, ULTIND: *INDICE
CABPARA, PPARA: *PARA
C_PARA: ENTERO

Paso d: Aplicación del Explorador semántico PARA

CREARLISTAIND ()
PIND=PEDIR ()
SI CABIND == NULL ENT
CABIND=PIND
SINO
ULTIND->SIG=PIND
FSI
ULTIND = PIND
PIND->SIG = NULL
PIND->SIMBOLO=MENSAJE2
PIND->CONTEO=C_PARA
FIN-CREARLISTA
CREARPILAPARA()
PPARA=PEDIR ()
PPARA->SIG=CABPARA
PPARA->CONTEO=PIND->CONTEO
PPARA->APUNTA=PIND
CABPARA=PPARA
FIN

DESEMPILAPARA ()
PPARA=CABPARA
CABPARA=CABPARA->SIG
LIBERE (PPARA)
FIN

SEMANTICA_PARA()
c_para=0
cabind=null
cabpara=null
linea=0
pf=cabf
Mientras que (pf!=NULL)
pp=pf->cab
pres= esres()
pp=pp->sig
linea++
SI pres->apila==3 Entonces
Imprpal()
c-para++
crearlistaind()
crearpilapara()
FSI
SI pres->desempila==3 Entonces
Imprpal()
SI (cabpara->apunta)-> simbolo != mensaje2 Entonces
Mensint( linea, “ No Corresponde Indice”)
FSI
desempilaparai()
FSI
Pf=pf->sig
FMQ
ESCRIBA "Verificador de Semántica del PARA Errores: ",error
FIN SEMANTICA DEL PARA
ETAPA GENERACION DE CODIGO
APUNTES DE CLASE DE COMPILADORES LENGUAJE ARTIFICIAL
UNIVERSIDAD AUTONOMA
COMPILADORES
GENERACION DE CODIGO

PARTE 1. ESTRUCTURAS PARA LA MANIPULACION BLOQUE MQ

Paso a. Creación de una Estructura Autómata de Pila del MQ

ESTRUCTURA MQ
CONTEO: ENTERO
SIG: *MQ
FIN ESTRUCTURA

Paso b: Declaración de Variables asociadas a la estructura MQ (Lista MQ)


CABMQ, PMQ: *MQ
C_MQ: ENTERO

Paso c: Uso de la Lista MQ en el caso de Generación Código MQ

CREARPILAMQ()
PMQ=PEDIR ()
PMQ->SIG=CABMQ
PMQ->CONTEO=C_MQ
CABMQ=PMQ
FIN

DESEMPILAMQ ()
PMQ=CABMQ
CABMQ=CABMQ->SIG
LIBERE (PMQ)
FIN

Imprpal():: Método que copia el nombre de variable como una cadena


ps=pp->cab
PARA i=0 HASTA 5
SI ps!=NULL Entonces
MENSAJE2[i]=ps->c[0]
Ps=ps->sig
SINO
MENSAJE2[i]=’ ‘
FSI
FPARA
FIN

PASARVARIABLE()
PP=PP->SIG
IMPRPAL()
VAR1=MENSAJE2
PP=PP->SIG
FIN
PARTE 2. OPERADORES DE RELACION
OPERADOR DE RELACION BANDERA BN (BANDERA NEGADA)
> 1 6
< 2 5
= 4 3
>= 5 2
<= 6 1

PARTE 3. NORMALIZACION

NORMALIZACION DE UNA LECTURA


CASO LEA b
COLUMNA 1-8 COLUMNA 10-15 COLUMNA 16-80
= AH , 9
= DX , b
INT 21

NORMALIZACION DE UNA ESCRITURA

CASO ESCR b
COLUMNA 1-8 COLUMNA 10-15 COLUMNA 16-80
= AH , A
= DX , b
INT 21

Entonces para la lectura y escritura se puede parametrizar así:


COLUMNA 1-8 COLUMNA 10-15 COLUMNA 16-80
= AH , FUNCION
= DX , VARIABLE
INT 21

MÉTODO IO(CADENA VARIABLE, CADENA FUNCION)


ESCRIBA (COLUMNA 10,” = “)
ESCRIBA (COLUMNA 16,” AH , “+FUNCION)
SALTO_LINEA()
ESCRIBA (COLUMNA 10,” = “)
ESCRIBA (COLUMNA 16,” DX, “+VARIABLE)
SALTO_LINEA()
ESCRIBA (COLUMNA 10,” INT “)
ESCRIBA (COLUMNA 16,” 21“)
FIN IO
NORMALIZACION DE LAS OPERACIONES ARITMETICAS

CASO ASIGNE
ASIGNE a = b +c *d
COLUMNA 1-8 COLUMNA 10-15 COLUMNA 16-80
= a,b
+ a, c
* a,d

CASO CONDICION

MQ
PARA a > b +c *d
SI
COLUMNA 1-8 COLUMNA 10-15 COLUMNA 16-80
= R1 , b
+ R1, c
* R1 , d

Entonces para el caso de ASIGNE y CONDICION se puede parametrizar así:


COLUMNA 1-8 COLUMNA 10-15 COLUMNA 16-80
= Variable , b
+ Variable , c
* Variable , d

METODO OPERACIÓN (CADENA VARIABLE)


ESCRIBA (COLUMNA 10,” = “)
IMPRPAL()
ESCRIBA (COLUMNA 16, VARIABLE + “ , “+MENSAJE2)
SALTO_LINEA()
PP = PP ->SIG
MQ PP != NULL
ESCRIBA (COLUMNA 10, (PP->CAB)->C[0])
PP=PP->SIG
IMPRPAL()
ESCRIBA (COLUMNA 16, VARIABLE + “ , “+MENSAJE2)
SALTO_LINEA()
PP=PP->SIG
FMQ
FIN METODO OPERACION

METODO ASIGNE()
PASARVARIABLE()
PP=PP->SIG
OPERACIÓN (VAR1)
FIN ASIGNE
NORMALIZACION DEL MQ
Se toma el caso de Normalizar el MQ número 2, así será:
COLUMNA 1-8 COLUMNA 10-15 COLUMNA 16-80
MQ # 2 COMP Variable , R1
J BN , FMQ#2
……….
………
J MQ#2
FMQ #2

La clausura BN, indica Bandera Negada (remitirse a Tabla de Operadores de relación).

Para el Caso de MQ es necesario utilizar el autómata de Pila.


CABMQ: CABEZA DEL MIENTRAS QUE
PMQ: APUNTADOR DE MIENTRAS QUE
C_MQ: CONTADOR DE MQ

METODO BANDERA()
BAND=””
PS=PP->CAB
MQ PS!=NULL
BAND=BAND+PS->C[0]
PS=PS->SIG
FMQ
DD BAND
CASO “>”: RETORNE 6
CASO “<”:RETORNE 5
…VER TABLA DE BANDERAS
FDD
FIN METODO BANDERA

METODO MQ()
PASARVARIABLE()
C_MQ ++
CREARPILAMQ()
BN =BANDERA () //RETORNO DE BANDERA NEGADA
PP=PP->SIG
OPERACIÓN (“R1”)
ESCRIBA (COLUMNA 1, ”MQ# “ + C_MQ)
ESCRIBA (COLUMNA 10, ”COMP “)
ESCRIBA (COLUMNA 16, VAR1 + “ , R1”)
SALTO_LINEA()
ESCRIBA (COLUMNA 10, ”J “)
ESCRIBA (COLUMNA 16, BN+ “ , “+”FMQ# “ + C_MQ)
SALTO_LINEA()
FIN METODO MQ

METODO FMQ ()
ESCRIBA (COLUMNA 8, ”J “)
ESCRIBA (COLUMNA 16, ”MQ# “ + CABMQ->CONTEO)
SALTO_LINEA()
ESCRIBA (COLUMNA 1, ”FMQ# “ + CABMQ->CONTEO])
SALTO_LINEA()
DESEMPILAMQ()
FIN FMQ

NORMALIZACION DEL PARA


Se toma el caso de Normalizar el PARA número 2, así será:
COLUMNA 1-8 COLUMNA 10-15 COLUMNA 16-80
PARA # 2 COMP Variable , R1
J BN , FPARA#2
……….
+ Variable, 1
J PARA#2
FPARA #2
La clausura BN, indica Bandera Negada (remitirse a Tabla de Operadores de relación).
Para el Caso de PARA es necesario utilizar el autómata de Pila y Cola . Ver Semántica

METODO PARA()
PASARVARIABLE()
C_PARA ++
CREARPILAPARA()
BN =BANDERA () //RETORNO DE BANDERA NEGADA
PP=PP->SIG
OPERACIÓN (“R1”)
ESCRIBA (COLUMNA 1, ”PARA# “ + C_PARA ->CONTEO)
ESCRIBA (COLUMNA 10, ”COMP “)
ESCRIBA (COLUMNA 16, VAR1 + “ , R1”)
SALTO_LINEA()
ESCRIBA (COLUMNA 10, ”J “)
ESCRIBA (COLUMNA 16, BN+ “ , “+”FPARA# “ + C_PARA ->CONTEO)
SALTO_LINEA()
PIND=PIND->SIG
FIN METODO PARA

METODO FPARA ()
ESCRIBA (COLUMNA 10, ”+ “)
ESCRIBA (COLUMNA 16, (CABPARA->APUNTA)->SIMBOLO + “, 1 “)
SALTO_LINEA()
ESCRIBA (COLUMNA 10, ”J “)
ESCRIBA (COLUMNA 16, ”PARA# “ + CABPARA->CONTEO)
SALTO_LINEA()
ESCRIBA (COLUMNA 1, ”FPARA# “ + CABPARA->CONTEO)
SALTO_LINEA()
DESEMPILAPARA()
FIN FPARA
NORMALIZACION DEL SI
Se toma el caso de Normalizar el SI número 2, en el caso que no tenga SINO, así será:
COLUMNA 1-8 COLUMNA 10-15 COLUMNA 16-80
COMP Variable , R1
J BN , FSI # 2
……….
FSI #2

Se toma el caso de Normalizar el SI número 2, en el caso que tenga SINO, así será:
COLUMNA 1-8 COLUMNA 10-15 COLUMNA 16-80
COMP Variable , R1
J BN , SINO # 2
……….
J FSI # 2
SINO #2
……….
FSI #2

La clausura BN, indica Bandera Negada (remitirse a Tabla de Operadores de relación).


Para el Caso de PARA es necesario utilizar el autómata de Pila) y Cola . Ver Semántica

METODO SI()
PASARVARIABLE()
C_SI ++
CREARPILASI()
BN =BANDERA () //RETORNO DE BANDERA NEGADA
PP=PP->SIG
OPERACIÓN (“R1”)
ESCRIBA (COLUMNA 10, ”COMP “)
ESCRIBA (COLUMNA 16, VAR1 + “ , R1”)
SALTO_LINEA()
ESCRIBA (COLUMNA 10, ”J “)
SI PSINO->ESTADO ENT //EXISTE UN SINO POR ESTE SI
ESCRIBA (COLUMNA 16, BN+ “ , “+”SINO# “ + C_SI)
SINO
ESCRIBA (COLUMNA 16, BN+ “ , “+”FSI# “ + C_SI )
FSI
SALTO_LINEA()
PSINO=PSINO->SIG
FIN SI()

METODO SINO ()
ESCRIBA (COLUMNA 10, ”J “)
ESCRIBA (COLUMNA 16, ”FSI# “ + CABSI->CONTEO)
SALTO_LINEA()
ESCRIBA (COLUMNA 1, ”SINO# “ + CABSI->CONTEO)
SALTO_LINEA()
FIN SINO ()
METODO FSI()
ESCRIBA (COLUMNA 1, ”FSI# “ + CABSI>CONTEO])
SALTO_LINEA()
DESEMPILASI()
FIN FSI ()

PROGRAMA DE GENERACION DE CODIGO ()


PIND = CABIND ; PSINO = CABSINO
CABMQ = CABPARA = CABSI = NULL
C_MQ = C_PARA = C_SI = 0
PF= CABF
MQ PF NO NULL
PP = PF->CAB
SWITCH (MENSAJE2)
CASO “LEA”:
PP=PP->SIG
IMPRPAL()
IO (MENSAJE2, “ 9 “)
CASO “ESCR”:
PP=PP->SIG
IMPRPAL()
IO (MENSAJE2, “ A “)
CASO “ASIGNE”: ASIGNE()
CASO “SI” : SI()
CASO “MQ”: MQ()
CASO “PARA”: PARA ()
CASO “SINO” : SINO()
CASO “FSI” : FSI()
CASO “FMQ”: FMQ()
CASO “FPARA”: FPARA ()
CASO “FIN”:
ESCRIBA (COLUMNA 10, ”END “)
SALTO_LINEA()
FIN-SWITCH
PF=PF->SIG
FMQ
PV=CABV
MQ PV NO NULL
ESCRIBA (COLUMNA 1, PV->SIMBOLO)
ESCRIBA (COLUMNA 10,”DS “)
SALTO_LINEA()
PV = PV->SIG
FIN MQ
FIN GENERACION DE CODIGO
COMPILADOR REALIZADO EN LENGUAJE C
APUNTES DE CLASE DE COMPILADORES LENGUAJE ARTIFICIAL
ARCHIVO fuente.txt
PROG a
INT a
INICIO
LEA a
SI a<=b+
ASIGNE a=3
SINO
ASIGNE b=
FSI
FIN

ARCHIVO léxico.txt
〠ㅁㅂㅃㅄㅅㅆㅇㅈㅉㅊㅋㅌㅍㅎㅏㅐㅑㅒㅓㅔㅕㅖㅗㅘㅙㅚ㉡㉢㉣㉤㉥㉦㉧㉨㉩㉪㉫㉬㉭
㉮㉯㉰㉱㉲㉳㉴㉵㉶㉷㉸㉹㉺㌰㌱㌲㌳㌴㌵㌶㌷㌸㌹㐫㐭㐪㐯㔼㔾㘦㙼㜽㠨㤩

ARCHIVO reserva.txt
PROGcc1122000ccccc
INTccc1223000ccccc
INICIO0344000ccccc
ASIGNE2445000ccccc
LEAccc1445000ccccc
ESCRcc1445000ccccc
SIcccc3445100ccFSI
SINOcc0445010cccSI
FSIccc0445001cccSI
PARAcc3445300FPARA
FPARAc1445003cPARA
MQcccc3445200ccFMQ
FMQccc0445002cccMQ
FINccc0566000ccccc
ARCHIVO compila.c
char mensaje2[6];
#include <stdio.h>
#include <dos.h>
#include <stdlib.h>
#include <iostream.h>
#define punta1 (puntero) malloc(sizeof(nodo))
#define punta2 (apunta) malloc(sizeof(lista))
#define punta3 (apuntador) malloc(sizeof(fila))
#define punta4 (punta) malloc(sizeof(bloque))
int linea=0,numread,error=0,pal=0;
int salto=1,i,j,k;
char c[2];
FILE *archivo;
struct nodo
{
char c[1];
short int tipo;
struct nodo *sig;
};
typedef nodo NODO;
typedef NODO* puntero;
puntero ps;
puntero cab=NULL,p,ult;
struct bloque
{
char mensaje[5];
short int linea;
short int estado;
struct bloque *sig;
};
typedef bloque BLOQUE;
typedef BLOQUE* punta;
punta cabb=NULL,pb;
struct lista
{
puntero cab;
puntero ult;
int conteo;
int tipo;
struct lista *sig;
};
typedef lista LISTA;
typedef LISTA* apunta;
apunta pp;
struct fila
{
apunta cab;
apunta ult;
int tipo;
int conteo;
struct fila *sig;
};
typedef fila FILA;
typedef FILA* apuntador;
apuntador cabf=NULL,pf,ultf;

struct reser
{
char nombre[6];
short int tipo;
short int nivel;
short int min;
short int max;
short int apila;
short int verifica;
short int desempila;
char mensaje[5];
struct reser *sig;
};

// Apuntadores a reservadas
typedef reser RESERVADA;
typedef RESERVADA* APUNTARES;
APUNTARES pres,ultres,cabres=NULL;
int ctoe(char c)
{
int k;
switch(c)
{
case '0': k=0;
break;
case '1': k=1;
break;
case '2': k=2;
break;
case '3': k=3;
break; ///////////////////////////////
case '4': k=4;
break;
case '5': k=5;
break;
case '6': k=6;
break;
case '7': k=7;
break;
case '8': k=8;
break;
case '9': k=9;

}
return k;
}
//////////////////////////////////////////////////////
//CARGA DEL ARCHIVO DE PALABRAS RESERVADAS
int cargar_reservadas()
{
char c[19];

//APERTURA DEL ARCHIVO "fuente"(CÓDIGO FUENTE DEL PROGRAMA)


if( (archivo = fopen( "reserva.txt", "r+" )) == NULL )
{
printf("NO EXISTE ARCHIVO PALABRAS RESERVADAS, ENTER PARA
CONTINUAR...");
return 0;
}
//LECTURA DEL ARCHIVO "fuente" Y ALMACENAMIENTO EN EL VECTOR
"PROGRAMA".
while(!feof(archivo))
{

fread(c, sizeof(char), 19, archivo);


pres=(APUNTARES) malloc(sizeof(reser));

if(cabres==NULL)
cabres=pres;
else
ultres->sig=pres;

ultres=pres;
pres->sig=NULL;

for(i=0;i<6;i++)
{
if(c[i]=='c')
pres->nombre[i]=' ';
else
pres->nombre[i]=c[i];
}
pres->tipo=ctoe(c[i]);

i++;
pres->nivel=ctoe(c[i]);

i++;
pres->min=ctoe(c[i]);

i++;
pres->max=ctoe(c[i]);

i++;
pres->apila=ctoe(c[i]);
i++;
pres->verifica=ctoe(c[i]);

i++;
pres->desempila=ctoe(c[i]);

i++;
for(int y=0;y<5;y++)
{
if(c[i]=='c')
pres->mensaje[y]=' ';
else
pres->mensaje[y]=c[i];
i++;
}

fclose(archivo);
//printf("%d",cabres);
if (cabres==NULL)
//fuente es un archivo vacio
{
printf("\n\nERROR, PROGRAMA RESERVA ES UN ARCHIVO VACIO!");
printf("ENTER PARA CONTINUAR.\n\n");
return 0;
}
else
return 1;
}
void lisres()
{
pres=cabres;
printf("\n Palabras Reservadas \n");
while(pres!=NULL)
{
printf("\n");
for(i=0;i<6;i++)
printf("%c",pres->nombre[i]);
printf("%d",pres->tipo);
printf("%d",pres->nivel);
printf("%d",pres->min);
printf("%d",pres->max);
printf("%d",pres->apila);
printf("%d",pres->verifica);
printf("%d",pres->desempila);
for(int i=0;i<5;i++)
printf("%c",pres->mensaje[i]);
pres=pres->sig;
}
printf("\n");
}
APUNTARES esreser()
{
int esta=0;
pres=cabres;
while(pres!=NULL && !esta)
{
esta=1;
i=0;
ps=pp->cab;
while( ps!=NULL && esta && pres->nombre[i]!=' ' )
if(ps->c[0]==pres->nombre[i])
{
ps=ps->sig;
i++;
}
else
esta=0;
if(ps!=NULL)
esta=0;
if(ps==NULL && i<6 && pres->nombre[i]!=' ')
esta=0;
if(!esta)
pres=pres->sig;
}
if(esta)
return pres;
else
return NULL;
}
void imprpal()
{
ps=pp->cab;
for(i=0;i<6;i++)
{
if(ps!=NULL)
{
mensaje2[i]=ps->c[0];
ps=ps->sig;
}
else
mensaje2[i]=' ';
}
}
void imprmsg(char *msg)
{
for(i=0;i<5;i++)
mensaje2[i]=msg[i];
mensaje2[i]=' ';
}
void mensint(char* mensaje1,char* mensaje3)//MENSAJE SINTACTICO
{
error++;
printf("\n Error en la Linea: %d %s ",linea,mensaje1);
for(i=0;i<6;i++)
printf("%c",mensaje2[i]);
printf("%s",mensaje3);
}

void verires()
{
linea=0;
pf=cabf;
while(pf!=NULL)
{
pp=pf->cab;
linea++;
pal=0;
while(pp!=NULL)
{
pal++;
if(pp->tipo==1 && (pres=esreser())==NULL)
{
imprpal();
mensint(" Palabra: "," No es Palabra Reservada");
}

pp=pp->sig;
}
pf=pf->sig;
}
printf("\n Verificador de Palabras Reservadas Errores: %d ",error);
printf("\n");
}
void parsing()
{
linea=0;
pf=cabf;
while(pf!=NULL)
{
pp=pf->cab;
linea++;
if(pp->tipo==1)
pf->tipo=esreser()->tipo;
else
{
imprpal();
mensint(" Debe Iniciar con Palabras Reservadas no con: ","");
}

pf=pf->sig;
}
printf("\n Verificador de Parsing Errores: %d ",error);
printf("\n");
}
void nivel()
{
int min=1,max=1;
linea=0;
pf=cabf;
error=0;
while(pf!=NULL)
{
pp=pf->cab;
pres=esreser();
linea++;
if(pres->nivel>=min && pres->nivel<=max)
{
min=pres->min;
max=pres->max;
}
else
{
error++;
mensaje2[0]=' ';
mensint(" Error de Nivel ","");
if(pres->nivel>min)
{
min=pres->min;
max=pres->max;
}
}
pf=pf->sig;
}
if(min!=6)
{
error++;
mensaje2[0]=' ';
mensint(" No tiene fin el Programa ","");
}
printf("\n Verificador de Nivel Errores: %d ",error);
printf("\n");
}
void apilar()
{
pb=punta4;
pb->sig=cabb;
cabb=pb;
pb->estado=pres->apila;
pb->linea=linea;
for(i=0;i<5;i++)
pb->mensaje[i]=pres->mensaje[i];
}
void desempila()
{
pb=cabb;
cabb=cabb->sig;
free(pb);
}
void bloque()
{
cabb=NULL;
linea=0;
pf=cabf;
while(pf!=NULL)
{
linea++;
pp=pf->cab;
pres=esreser();
if(pres->apila>0)
apilar();
if(pres->verifica>0)
{
if(cabb==NULL || pres->verifica!=cabb->estado)
{
imprmsg((char *) pres->mensaje);
mensint(" Falta: "," ");
}
}
if(pres->desempila>0)
{
if(cabb==NULL || pres->desempila!=cabb->estado)
{
imprmsg((char *) pres->mensaje);
mensint(" Falta: "," ");
}
else
desempila();
}
pf=pf->sig;
}
while(cabb!=NULL)
{
imprmsg((char *) cabb->mensaje);
linea=cabb->linea;
mensint(" Falta: "," ");
desempila();
}
printf("\n Verificador de Bloque Sintactico Errores: %d ",error);
printf("\n");
}
void operacion()
{
int operando=1;
while(pp!=NULL)
{
if(operando)
{
if(pp->tipo!=2 && pp->tipo!=3)
{
imprpal();
mensint(" Esperaba variable o numero y no: ", " ");
}
}
else
{
if(pp->tipo!=4)
{
imprpal();
mensint(" Esperaba +, /, * , - y no: ", " ");
}
}
operando=!operando;
pp=pp->sig;
}
if(operando)
{
imprpal();
mensint(" Debe terminar con variable o numero y no: ", " ");
}
}
void asignacion()
{
pp=pp->sig;
if(pp->tipo!=2)
{
imprpal();
mensint(" Esperaba variable y no: ", " ");
}
pp=pp->sig;
if(pp->tipo!=7)
{
imprpal();
mensint(" Esperaba un = y no: ", " ");
}
pp=pp->sig;
operacion();
}
void condicion()
{
pp=pp->sig;
if(pp->tipo!=2)
{
imprpal();
mensint(" Esperaba variable y no: ", " ");
}
pp=pp->sig;
if(pp->tipo!=5)
{
imprpal();
mensint(" Esperaba un >,<=,>=,> y no: ", " ");
}
pp=pp->sig;
operacion();
}
void cadena()
{
linea=0;
pf=cabf;
while(pf!=NULL)
{
linea++;
pp=pf->cab;
switch(pf->tipo)
{
case 0:
if(pf->conteo>1)
{
error++;
printf("Linea: %d Debe tener no debe tener parametro ",linea);
}
break;
case 1:
if(pf->conteo!=2)
{
error++;
printf("Linea: %d Debe tener un solo parametro ",linea);
}
else
if((pp->sig)->tipo!=2)
{
pp=pp->sig;
imprpal();
mensint(" Esperaba una variable y no: ", " ");
}
break;
case 2:
if(pf->conteo<4)
{
error++;
printf("Linea: %d Le faltan parametros ",linea);
}
else
asignacion();
break;
case 3:
if(pf->conteo<4)
{
error++;
printf("Linea: %d Le faltan parametros ",linea);
}
else
condicion();
break;
}
pf=pf->sig;
}
printf("\n Verificador de Cadena Sintactica Errores: %d ",error);
printf("\n");
}
int existe(char c)
{
p=cab;
while(p!=NULL && p->c[0]!=c)
p=p->sig;
if(p!=NULL)
return p->tipo;
else
return -1;
}
apuntador agregarfila(apuntador *cab,apuntador *ultc)
{
apuntador pc;
pc=punta3;
if(*cab==NULL)
*cab=pc;
else
(*ultc)->sig=pc;
*ultc=pc;
pc->conteo=0;
pc->sig=NULL;
pc->cab=NULL;
pc->ult=NULL;
return pc;
}
apunta agregarpalabra(apunta *cab,apunta *ultc)
{
apunta pc;
pc=punta2;
if(*cab==NULL)
*cab=pc;
else
(*ultc)->sig=pc;
*ultc=pc;
pc->conteo=0;
pc->sig=NULL;
pc->cab=NULL;
pc->ult=NULL;
return pc;
}
void agregarsimbolo(puntero *lis,puntero *ultc,char c)
{
ps=punta1;
if(*lis==NULL)
*lis=ps;
else
(*ultc)->sig=ps;
*ultc=ps;
ps->c[0]=c;
ps->tipo=existe(c);
ps->sig=NULL;
}
void eliminafilas(apuntador *lis)
{
apuntador pe;
pe=*lis;
*lis=(*lis)->sig;
free(pe);
}
void eliminamulti(apunta *cab)
{
apunta pe;
pe=*cab;
*cab=(*cab)->sig;
free(pe);
}
void eliminacaracter(puntero *lis)
{
puntero pe;
pe=*lis;
*lis=(*lis)->sig;
free(pe);
}
void blanco()
{
while(!feof(archivo) && existe(c[0])==0)
numread = fread( c, sizeof( char ), 1, archivo );
}
void operando()
{
pf->conteo++;
pp=agregarpalabra(&(pf->cab),&(pf->ult));
agregarsimbolo(&(pp->cab),&(pp->ult),c[0]);
pp->tipo=ps->tipo;
pp->conteo=1;
while(!feof(archivo) && (existe(c[0])>=1 && existe(c[0])<=3))
{
numread = fread( c, sizeof( char ), 1, archivo );
if(!feof(archivo) && (existe(c[0])>=1 && existe(c[0])<=3))
{
pp->conteo++;
agregarsimbolo(&(pp->cab),&(pp->ult),c[0]);
}
}
}
void operador()
{
pf->conteo++;
pp=agregarpalabra(&(pf->cab),&(pf->ult));
agregarsimbolo(&(pp->cab),&(pp->ult),c[0]);
pp->tipo=ps->tipo;
pp->conteo=1;
while(!feof(archivo) && existe(c[0])==pp->tipo)
{
numread = fread( c, sizeof( char ), 1, archivo );
if(!feof(archivo) && existe(c[0])==pp->tipo)
{
pp->conteo++;
agregarsimbolo(&(pp->cab),&(pp->ult),c[0]);
}
}
}
void agrupador()
{
pf->conteo++;
pp=agregarpalabra(&(pf->cab),&(pf->ult));
agregarsimbolo(&(pp->cab),&(pp->ult),c[0]);
pp->tipo=ps->tipo;
pp->conteo=1;
}
void flectura()
{
int nuevo=1;
error=0;
linea=0;
numread = fread( c, sizeof( char ), 1, archivo );
salto=1;
while(!feof(archivo))
{
while(!feof(archivo) && c[0]=='\n')
{
numread = fread( c, sizeof( char ), 1, archivo );
salto=1;
}
if(!feof(archivo))
{
if(salto)
{
linea++;
pf=agregarfila(&cabf,&ultf);
salto=0;
nuevo=1;
}
switch(existe(c[0]))
{
case -1:
if(nuevo)
printf("\n Simbolos No reconocidos en la linea % d",linea);
printf(" %c",c[0]);
nuevo=0;
error++;
numread = fread( c, sizeof( char ), 1, archivo );
break;
case 0: blanco();
break;
case 1:
case 2:
case 3:operando();
break;
case 4:
case 5:
case 6:
case 7: operador();
break;
case 8:
case 9:agrupador();
break;

}
}
}
fclose(archivo);
}
void operandocaso2()
{
if(pp->conteo>6)
{
error++;
printf("\n Linea: %d Palabra: %d Excede longuitud ",linea,pal);
}
ps=pp->cab;
while(ps!=NULL)
{
// printf(" Tipo Palabra: %d Tipo Simbolo:%d \n",pp->tipo,ps->tipo);
if(ps->tipo!=pp->tipo)
{
error++;
printf("\n Linea: %d Palabra: %d Caracter: %c No Corresponde Naturaleza
",linea,pal,ps->c[0]);
}
ps=ps->sig;
}
}
void operadorcaso2()
{
if(pp->conteo>6)
{
error++;
printf("\n Linea: %d Palabra: %d Excede longuitud ",linea,pal);
}
}
void morfos2()
{
linea=0;
pf=cabf;
while(pf!=NULL)
{
pp=pf->cab;
linea++;
pal=0;
while(pp!=NULL)
{
pal++;
switch(pp->tipo)
{
case 1:
case 2:
case 3:operandocaso2();
break;
case 4:
case 5:
case 6:
case 7: operadorcaso2();
}
pp=pp->sig;
}
pf=pf->sig;
}
}
void casomorfos3()
{
apunta pptemp;
if(pf->ult==pp->sig)
pf->ult=(pp->sig)->sig;
pf->conteo--;
pptemp=pp->sig;
pp->conteo++;
(pp->ult)->sig=pptemp->cab;
pp->ult=pptemp->cab;
pp->sig=pptemp->sig;
free(pptemp);
}
void morfos3()
{
pf=cabf;
while(pf!=NULL)
{
pp=pf->cab;
while(pp!=NULL)
{
if(pp->tipo==5 && pp->sig!=NULL)
if((pp->sig)->tipo==7)
casomorfos3();
pp=pp->sig;
}
pf=pf->sig;
}
}
void lismorfos()
{
linea=0;
pf=cabf;
while(pf!=NULL)
{
pp=pf->cab;
linea++;
pal=0;
printf("\n Linea: %d ",linea);
while(pp!=NULL)
{
pal++;
printf(" ");
ps=pp->cab;
while(ps!=NULL)
{
printf("%c",ps->c[0]);
ps=ps->sig;
}
pp=pp->sig;
}
pf=pf->sig;
}
printf("\n");
}
void scaracter()
{
p=punta1;
if(cab==NULL)
cab=p;
else
ult->sig=p;
ult=p;
p->c[0]=c[0];
p->tipo=ctoe(c[1]);
p->sig=NULL;
}
void slectura()
{
while(!feof(archivo))
{
numread = fread( c, sizeof( char ), 2, archivo );
scaracter();
}
fclose(archivo);
}
void slistar()
{
linea=70;
p=cab;
printf(" Simbolos \n");
while(p!=NULL)
{
if(linea>=70)
{
printf("\n");
linea=1;
}
printf(" %c %d ",p->c[0],p->tipo);
p=p->sig;
linea=linea+5;
}
printf("\n");
}

int main()
{/* Open for read (will fail if file "data" does not exist) */
if( (archivo = fopen( "lexico.txt", "r" )) == NULL )
{
printf( "Archivo de simbolos no se puede abrir\n" );
exit(0);
}
slectura();slistar();
if(cargar_reservadas()==0)
exit(0);
lisres();
if( (archivo = fopen( "fuente.txt", "r" )) == NULL )
{
printf( "Archivo Fuente no se puede abrir\n" );
exit(0);
}
printf(" ============== Programa fuente =========== \n");
system(" type fuente.txt");
flectura();
printf("\n Programa Tokenizado Paso 1 Lexico ");
lismorfos();
printf("Numero de Errores: %d ",error);
if(error!=0)
exit(0);
morfos2();
printf("\n Programa Tokenizado Paso 2 Lexico ");
lismorfos();
printf("Numero de Errores: %d ",error);
if(error!=0)
exit(0);
morfos3();
printf("\n Programa Tokenizado Paso 3 Lexico ");
lismorfos();
verires();
if(error!=0)
exit(0);
parsing();
if(error!=0)
exit(0);
nivel();
if(error!=0)
exit(0);
system("pause");
bloque();
if(error!=0)
exit(0);
system("pause");
cadena();
system("pause");
return 0;
}

También podría gustarte