Práctica 1
Analizador Léxico
Dado el código fuente de un programa en PseInt, su tarea consiste en realizar el análisis
léxico sobre dicho código de acuerdo a las especificaciones descritas a continuación.
Entrada
La entrada consiste en el código fuente de un programa en PseInt el cual puede estar
correcto léxicamente o no. Note que en estas instancias no interesa si el programa tiene
errores de sintaxis o errores semánticos porque por el momento nos enfocaremos
solamente en el análisis lexico.
Salida
La salida consiste en una lista de tokens (uno por línea) especificados en el siguiente
formato: <tipo_de_token,lexema,fila,columna>
En el caso de las palabras reservadas, el tipo de token y el lexema son iguales. Entonces
solo se imprimirá en el siguiente formato: <tipo_de_token,fila,columna>
Por ejemplo:
Entrada Salida
Proceso <proceso,1,1>
entero <entero,2,5>
Definir reAl <definir,3,5>
MienTras <real,3,13>
finsi <mientras,4,5>
FinProceso <finsi,5,5>
<finproceso,6,1>
Recuerde que pseint no hace distinción entre minúsculas y mayúsculas. Excepto en las
cadenas (strings) que van entre comillas. Ahí debe ser respetada la estructura de la palabra
Note también que la indentación se ha hecho con 4 espacios. En esta práctica, se puede
considerar que un caracter de tabulación (\t) es equivalente a 4 espacios en blanco.
Los comandos especiales: leer, escribir, esperar son considerados palabras
reservadas. Note también que es su trabajo identificar cuáles son las demás palabras
reservadas según la definición del lenguaje que está publicada junto a este archivo. En el
caso de las palabras reservadas o, y, no, mod debe asumirse que se tiene el símbolo
correspondiente, es decir que por ejemplo, ‘&‘ con ‘y’ corresponden a la misma noción léxica
y se deben imprimir como <token_y,fila,columna> (ver ejemplos mas adelante).
Los identificadores se deben imprimir en el siguiente formato: <id,lexema,fila,columna>
Entrada Salida
algoritmo mi_algoritmo <algoritmo,1,1>
Definir a como Entero <id,mi_algoritmo,1,11>
a <definir,2,5>
Definir B como real <id,a,2,13>
b <como,2,15>
FinProceso <entero,2,20>
<id,a,3,5>
<definir,4,5>
<id,b,4,13>
<como,4,15>
<real,4,20>
<id,b,5,5>
<finproceso,6,1>
Note que aunque en la declaración de B está como mayúscula, en la salida se requiere
siempre imprimir con minúscula, esto es debido a que PseInt no hace distinción entre
mayúsculas y minúsculas.
● De manera similar, se deben imprimir los tokens correspondientes a cadenas no
propias del lenguaje tales como ‘1212’, ‘1.6565’ o ‘cadena’ haciendo distinción del
tipo de token que se muestra. El formato será el que sigue a continuación,
respectivamente:
<token_entero,lexema,fila,columna>
<token_real,lexema,fila,columna>
<token_cadena,lexema,fila,columna>
● Las asignaciones para las variables booleanas como verdadero, falso deben ser
tratadas como palabras reservadas a menos que estén entre comillas.
● Los operadores y símbolos especiales se deben imprimir en el siguiente formato:
<token,fila,columna>
Donde el tokenserá determinado de acuerdo a la siguiente tabla:
token nombre
~ token_neg
= token_igual
<- token_asig
<> token_dif
< token_menor
> token_mayor
<= token_menor_igual
>= token_mayor_igual
+ token_mas
- token_menos
/ token_div
* token_mul
% token_mod
; token_pyc
: token_dosp
( token_par_izq
) token_par_der
[ token_cor_izq
] token_cor_der
| token_o
& token_y
, token_coma
^ token_pot
● Los comentarios serán ignorados
● Errores: cuando el analizador detecta un error léxico debe abortar el análisis y
debe reportar el error a la salida mediante un mensaje con el siguiente formato:
>>> Error lexico (linea: X, posicion: Y)
Donde X y Y son números enteros que representan el número de línea y la posición
donde fue detectado el inicio del error léxico. Por ejemplo:
Entrada Salida
Algoritmo sin_titulo <algoritmo,1,1>
10 <id,sin_titulo,1,11>
12.31221 <token_entero,10,2,5>
"esto es una cadena" <token_real,12.31221,3,5>
'esto TAMBIEN" <token_cadena,esto es una cadena,4,5>
<token_cadena,esto TAMBIEN,5,5>
//Estas lineas se ignoran <token_cadena,e,10,5>
//pero se cuentan las lineas <token_entero,112,11,5>
<token_menos,11,9>
'e' <token_entero,122,11,11>
112 - 122 * 3 <token_mul,11,15>
FinAlgoritmo <token_entero,3,11,17>
<finalgoritmo,12,1>
Note que la cadena 'esto TAMBIEN" se abre con comilla sencilla pero se cierra con
comilla doble, esto es permitido. Además, al interior de la cadena hay caracteres en
mayúscula, lo cual se debe respetar (no cambiar a minúsculas).
Ejemplos
Entrada Salida
Proceso mi_proceso <proceso,1,1>
Definir n Como Entero; <id,mi_proceso,1,9>
n <- 100; <definir,2,5>
<id,n,2,13>
Mientras n>0 Hacer <como,2,15>
Escribir n; <entero,2,20>
n <- n-1; <token_pyc,2,26>
FinMientras <id,n,3,5>
<token_asig,3,7>
FinProceso <token_entero,100,3,10>
<token_pyc,3,13>
<mientras,5,5>
<id,n,5,14>
<token_mayor,5,15>
<token_entero,0,5,16>
<hacer,5,18>
<escribir,6,9>
<id,n,6,18>
<token_pyc,6,19>
<id,n,7,9>
<token_asig,7,11>
<id,n,7,14>
<token_menos,7,15>
<token_entero,1,7,16>
<token_pyc,7,17>
<finmientras,8,5>
<finproceso,10,1>
Entrada Salida
Proceso mi_proceso <proceso,1,1>
Definir b Como Real; <id,mi_proceso,1,9>
Definir c Como Real; <definir,2,5>
<id,b,2,13>
c $ 12; <como,2,15>
<real,2,20>
b <- (3*212 - c*323/21 ) <token_pyc,2,24>
<definir,3,5>
Escribir b; <id,c,3,13>
FinProceso <como,3,15>
<real,3,20>
<token_pyc,3,24>
<id,c,5,5>
>>> Error lexico (linea: 5, posicion: 7)
Entrada Salida
//Es un comentario <proceso,2,1>
Proceso mi_proceso <id,mi_proceso,2,9>
Definir n Como Numerico; <definir,3,5>
Definir i Como Entero; <id,n,3,13>
DEFINIR c COMO CARACTER; <como,3,15>
Definir r Como Real; <numerico,3,20>
Definir b Como Logico; <token_pyc,3,28>
<definir,4,5>
<id,i,4,13>
n <- 1;
<como,4,15>
i <- 10; <entero,4,20>
c <- 'hola'; <token_pyc,4,26>
r <- 3.141212; <definir,5,5>
b <- Verdadero; <id,c,5,13>
<como,5,15>
Escribir N,' ',i,' ',c,' ',r,' ',b; <caracter,5,20>
FinProceso <token_pyc,5,28>
<definir,6,5>
<id,r,6,13>
<como,6,15>
<real,6,20>
<token_pyc,6,24>
<definir,7,5>
<id,b,7,13>
<como,7,15>
<logico,7,20>
<token_pyc,7,26>
<id,n,9,5>
<token_asig,9,7>
<token_entero,1,9,10>
<token_pyc,9,11>
<id,i,10,5>
<token_asig,10,7>
<token_entero,10,10,10>
<token_pyc,10,12>
<id,c,11,5>
<token_asig,11,7>
<token_cadena,hola,11,10>
<token_pyc,11,16>
<id,r,12,5>
<token_asig,12,7>
<token_real,3.141212,12,10>
<token_pyc,12,18>
<id,b,13,5>
<token_asig,13,7>
<verdadero,13,10>
<token_pyc,13,19>
<escribir,15,5>
<id,n,15,14>
<token_coma,15,15>
<token_cadena, ,15,16>
<token_coma,15,19>
<id,i,15,20>
<token_coma,15,21>
<token_cadena, ,15,22>
<token_coma,15,25>
<id,c,15,26>
<token_coma,15,27>
<token_cadena, ,15,28>
<token_coma,15,31>
<id,r,15,32>
<token_coma,15,33>
<token_cadena, ,15,34>
<token_coma,15,37>
<id,b,15,38>
<token_pyc,15,39>
<finproceso,16,1>
Entrada Salida
Proceso sin_titulo <proceso,1,1>
si 2>1 y no 2<3 Entonces <id,sin_titulo,1,9>
Escribir 2; <si,2,5>
FinSi <token_entero,2,2,8>
o; <token_mayor,2,9>
FinProceso <token_entero,1,2,10>
<token_y,2,12>
<token_neg,2,14>
<token_entero,2,2,17>
<token_menor,2,18>
<token_entero,3,2,19>
<entonces,2,21>
<escribir,3,9>
<token_entero,2,3,18>
<token_pyc,3,19>
<finsi,4,5>
<token_o,5,5>
<token_pyc,5,6>
<finproceso,6,1>
Entrada Salida
Proceso sin_titulo <proceso,1,1>
si !2>1 y no 2<3 Entonces <id,sin_titulo,1,9>
Escribir 2; <si,2,5>
FinSi >>> Error lexico (linea: 2, posicion: 8)
FinProceso
Entrada Salida
<token_cadena,á,2,5>
'á' >>> Error lexico (linea: 3, posicion: 5)
á
}
Entrada Salida
"hola" <> "hello" <token_cadena,hola,1,1>
"hol" <token_dif,1,8>
"ho" <token_cadena,hello,1,11>
"h" <token_cadena,hol,2,1>
"" <token_cadena,ho,3,1>
entero <token_cadena,h,4,1>
y & <token_cadena,,5,1>
o | <entero,6,1>
no ~ <token_y,7,1>
mod % <token_y,7,3>
<token_o,8,1>
<token_o,8,3>
<token_neg,9,1>
<token_neg,9,4>
<token_mod,10,1>
<token_mod,10,5>
Entrada Salida
233.2 <token_real,233.2,1,1>
1.1212 <token_real,1.1212,2,23>
<token_real,122.212,6,18>
>>> Error lexico (linea: 7, posicion: 1)
122.212
123as
Note que no se permiten acentos ni caracteres especiales por fuera de las cadenas, pero si
dentro de ellas. Las cadenas no pueden contener comillas en su interior (‘ o “) ya que se
asumiría que es el final de la cadena, es decir, no existe un caracter de escape para usar
estas comillas dentro de una cadena.
Observaciones finales
Los casos de prueba citados en este documento pueden no servir igualmente por el cambio
de formato de los caracteres que hace el editor de texto, por esto, debe trabajar con los
casos de prueba dispuestos en la plataforma de evaluación.
