Error Handling

Understanding compilation errors at each phase: lexical, syntax, and semantic

Error Handling

The compiler detects and reports errors at three different phases: lexical analysis, syntax analysis, and semantic analysis. This page demonstrates common errors and how they are caught.

Error Detection Phases

1. Phase 1: Lexical Errors

   Detected during tokenization. These errors occur when the scanner encounters invalid characters or malformed tokens.

   Examples: @, #, $, or other characters not in the language.

2. Phase 2: Syntax Errors

   Detected during parsing. These errors occur when tokens are in the wrong order or structure.

   Examples: missing semicolons, mismatched parentheses, wrong keyword order.

3. Phase 3: Semantic Errors

   Detected during semantic analysis. These errors occur when code is syntactically correct but logically invalid.

   Examples: undefined variables, division by zero.

---

Lexical Errors

Lexical errors occur when the scanner encounters characters that are not part of the language.

Invalid Characters

Error Example

let x = 10;
let @invalid = 5;  // '@' is not valid
print x;

Error Output

[FASE 1] Análisis Léxico...
         (Convirtiendo código en tokens)
  ✗ Error léxico en línea 2, columna 5: carácter inesperado '@'
  ✓ Completado: 11 tokens generados

[FASE 2] Análisis Sintáctico...
         (Verificando gramática y construyendo AST)
  ✗ Error de sintaxis en línea 2, columna 5: Se esperaba nombre de 
     variable después de 'let'. Se encontró ''

[FASE 3] Análisis Semántico...
         (Verificando que el código tenga sentido)
  ⚠ Omitido debido a errores de sintaxis

  ✗ RESULTADO: 2 error(es) encontrado(s)

Explanation

• The lexer detects the invalid character @ at line 2, column 5
• It creates an ERROR token for this character
• The parser then fails because it expected an identifier after let
• Semantic analysis is skipped due to syntax errors

More Invalid Characters

Special Characters

let x = 10 $ 5;  // '$' invalid

Error: “carácter inesperado ’$’”

Hash Symbol

#define x 10;  // '#' invalid

Error: “carácter inesperado ’#’”

Backtick

let `variable = 5;  // '`' invalid

Error: “carácter inesperado ’`’”

Question Mark

let x = 5 ? 10;  // '?' invalid

Error: “carácter inesperado ’?’”

Valid characters in the language are:

• Letters: a-z, A-Z
• Digits: 0-9
• Operators: +, -, *, /, =
• Delimiters: (, ), ;
• Whitespace: spaces, tabs, newlines
• Comments: //
• Underscore: _ (in identifiers)

---

Syntax Errors

Syntax errors occur when tokens are present but in the wrong order or missing required tokens.

Missing Equal Sign

Error Example

let x 10;  // Missing '=' between x and 10
print x;

Error Output

[FASE 1] Análisis Léxico...
         (Convirtiendo código en tokens)
  ✓ Completado: 7 tokens generados

[FASE 2] Análisis Sintáctico...
         (Verificando gramática y construyendo AST)
  ✗ Error de sintaxis en línea 1, columna 7: Se esperaba '=' después 
     del nombre de variable. Se encontró '10'
  ✓ Completado: 1 sentencias parseadas

[FASE 3] Análisis Semántico...
         (Verificando que el código tenga sentido)
  ⚠ Omitido debido a errores de sintaxis

  ✗ RESULTADO: 1 error(es) encontrado(s)

Explanation

• Lexical analysis succeeds (all characters are valid)
• Parser expects = after the variable name x
• Instead, it finds the number 10
• Clear error message shows exactly what was expected and what was found

Missing Semicolon

Error Code

let x = 10  // Missing semicolon
print x;

Every statement in the language must end with a semicolon ;. This is not optional!

Mismatched Parentheses

1. Missing Closing Parenthesis

   let x = (10 + 5;
   print x;
   

   Error: “Se esperaba ’)’ después de la expresión. Se encontró ’;’”

2. Missing Opening Parenthesis

   let x = 10 + 5);
   print x;
   

   Error: “Se esperaba una expresión. Se encontró ’)’”

3. Extra Closing Parenthesis

   let x = (10 + 5));
   print x;
   

   Error: “Se esperaba ’;’ al final de la declaración. Se encontró ’)‘“

Invalid Statement Start

x = 10;  // Missing 'let' keyword
print x;

Error Message:

[FASE 2] Análisis Sintáctico...
  ✗ Error de sintaxis en línea 1, columna 1: Se esperaba 'let' o 
     'print'. Se encontró 'x'

The compiler only recognizes two types of statements:

• let declarations
• print statements

Any statement must start with one of these keywords.

---

Semantic Errors

Semantic errors occur when code is syntactically correct but violates logical rules.

Undefined Variable

Error Example

let y = x + 5;  // 'x' is not defined
print y;

Error Output

[FASE 1] Análisis Léxico...
         (Convirtiendo código en tokens)
  ✓ Completado: 10 tokens generados

[FASE 2] Análisis Sintáctico...
         (Verificando gramática y construyendo AST)
  ✓ Completado: 2 sentencias parseadas

[FASE 3] Análisis Semántico...
         (Verificando que el código tenga sentido)
  ✗ Error semántico en línea 1, columna 9: la variable 'x' no ha 
     sido declarada

  ✗ RESULTADO: 1 error(es) encontrado(s)

Explanation

• Lexical analysis: ✓ All tokens are valid
• Syntax analysis: ✓ Grammar is correct
• Semantic analysis: ✗ Variable x used before declaration

The semantic analyzer maintains a set of declared variables and checks every identifier reference.

Self-Reference in Declaration

let x = x + 1;  // 'x' used in its own definition
print x;

Error:

[FASE 3] Análisis Semántico...
  ✗ Error semántico en línea 1, columna 9: la variable 'x' no ha 
     sido declarada

Variables cannot reference themselves in their own declaration. The variable is only added to the symbol table after its initialization expression is analyzed.

Division by Zero

Error Example

let x = 10 / 0;  // Division by zero
print x;

Error Output

[FASE 1] Análisis Léxico...
         (Convirtiendo código en tokens)
  ✓ Completado: 9 tokens generados

[FASE 2] Análisis Sintáctico...
         (Verificando gramática y construyendo AST)
  ✓ Completado: 2 sentencias parseadas

[FASE 3] Análisis Semántico...
         (Verificando que el código tenga sentido)
  ✗ Error semántico en línea 1, columna 11: división entre cero 
     detectada

  ✗ RESULTADO: 1 error(es) encontrado(s)

Limitation

The compiler only detects division by zero when the divisor is a literal number (e.g., 0).

It cannot detect division by zero with variables:

let y = 0;
let x = 10 / y;  // No error at compile-time

This would cause a runtime error if the code were executed.

Variable Redeclaration Warning

let x = 5;
let x = 10;  // Redeclaring 'x'
print x;

Output:

[FASE 3] Análisis Semántico...
  ✗ Advertencia en línea 2, columna 5: la variable 'x' ya fue 
     declarada anteriormente
  ✓ Completado: 1 variables verificadas

  ✗ RESULTADO: 1 error(es) encontrado(s)

Although labeled as “Advertencia” (warning), variable redeclaration is counted as an error and prevents successful compilation.

---

Error Recovery

The compiler attempts to recover from syntax errors and report multiple errors in a single compilation.

Multiple Errors

Program with Multiple Errors

let x 10;        // Error 1: Missing '='
let y = z + 5;   // Error 2: 'z' undefined
print x          // Error 3: Missing ';'

Synchronization Points

When the parser encounters an error, it uses panic mode recovery:

1. Report the error
2. Skip tokens until a synchronization point is found:
   • Semicolon (;) - end of statement
   • Keywords (let, print) - start of new statement
3. Continue parsing from the synchronization point

This allows the compiler to report multiple errors instead of stopping at the first one.

---

Common Error Patterns

Forgetting Semicolons

Problem: Every statement must end with ;

let x = 10  // ✗ Missing semicolon
let x = 10; // ✓ Correct

The semicolon is not optional in this language.

Wrong Keyword Order

Problem: Variables must be declared with let name = value;

x let = 10;   // ✗ Wrong order
let = x 10;   // ✗ Wrong order
let x = 10;   // ✓ Correct

Using Variables Before Declaration

Problem: Variables must be declared before use

print x;      // ✗ 'x' not declared
let x = 10;

Correct order:

let x = 10;   // ✓ Declare first
print x;      // ✓ Then use

Unbalanced Parentheses

Problem: Every ( must have a matching )

let x = (10 + 5;     // ✗ Missing ')'
let x = 10 + 5);     // ✗ Extra ')'
let x = (10 + 5);    // ✓ Balanced

Invalid Operators

Problem: Only +, -, *, / are supported

let x = 10 % 3;      // ✗ Modulo not supported
let x = 10 ** 2;     // ✗ Exponentiation not supported
let x = 10 + 3;      // ✓ Addition supported

---

Error Message Format

All error messages follow a consistent format:

[Type] en línea [line], columna [column]: [description]

Components:

• Type: Error léxico, Error de sintaxis, or Error semántico
• Line: Line number where the error occurred (1-indexed)
• Column: Column number where the error occurred (1-indexed)
• Description: Human-readable explanation of the error

Example

Error semántico en línea 3, columna 9: la variable 'count' no ha sido declarada
│              │         │           │                │
│              │         │           │                └─ Description
│              │         │           └────────────────── Column number
│              │         └────────────────────────────── Line number
│              └──────────────────────────────────────── "at line"
└─────────────────────────────────────────────────────── Error type

Use the line and column numbers to quickly locate errors in your source code. Most text editors can jump to a specific line:column position.

---

Best Practices for Avoiding Errors

Always Use Semicolons

End every statement with ; - no exceptions.

Declare Before Use

Always declare variables with let before using them.

Match Parentheses

For every (, make sure there’s a corresponding ).

Check Division

Avoid dividing by zero, even with literals.

Use Valid Characters

Stick to letters, numbers, _, and supported operators.

Follow Syntax Rules

Learn the language syntax: let name = expr; and print expr;