Deteccion y recuperacion de errores - GIAA

Recuperación de Errores
1
Tratamiento de Errores. Procesadores de Lenguaje I
Rutinas de Manejo de Errores
Ocupan gran parte de los compiladores
Objetivos
• Informar con claridad, exactitud
• Recuperación rápida
• recuperación no es corrección
• No debe retrasar el procesamiento de programas sin errores
• No generar errores en cascada (ej. eliminar identificador)
Acciones posibles
• Detectar errores
• Informar de los errores
• Recuperar de los errores
• Corregir errores
¿Necesidad actual de recuperación?
• Más rápido re-compilar que leer siguiente error…
2

Tratamiento de Errores. Procesadores de Lenguaje I
Tipos de Errores
Tipos de errores
• Léxicos: escribir mal un identificador, número, …
• Sintácticos: no poner un “;” al final de una sentencia,
estructura incorrecta
• Semánticos: multiplicar por una variable booleana
• Lógicos: bucle infinito
Herramientas para disminuir el número de errores ...
• Léxicos
• Si se utiliza alguna herramienta que complete palabras
• Sintácticos
• Si se utiliza algún editor basado en sintaxis (colores)
• Semánticos
• Busca funciones/clases e indica tipos especificados
3
Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación Errores Sintácticos
Ejemplo 1: análisis descendente
Gramática:
S::=a A S | b A
A::=c A | d
Tabla:
a
Σ N
S aAS bA
A
cA d
Entrada: a b ...
Estado del análisis cuando detecta el error:
Pila Entrada
$S a b ...
$SAa a b ...
$SA b ...
Error: Se ha encontrado una b, cuando se esperaba una c o d
• Podría eliminarse
b
c
d
4

Tratamiento de Errores. Procesadores de Lenguaje I
Errores en Análisis LR
Ejemplo 2: análisis ascendente
Gramática
1. S::=A A
2. A::=x A
3. A::=y
Entrada: xy
0
1
2
3
4
5
6
x
d3
d3
d3
r3
r1
r2
acción
y
d4
d4
d4
r3
r2
$
acpt
r3
r2
ir_a
S A
1 2
5
6 6
7
8
Estado del análisis cuando detecta el error: Pila Entrada
Se podría añadir un token y 0x3A6 $
0A2 $
0A2 $
5
Tratamiento de Errores. Procesadores de Lenguaje I
Estrategias de Recuperación
No hay una estrategia de aceptación universal
• Abundan técnicas heurísticas y ad hoc
Principio general de recuperación
• Minimizar tokens eliminados/modificados
• Dejar el analizador listo para continuar procesando
Principales estrategias de recuperación son:
• Modo de pánico/alarma
• Nivel de frase
• Producciones de error
• Corrección Global
6

Tratamiento de Errores. Procesadores de Lenguaje I
Modo de Pánico
Características
• Método más sencillo
• Lo pueden usar la mayoría de los AS
• No entra en lazos infinitos
• Adecuado para lenguajes en los que son raros múltiples
errores en la misma proposición
Funcionamiento general
• El AS desecha símbolos de la entrada, uno por uno, hasta
encontrar un token de sincronización para continuar
• Delimitadores (punto y coma, palabras clave como end)
Inconvenientes
• Podrían omitirse gran cantidad de símbolos sin analizar
7
Tratamiento de Errores. Procesadores de Lenguaje I
A nivel de frase
Características
• Correcciones en la cadena de entrada
Funcionamiento
• Descubierto el error se corrige (localmente) la entrada por un
prefijo que permite continuar el AS
• Sustituir una coma por un punto y coma, insertar un punto y
coma, etc.
Inconvenientes
• Dificultad para resolver situaciones en las que el error se
produjo antes de la detección de éste
• Pueden producir lazos infinitos
• Evitar insertar símbolos antes del símbolo actual en la entrada
8

Tratamiento de Errores. Procesadores de Lenguaje I
Producciones de error
Funcionamiento
• Conocidos los errores más comunes, se extiende la gramática
con producciones de error
• Reconocido el error, se dan diagnósticos precisos de la
construcción errónea
• Ej.:
E->E op T | E->T
E-> E T //falta operador
T->id | num
Inconvenientes
• Dificultad para ir más allá de los casos particulares más
frecuentes
• Generación ambigüedades
9
Tratamiento de Errores. Procesadores de Lenguaje I
Corrección Global
Características
• Algoritmos que eligen una secuencia mínima de
cambios para obtener una corrección global de
menor costo
• Ej.: x=a(p+q(-b(r-s); -> a(p+q)-b(r-s);
ifa=b then sum=0; -> if a =b then sum=0;
Inconvenientes
• Técnicas costosas en tiempo y espacio: métricas de
distancias, búsqueda, optimización, …
10

Recuperación en Analisis
Descendente Predictivo
Tratamiento de Errores. Procesadores de Lenguaje I
Detección del error
• En un procedimiento, el token de preanálisis no es
válido en esa situación
Recuperación
• Modo pánico
• Si no encuentra token apropiado, buscar hasta tokens de
sincronización
• Calcular los tokens de sincronización apropiados en cada
situación
• Conjunto siguiente del no terminal
• Conjunto primero, después
• Elección que permita rápida recuperación de los errores
más comunes
11
Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación en Análisis
Descendente Predictivo. Ejemplo
Ejemplo:
S → if B then S | write B | i := B
B → i = i | i i | true | false
PRIMERO(S)= {if, write, i}
PRIMERO(B)= {i,true,false}
Procedure S()
{
if (token== if)
{ scan();
B();
if (token== then) {scan();} else error();
S();
}
else if (token==write)
{scan();
B();
}
else if (token== i)
{ scan();
if (token == asig) {scan();} else error();
B();
}
else error()
}
Procedure B()
{
if (token= i)
{ scan();
if (token in [igual, noigual]) scan(); else error();
if (token == i) then scan else error;
}
elseif (token in [true, false])
scan();
else
error();
}
Procedure Main()
{
S();
if (token!=“$”) error
}
12

Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación en Analisis
Descendente Predictivo. Ejemplo
Ejemplo con modo pánico:
S → if B then S | write B | i := B
B → i = i | i i | true | false
Procedure S(sync)
{
buscarSinc({if, write, i}, sync);
if (not token in {if, write, i})return;
if (token== if)
{ scan();
B({then});
if (token== then) scan();
S(sync); }
else if (token==write)
{scan();
B({$}); }
else if (token== i)
{ scan();
if (token == asig) scan();
B({$}); }
buscarSinc(sync, {})
}
Procedure B(sync)
{
buscarSinc({i, true, false}, sync);
if (not token in {i, true, false}) return;
if (token= i)
{ scan();
if (token in {igual, noigual}) scan();
if (token == i) scan(); }
elseif (token in {true, false})
scan();
buscarSinc(sync, {});
}
Procedure Main()
{
S({$, if, write, i});
if (token!=“$”) error();
}
PRIMERO(S)= {if, write, i}
PRIMERO(B)= {i,true, false}
SIGUIENTE(S)= {$}
SIGUIENTE(B)= {then, $}
Procedure buscarSinc
(PRIM,SIG)
{
if (not token in PRIM){
mensajeError();
avanzar(PRIM U SIG);}
}
Procedure avanzar(A)
{
while not (token in A){
scan(); }
}
13
Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación en Analisis
Descendente Predictivo. Ejemplo
Ej.:
if a:=b then writte false
Procedure S(sync)
{
buscarSinc({if, write, i}, sync);
if (not token in {if, write, i})return;
if (token== if)
{ scan();
B({then});
if (token== then) scan();
S(sync); }
else if (token==write)
{scan();
B({$}); }
else if (token== i)
{ scan();
if (token == asig) scan();
B({$}); }
buscarSinc(sync, {})
}
Procedure B(sync)
{
buscarSinc({i, true, false}, sync);
if (not token in {i, true, false}) return;
if (token= i)
{ scan();
if (token in {igual, noigual}) scan();
if (token == i) scan(); }
elseif (token in {true, false})
scan();
buscarSinc(sync, {});
}
Procedure Main()
{
S({$, if, write, i});
if (token!=“$”) error();
}
PRIMERO(S)= {if, write, i}
PRIMERO(B)= {i,true, false}
SIGUIENTE(S)= {$}
SIGUIENTE(B)= {then, $}
Procedure buscarSinc
(PRIM,SIG)
{
if (not token in PRIM){
mensajeError();
avanzar(PRIM U SIG);}
}
Procedure avanzar(A)
{
while not (token in A){
scan(); }
}
14

Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación en Analizador LL(1)
Detección del error
• El terminal de la cima de la pila no concuerda con la
entrada
• El no terminal A de la cima de la pila y el termina a
de la entrada indexan la tabla de análisis sintáctico
una entrada vacía, M[A,a]=∅
Recuperación
• Modo pánico
• La eficacia de esta estrategia depende de la elección del
conjunto de tokens de sincronización
• La elección debe ser tal que el AS se recupere rápidamente
de los errores más comunes
15
Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación en AS LL(1)
Heurísticas para modo pánico
• Colocar todos los símbolos de SIGUIENTE(A) en el
conjunto de sincronización de A
• Saltar tokens hasta encontrar uno en SIGUIENTE(A) y sacar
A de la pila, es probable que el AS pueda seguir
• Acción especial si se vacía la pila: poner S y saltar hasta
PRIMERO(S)
• Añadir los símbolos de PRIMERO(A) al conjunto de
sincronización de A, el AS continúa con A si aparece
un token de PRIMERO(A)
• Añadir al conjunto de sincronización tokens de inicio
de bloques de una jerarquía superior (bloques, sent,
exp, …)
16
Si λ PRIMERO( ) d i ió l

Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación AS LL(1)
Modo Pánico
Ejemplo:
• E → TE’
{(,id}
{),$}
E’
• E’ → +TE’ | λ
{+,λ} {),$}
• T → FT’
T {(,id} {+,),$}
• T’ → *FT’ | λ T’ {*,λ} {+,),$}
• F → (E) | id F {(,id} {+,*),$}
Σ N
E
Primero
Siguiente
E
E’
T
T’
F
id
E→TE’
scan
T→FT’
scan
F→id
+
scan
E’→+TE’
ext
T’→λ
ext
*
scan
scan
scan
T’→*FT’
ext
(
E→TE’
scan
T→FT’
scan
F→(E)
)
ext
E’→λ
ext
T’→λ
ext
$
ext
E’→λ
ext
T’→λ
ext
17
Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación AS LL(1)
Ejemplo entrada: )id*+id
E
E’
T
T’
F
id
E→TE’
scan
T→FT’
scan
F→id
+
scan
E’→+TE’
ext
T’→λ
ext
*
scan
scan
scan
T’→*FT’
ext
(
E→TE’
scan
T→FT’
scan
F→(E)
)
ext
E’→λ
ext
T’→λ
ext
$
ext
E’→λ
ext
T’→λ
ext
18

Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación AS LL(1)
A nivel de frase
• Se llenan las entradas en blanco de la tabla con
llamadas a rutinas de error
• Las rutinas insertan, cambian o eliminan símbolos de la
entrada y emiten mensajes de error
• Pueden sacar elementos de la pila
• Hay que asegurarse de que no se produzcan lazos
infinitos
• Las acciones de recuperación deben consumir símbolos de
la entrada o de la pila
19
Gramática:
Tabla de precedencia:
E::= E·+·E | E·*·E | (·E·) | Id
Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación Precedencia por
Operador
( Id * + ) $
) •> •> •> •>
Id •> •> •> •>
* •> •>
+
(

Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación Precedencia por
Operador
Hay dos situaciones en las que un AS por precedencia
descubre errores sintácticos:
• Encontrado el pivote, no existe ninguna producción que
reducir
• Para reducir hay que decidir que regla de producción se asemeja
más al pivote
• No se cumple ninguna relación de precedencia entre el
terminal de la pila y el de la entrada actual
• Estrategia para continuar el análisis
• Las entradas en blanco de la tabla de relación de precedencia
deben especificar rutinas de recuperación de errores
• Para recuperarse hay que modificar la pila, la entrada o ambas
• Hay que prevenir los bucles infinitos
21
Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación Precedencia por
Operador
Problemas al reducir el pivote
• Para reducir hay que decidir que regla de producción se asemeja
más al pivote
• Una posibilidad es modificarlo, eliminando o insertando símbolos
hasta encontrar producción más parecida
• Ej.: A-> a E c
encontrado: aac … …
modificar a aEc … …
“a” ilegal en línea …
falta “E” en línea …
• Para casos sencillos pueden enumerarse todos los casos de
cada producción. Ej.: aritmética
• si +,* se reduce y no hay no terminales a los lados: falta
operando
• Si id se reduce y no hay no terminal a un lado: falta operador
• Si () se reduce si no terminal en medio: falta expresión
• …
22

Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación Precedencia por
Operador
No se cumple ninguna relación de precedencia entre el terminal
de la pila y el de la entrada actual
• Las entradas en blanco de la tabla de relación de precedencia deben
especificar rutinas de recuperación de errores
• Para recuperarse hay que modificar la pila, la entrada o ambas
• Hay que prevenir los bucles infinitos
Ej.:E → E+E | E-E | E*E | E/E | E↑E | (E) | -E | id
id
(
)
$
+
*
id
•>
•>
•>
•>
(
$
*
•>

Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación AS LR(1)
Detección del error
• Al consultar la tabla de acciones del AS y la entrada
es de error
• Detección más rápida que otros analizadores: propiedad
del prefijo viable
• Nunca se hace un desplazamiento posterior al token
errónea
• LR canónico nunca hace una reducción antes de anunciar
un error
• SLR y LALR pueden realizar varias reducciones antes de
anunciar un error, pero nunca desplazan un símbolo de la
entrada erróneo
• Mayor rapidez de detección al aumentar estados
25
Tratamiento de Errores. Procesadores de Lenguaje I
Detección errores AS LR(1)
Ej. SLR vs LR(1). Gramática: A->(A)|a
E
0
1
2
3
4
5
(
d3
d3
acción
a )
d2
d2
r2
d5
r1
$
acpt
r2
r1
ir_a
A
1
4
E
0
1
2
3
4
5
6
acción
( a )
d2 d3
d5 d6
d7
d5 d6
r2
$
acpt
r2
ir_a
A
1
4
8
Comparar: (a$
a)$
7
8
9
d9
r1
r1
26

Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación AS LR(1)
Recuperación LR en modo pánico
• Procedimiento heurístico que pretende:
• Identificar una construcción en proceso de ser reconocida
cuando aparece el error
• Determinar la posición en la entrada para continuar
• Algoritmo
• Se examina la pila hasta encontrar un estado s con valor
de ir_a no vacío: al menos para un símbolo no terminal A
• Se desechan símbolos de la entrada hasta encontrar un
terminal a válido para seguir al no terminal A (acción
no vacía)
• Poner en la pila el estado de ir_a[s,A] y sigue el análisis
sintáctico
27
Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación AS LR(1)
A nivel de frase
• Se construyen procedimientos de recuperación que modifiquen
la pila y/o la entrada dependiendo del error
• Los procedimientos de recuperación eliminarán o desplazarán
al menos un símbolo de la entrada o reducirán la pila si la
entrada ha sido procesada (evitar bucles infinitos)
• No extraer de la pila estados que alcancen un no terminal
(estaremos extrayendo construcciones correctamente
examinadas)
• Para evitar excesivos mensajes de error se puede extender, en
los estados en los que las reducciones son siempre al mismo
estado, la reducción a las entradas en blanco (los errores se
detectarán ahora al desplazar)
28

Tratamiento de Errores. Procesadores de Lenguaje I
Recuperación AS LR(1)
A nivel de frase
Ejemplo: id+)
E → E+E|E*E|(E)|id
e1: se esperaba un operando id ó
( pero se encontró operador o final
• introducir id en la pila y estado 3
• mostrar “falta operando”
e2: encuentra un paréntesis
• eliminar ) de la entrada
• mostrar “) no equilibrado” 6 e3 d4 d5 e3 d9
e3: se esperaba un operador pero 7 r1 r1 d5 r1 r1
se encontró id ó )
8 r2 r2 r2 r2 r2
• introducir + en la pila y estado 4
• mostrar “falta operador”
9 r3 r3 r3 r3 r3
e4: se esperaba operador ó ) pero encontró el final de la entrada
• introducir ) en la pila y estado 9
• mostrar “falta paréntesis derecho”
0
1
2
3
4
5
id
d3
e3
d3
r4
d3
d3
+
e1
d4
e1
r4
e1
e1
acción
*
e1
d5
e1
r4
e1
e1
(
d2
e3
d2
r4
d2
d2
)
e2
e2
e2
r4
e2
e2
$
e1
acpt
e1
r4
e1
e1
e4
r1
r2
r3
ir_a
E
1
6
7
8
29
Tratamiento de Errores. Procesadores de Lenguaje I
Conj. LR(0)
I 0
: [E’→•E]
[E→•E+ E]
[E→•E * E]
e1
[E→• (E)]
[E →•Id]
I 1
: [E’→E•]
[E→E•+ E]
[E→E•* E]
e3
E
(
Id
+
*
I 2
: [E→(•E)]
[E→•E+ E]
[E→•E * E]
[E→• (E)]
e1 [E →•Id]
I 3
: [E→Id•]
I 4
: [E→E+•E]
[E→•E+ E]
[E→•E * E]
[E→•(E)]
[E→•Id]
e1
I 5
: [E→E *•E]
[E→•E+ E]
[E→•E * E]
[E→•(E)]
[E→•Id]
e1
Id
e2
+
E
(
E
+
*
E
*
I 6
: [E→(E •)]
[E→E•+ E]
[E→E• * E]
e3
I 7
: [ E→E+E•]
[E→E•+ E]
[E→E• * E]
I 8
: [E→E *E •]
[E→E•+ E]
[E→E•* E]
e4
)
I 9
: [E→(E) •]
e1: esperaba operando o (
e2: encuentra un paréntesis )
e3: esperaba operador
e4: esperaba)
30

Tratamiento de Errores. Procesadores de Lenguaje I
Conclusiones de Manejo de Errores
Aspecto complejo del diseño del compilador
• Análisis cuidadoso del lenguaje y posibles errores
• No hay una estrategia de aceptación universal
• Abundan técnicas heurísticas y ad hoc
Principio general de recuperación
• Minimizar tokens eliminados/modificados
• Dejar el analizador listo para continuar procesando
Objetivos
• Informar con claridad, exactitud y extensión
• Evitar errores en cascada y procesos infinitos
Analizadores LL y LR gran capacidad para estrategias en modo
pánico y frase en función del contexto
31