Documentos de Académico
Documentos de Profesional
Documentos de Cultura
FACULTAD DE INGENIERIA
PROGRAMA INGENIERIA DE SISTEMAS
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
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
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
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 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 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
ANTECEDENTE LEXICO
ESTRUCTURA SIMBOLO
SIMBOLO: CHAR
NIVEL: ENTERO
SIG: *SIMBOLO
FIN ESTRUCTURA SIMBOLO
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
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
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
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
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
<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 |
<Aritméticos>:- + - * /
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
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
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
<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)
<Aritméticos>:- + - * /
ESTRUCTURA TOKENS
CONTEO: ENTERO
NIVEL: ENTERO
TOKEN: CADENA[1..6]
SIG: *TOKENS
FIN ESTRUCTURA TOKENS
NODO TOKENS
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
ESTRUCTURA SENTENCIA
LINEA: ENTERO
CONTEO: ENTERO
CAB: *TOKENS
SIG: *SENTENCIA
FIN ESTRUCTURA SENTENCIA
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
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
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
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
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
ESTRUCTURA SENTENCIA
LINEA: ENTERO
CONTEO: ENTERO
CAB: *TOKENS
SIG: *SENTENCIA
FIN ESTRUCTURA SENTENCIA
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
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
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
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
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
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
ESTRUCTURA SINO
CONTEO: ENTERO
ESTADO: BOOLEAN
SIG; *SINO
FIN ESTRUCTURA
ESTRUCTURA SI
CONTEO: ENTERO
APUNTA: *SINO
SIG: *SI
FIN ESTRUCTURA
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
ESTRUCTURA PARA
CONTEO: ENTERO
APUNTA: *INDICE
SIG: *PARA
FIN ESTRUCTURA
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
ESTRUCTURA MQ
CONTEO: ENTERO
SIG: *MQ
FIN ESTRUCTURA
CREARPILAMQ()
PMQ=PEDIR ()
PMQ->SIG=CABMQ
PMQ->CONTEO=C_MQ
CABMQ=PMQ
FIN
DESEMPILAMQ ()
PMQ=CABMQ
CABMQ=CABMQ->SIG
LIBERE (PMQ)
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
CASO ESCR b
COLUMNA 1-8 COLUMNA 10-15 COLUMNA 16-80
= AH , A
= DX , b
INT 21
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
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
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
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
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 ()
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];
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;
}