LyAII Evidencia1 TorresEsquivelHenry

Instituto Tecnológico Superior Progreso
Dirección General
Subdirección Académica
INSTITUTO TECNOLÓGICO
SUPERIOR PROGRESO
PROGRAMA ACADÉMICO DE INGENIERÍA EN
SISTEMAS COMPUTACIONALES
ASIGNATURA
Lenguajes y Autómatas II
DOCENTE
Dr. Holzen A. Martínez García
TRABAJO
Evidencia 1 – Reporte de investigación. Errores
Semánticos
PRESENTA
Br. Henry Efrain Torres Esquivel (04190031)
Progreso Yucatán, 05 de 09 de 2022.
Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Tel. 969 934 3023 Cel. 999 278 6219
tecnm.mx | progreso.tecnm.mx
Dirección General
Índice.
Contenido
Introducción. ..................................................................................................................... 4
Marco teórico. ................................................................................................................... 5
Errores semánticos. ....................................................................................................... 5
¿Cómo se producen? ................................................................................................. 5
Manejo de errores semánticos. ..................................................................................... 7
Comprobaciones de tipos en expresiones. ........................................................................ 8
¿En qué consiste?.......................................................................................................... 8
Comprobaciones estáticas. .................................................................................... 8
Ejemplo......................................................................................................................... 8
Comprobaciones dinámicas. .................................................................................. 9
Ejemplo......................................................................................................................... 9
Verificación de tipos. ........................................................................................... 10
Ejemplo....................................................................................................................... 10
Inferencia de tipos. .............................................................................................. 11
Ejemplo....................................................................................................................... 11
Conclusiones................................................................................................................... 12
Referencias. .................................................................................................................... 13
Instrumento de evaluación. ............................................................................................. 14

Tel. 969 934 3023 Cel. 999 278 6219
Dirección General
Evidencia 1 – Reporte de investigación. Errores Semánticos.
Instrucciones: Elabora un reporte de investigación acerca de los errores semánticos y la

comprobación de tipos utilizadas en esta fase.

Tel. 969 934 3023 Cel. 999 278 6219 3
Dirección General
Introducción.
En el siguiente reporte de investigación se indagará acerca de los errores semánticos,

enfocados específicamente en los siguientes puntos: ¿cómo se producen?, los principales
errores semánticos y cómo manejarlos.
De igual forma, se indagará sobre el tema de comprobaciones de tipos en expresiones,

enfocados en los siguientes puntos: ¿en qué consisten?, sus tipos y ejemplos.
Finalmente, se concluirá con el reporte de investigación en forma de resumen, definiendo

los conceptos mencionados del documento para el mejor entendimiento del tema
presentado.
Un error semántico se produce cuando la sintaxis del código es correcta, pero la semántica
o significado no es el que se pretendía. La construcción obedece las reglas del lenguaje,
y por ello el compilador o intérprete no detectan los errores semánticos.
Las comprobaciones de tipos en expresiones verifican que los tipos y valores asociados a
los objetos de un programa se utilizan de acuerdo con la especificación del lenguaje.
Detectan conversiones implícitas de tipos para efectuarlas o insertar el código apropiado

para efectuarlas, almacenan información relativa a los tipos de los objetos y aplican las
reglas de verificación de tipos.
Para entender de mejor manera lo antes mencionado, se especifican los puntos en los
siguientes apartados.

Tel. 969 934 3023 Cel. 999 278 6219 4
Dirección General
Marco teórico.
Errores semánticos.
¿Cómo se producen?
Un error semántico se produce cuando la sintaxis del código es correcta, pero la semántica
o significado no es el que se pretendía. La construcción obedece las reglas del lenguaje,
y por ello el compilador o intérprete no detectan los errores semánticos. Los compiladores
e intérpretes sólo se ocupan de la estructura del código que se escribe, y no de su
significado.
Algunas de las características de un lenguaje de programación no pueden enunciarse con

reglas independientes del contexto, ya que dependen de él; por ejemplo, la restricción de
que los identificadores deben declararse previamente. Por lo tanto, los principales errores
semánticos son:
• Conversiones de tipos no permitidas.
int x;
x = 4.32;
Error: Ej1.java [6:1] Possible loss of accuracy

Figura 1. Ejemplo de conversiones de tipos no permitidas (lenguaje: Java).
• Variables usadas y no definidas
Figura 2. Ejemplo de variables usadas y no definidas (lenguaje: M).
• Operandos de tipos no compatibles
if (x || 5) x = 0;
Error: Ej2.java [7:1] operator || cannot be applied to

int, int
Figura 3. Ejemplo de operandos de tipos no compatibles.

Tel. 969 934 3023 Cel. 999 278 6219 5
Dirección General
Otros errores semánticos:
• Errores de puntuación.
• Errores de palabras clave.
• Otros tipos de errores.
Los errores que puede detectar el analizador sintáctico son aquellos que violan las reglas
de una gramática independiente del contexto.
Es mucho más difícil introducir métodos formales para la recuperación de errores

semánticos que para la recuperación de errores sintácticos. No obstante, puede requerirse
que, por lo menos, el error semántico sea informado al programador, que se le ignore y
que, por tanto, se suprimirá la generación de código.
Sin embargo, la mayoría de los errores semánticos pueden ser detectados mediante la
revisión de la tabla de símbolos, suponiendo un tipo que se base en el contexto donde
ocurra o un tipo universal que permita al identificador ser un operando de cualquier
operador del lenguaje. Al hacerlo, evitamos la producción de un mensaje de error cada
vez que se use la variable no definida. Si el tipo de un operando no concuerda con los
requisitos de tipo del operador, también es conveniente reemplazar el operando con una
variable ficticia de tipo universal.
Figura 4. Ejemplo de tabla de símbolos.
En cierto modo, este tipo de error es el más difícil de depurar, ya que ni el compilador ni
el sistema proporcionan información sobre qué está fallando. Lo único cierto es que el
programa no se está comportando como debería.

Tel. 969 934 3023 Cel. 999 278 6219 6
Dirección General
Manejo de errores semánticos.
Es una de las misiones más importantes de un compilador, aunque, al mismo tiempo, es

lo que más dificulta su realización. A veces unos errores ocultan otros. Un error provoca
una avalancha de muchos errores que se solucionan con el primero.
Es conveniente un buen manejo de errores, y que el compilador detecte todos los errores
que tiene el programa y no se pare en el primero que encuentre. Hay, pues, dos criterios
a seguir a la hora de manejar errores:
• Pararse al detectar el primer error.

• Detectar todos los errores de una pasada.
El análisis semántico es posterior al sintáctico y mucho más difícil de formalizar que éste.
Se trata de determinar el tipo de los resultados intermedios, comprobar que los
argumentos que tiene un operador pertenecen al conjunto de los operadores posibles, y si
son compatibles entre sí, etc. En definitiva, comprobará que el significado de lo que se va
leyendo es válido.
La salida "teórica" de la fase de análisis semántico sería un árbol semántico. Consiste en

un árbol sintáctico en el que cada una de sus ramas ha adquirido el significado que debe
tener. En el caso de los operadores polimórficos (un único símbolo con varios
significados), el análisis semántico determina cuál es el aplicable.
Figura 5. Ejemplo de fase de análisis semántico recorriendo un árbol sintáctico.

Tel. 969 934 3023 Cel. 999 278 6219 7
Dirección General
Comprobaciones de tipos en expresiones.
¿En qué consiste?
La labor de comprobación de tipos consiste en conferir a las construcciones sintácticas

del lenguaje la semántica de tipificación y en realizar todo tipo de comprobaciones de
dicha índole. Por su naturaleza, sin embargo, ésta se encuentra repartida entre la fase de
análisis semántico y la generación de código intermedio.
• Comprobaciones estáticas.
Las comprobaciones estáticas recogen el compendio de todas aquellas tareas de carácter

semántico que, por su naturaleza, pueden ser realizadas directamente durante la fase de
compilación mediante el uso de los artefactos y mecanismos propios de dicha fase. Este
tipo de comprobaciones son beneficiosas puesto que confieren seguridad a la ejecución
del programa.
Ejemplo.
Code Analysis: para controladores es una herramienta de comprobación estática que se

ejecuta en tiempo de compilación. Análisis de CCode para controladores puede
comprobar los controladores escritos en C/C++ y el código administrado. Examina el
código de cada función de un controlador de forma independiente, por lo que puede
ejecutarlo en cuanto pueda compilar el controlador. Se ejecuta con relativa rapidez y usa
pocos recursos.
Figura 6. Representación ilustrada de un análisis de código.

Tel. 969 934 3023 Cel. 999 278 6219 8
Dirección General
• Comprobaciones dinámicas.
Las comprobaciones dinámicas son aquellas que no se realizan durante la fase de

compilación y se delegan al momento de la ejecución del programa. Ello requiere generar
código ejecutable específicamente diseñado para realizar tales comprobaciones. Los
lenguajes con una carga excesiva de comprobaciones dinámicas generan programas más
largos, lentos e inseguros en ejecución.
Ejemplo.
Driver Verifier: es una herramienta de verificación dinámica escrita especialmente para

Windows controladores. Incluye varias pruebas que se pueden ejecutar en varios
controladores simultáneamente. El comprobador de controladores es tan eficaz para
encontrar errores graves en los controladores que los desarrolladores y evaluadores de
controladores experimentados configuran Driver Verifier para que se ejecute siempre que
su controlador se ejecute en un entorno de desarrollo o prueba. Driver Verifier se incluye
en Windows. Al habilitar Driver Verifier para un controlador, también debe ejecutar
varias pruebas en el controlador. El comprobador de controladores puede detectar
determinados errores del controlador que son difíciles de detectar mediante el uso de
herramientas de verificación estáticas por sí solos.
Figura 7. Ejemplo de comprobador de controladores.

Tel. 969 934 3023 Cel. 999 278 6219 9
Dirección General
• Verificación de tipos.
Comprueba la compatibilidad de tipos de todas las expresiones del código fuente

recuperando la información durante la gestión de declaraciones. Además, se asegura de
que no existe en el programa ninguna referencia a ningún símbolo no declarado.
Ejemplo.
En algunos lenguajes de tipos estrictos, solo puede agregar dos enteros o dos números de
coma flotante, pero puede marcar un error si lo intenta para agregar un número entero a
un flotante.
C ++ está en algún lugar en el medio. En C ++ permite algunas conversiones implícitas.

C y C ++ tienen un par de lagunas. Primero, se llama casting. La conversión es
básicamente decirle al compilador que elija una variable como «este tipo» en lugar del
valor declarado. Si queremos que el float sea tratado como un int, podemos convertir el
float en un int, como se demuestra a continuación:
int x, a; float y, b;
b = x + y;
a = x + (int) y; /*o puede querer*/ a = (int) (x + y);
/*Dado que los punteros generalmente se escriben, podemos

usar la conversión para hacer que una estructura se vea
como otro tipo de estructura.*/
typedef struct {/ * miembros * /} A;
typedef struct {/ * miembros * /} B;
A ax;
B * bp;
bp = &ax; // Error: ¡diferentes tipos de punteros!
bp = (B *) &ax; // define efectivamente una superposición

A con B como una unión
Figura 8. Ejemplo de código de verificación de tipos.

Tel. 969 934 3023 Cel. 999 278 6219 10
Dirección General
Con los punteros también hay un vacío * que es un puntero comodín. Permite el uso donde
se permite cualquier tipo de puntero, tales funciones de tipo mem, p. Ej. memcpy.
• Inferencia de tipos.
En lenguajes sin tipificación de variables o con sobrecarga se aplican tareas de inferencia

de tipos en el nivel gramatical de las expresiones para resolver el tipo de datos de la
expresión resultante en función del contexto de evaluación.
Ejemplo.
Determina el tipo de un objeto a partir de sus componentes:
Figura 9. Ejemplo de código de inferencia de tipos.
No puede ser Ta, ni Tb.

Tel. 969 934 3023 Cel. 999 278 6219 11
Dirección General
Conclusiones.
Un error semántico se produce cuando la sintaxis del código es correcta, pero la

semántica o significado no es el que se pretendía. La construcción obedece las reglas del
lenguaje, y por ello el compilador o intérprete no detectan los errores semánticos. Los
compiladores e intérpretes sólo se ocupan de la estructura del código que se escribe, y no
de su significado.
Un error semántico puede hacer que el programa termine de forma anormal, con o sin un
mensaje de error. Hablando en términos coloquiales, puede hacer que el equipo se quede
"colgado".
El manejo de errores semánticos es una de las misiones más importantes de un

compilador, aunque, al mismo tiempo, es lo que más dificulta su realización. A veces
unos errores ocultan otros. Un error provoca una avalancha de muchos errores que se
solucionan con el primero. Es conveniente un buen manejo de errores, y que el
compilador detecte todos los errores que tiene el programa y no se pare en el primero que
encuentre.
Hay que señalar que los posibles errores ya deben estar considerados al diseñar un
lenguaje de programación. Por ejemplo, considerar si cada proposición del lenguaje de
programación comienza con una palabra clave diferente (excepto la proposición de
asignación, por supuesto). Sin embargo, es indispensable lo siguiente:
1. El compilador debe ser capaz de detectar errores en la entrada;
2. El compilador debe recuperarse de los errores sin perder demasiada información;
3. Y, sobre todo, el compilador debe producir un mensaje de error que permita al

programador encontrar y corregir fácilmente los elementos (sintácticamente)
incorrectos de su programa.
Las comprobaciones de tipos consisten en conferir a las construcciones sintácticas del

lenguaje la semántica de tipificación y en realizar todo tipo de comprobaciones. Por su
naturaleza, sin embargo, ésta se encuentra repartida entre la fase de análisis semántico y
la generación de código intermedio.
La verificación de tipos se puede hacer en forma: Estática (en tiempo de compilación)

y Dinámica (en tiempo de ejecución).
Verifica:
• Compatibilidad entre un operador y sus operandos.

• Flujo de control sea correcto.
• Duplicidad de nombres cuando esto sea prohibido.
La etapa de análisis semántico detecta la validez semántica de las sentencias aceptadas

por el analizador sintáctico, revisa el conjunto de reglas que especifican el significado de
las sentencias sintácticas y las compara, verificando su correcta escritura.

Tel. 969 934 3023 Cel. 999 278 6219 12
Dirección General
Referencias.
1. Alonso, L. (2022). 1.7 Manejo de errores semánticos. Lenguajes y Autómatas II.

1.7 Manejo de errores semánticos (lenguajeyautomatasiildd.blogspot.com)
2. En Compiladores e Intérpretes. Teoria y Practica, de M Moreno, M de la cruz, A

Ortega y E Pulido, 78-85, 191-194, 199-204, 221-223. España: Pearson- Prentice
Hall, 2006.
3. En Compiladores, Principios, Técnicas y Herramientas, de Sethi, R, Ullman, J

Aho A, 86-89,94-108,115-131,164-187,190-193,200-201,209-212,221-226,264-
274,443-444. U.S.A: Adisson-Wesley Iberoamericana, 1990.
4. En Sistema Operativos y Compiladores, de Jesus Salas Parilla, 149,150,173,174.

México: Mc Graw-Hill, 1992.
5. Meza, M. (2013). MANEJO DE ERRORES SEMÁNTICOS. Prezi. MANEJO

DE ERRORES SEMÁNTICOS by marisela meza molina (prezi.com)
6. Neira, J. (s.f.). Lección 2: Comprobación de Tipos. Unizar. Microsoft PowerPoint

- L2-Comprobación de Tipos, B.ppt (unizar.es)
7. S / A. (2020). 1.3.- COMPROBACIONES DE TIPOS EN EXPRESIONES.

Lenguajes y Autómatas II. 1.3.- Comprobaciones de tipos en expresiones -
Lenguajes y Autómatas II (site123.me)
8. S / A. (2020). 1.7.- MANEJO DE ERRORES SEMÁNTICOS. Lenguajes y

Autómatas II. 1.7.- Manejo de errores semánticos - Lenguajes y Autómatas II
(site123.me)
9. S / A. (s.f.). 4.5 Errores Semánticos. Autómatas y Compiladores. 4.5 Errores

Semánticos (uaeh.edu.mx)
10. S / A. (s.f.). Unidad 1. Análisis semántico. Moodle. lengaut2: Análisis Semántico

(tecnm.mx)

Tel. 969 934 3023 Cel. 999 278 6219 13
Dirección General
Instrumento de evaluación.

Tel. 969 934 3023 Cel. 999 278 6219 14

LyAII Evidencia1 TorresEsquivelHenry

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

LyAII Evidencia1 TorresEsquivelHenry

Uploaded by

Copyright:

Available Formats

Instituto Tecnológico Superior Progreso

Progreso Yucatán, 05 de 09 de 2022.

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Evidencia 1 – Reporte de investigación. Errores Semánticos.

Instrucciones: Elabora un reporte de investigación acerca de los errores semánticos y la

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

En el siguiente reporte de investigación se indagará acerca de los errores semánticos,

De igual forma, se indagará sobre el tema de comprobaciones de tipos en expresiones,

Finalmente, se concluirá con el reporte de investigación en forma de resumen, definiendo

Detectan conversiones implícitas de tipos para efectuarlas o insertar el código apropiado

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Algunas de las características de un lenguaje de programación no pueden enunciarse con

• Conversiones de tipos no permitidas.

Error: Ej1.java [6:1] Possible loss of accuracy

• Variables usadas y no definidas

Figura 2. Ejemplo de variables usadas y no definidas (lenguaje: M).

• Operandos de tipos no compatibles

Error: Ej2.java [7:1] operator || cannot be applied to

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Otros errores semánticos:

Es mucho más difícil introducir métodos formales para la recuperación de errores

Figura 4. Ejemplo de tabla de símbolos.

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Manejo de errores semánticos.

Es una de las misiones más importantes de un compilador, aunque, al mismo tiempo, es

• Pararse al detectar el primer error.

La salida "teórica" de la fase de análisis semántico sería un árbol semántico. Consiste en

Figura 5. Ejemplo de fase de análisis semántico recorriendo un árbol sintáctico.

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Comprobaciones de tipos en expresiones.

¿En qué consiste?

La labor de comprobación de tipos consiste en conferir a las construcciones sintácticas

Las comprobaciones estáticas recogen el compendio de todas aquellas tareas de carácter

Code Analysis: para controladores es una herramienta de comprobación estática que se

Figura 6. Representación ilustrada de un análisis de código.

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Las comprobaciones dinámicas son aquellas que no se realizan durante la fase de

Driver Verifier: es una herramienta de verificación dinámica escrita especialmente para

Figura 7. Ejemplo de comprobador de controladores.

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Comprueba la compatibilidad de tipos de todas las expresiones del código fuente

C ++ está en algún lugar en el medio. En C ++ permite algunas conversiones implícitas.

a = x + (int) y; /*o puede querer*/ a = (int) (x + y);

/*Dado que los punteros generalmente se escriben, podemos

typedef struct {/ * miembros * /} A;

typedef struct {/ * miembros * /} B;

bp = &ax; // Error: ¡diferentes tipos de punteros!

bp = (B *) &ax; // define efectivamente una superposición

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

En lenguajes sin tipificación de variables o con sobrecarga se aplican tareas de inferencia

Determina el tipo de un objeto a partir de sus componentes:

Figura 9. Ejemplo de código de inferencia de tipos.

No puede ser Ta, ni Tb.

Boulevard Tecnológico de Progreso S/N por 62 Progreso, Yucatán, C.P. 97320

Un error semántico se produce cuando la sintaxis del código es correcta, pero la

El manejo de errores semánticos es una de las misiones más importantes de un

1. El compilador debe ser capaz de detectar errores en la entrada;

2. El compilador debe recuperarse de los errores sin perder demasiada información;

3. Y, sobre todo, el compilador debe producir un mensaje de error que permita al

Las comprobaciones de tipos consisten en conferir a las construcciones sintácticas del

La verificación de tipos se puede hacer en forma: Estática (en tiempo de compilación)

• Compatibilidad entre un operador y sus operandos.

a = x + (int) y; /o puede querer/ a = (int) (x + y);