Crea tu propio compilador – Cap. 15 – Condicionales

15.1 Introducción

En el artículo anterior implementamos las instrucciones print() y println() que nos ayudaron a mostrar texto y el contenido de variables y expresiones por pantalla. Además, aprendimos como agregar funciones del sistema.

Con print() y println() implementadas, hemos dotado de nuestro lenguaje de la posibilidad de mostrar información variada por pantalla. Pero necesitamos de un tipo de sentencias especiales para darle más poder a nuestro lenguaje.

En esta sección veremos cómo podemos implementar las sentencias condicionales, ayudándonos de las macros que nos ofrece MASM32.

var 
  x: integer;
  no_usada: integer;
begin
  x := 1;
end.

a = 1 + 5

a = 6

cons VALOR = 5
a = 1 + VALOR

x = 1
a = x + 3

a = 4

15.3 Condicionales en ensamblador

Las sentencias condicionales son aquellas que nos permiten evaluar una condición del programa, por lo general la evaluación o comparación de una variable para decidir la ejecución, o no, de un bloque del programa.

Ante todo debemos saber que en el ensamblador del Intel x86, como en la mayoría de ensambladores, no existe algo similar a lo que conocemos como una condicional de los lenguajes de alto nivel.

Lo que nos ofrecen los ensambladores típicos son una serie de instrucciones de comparación, como la instrucción CMP, en nuestra arquitectura. Dicha instrucción compara registros, variables o literales, dejando el resultado de la comparación en algunas banderas del registro FLAGS.

Consideremos el siguiente ejemplo en ensamblador, que nos permite comparar el valor de dos variables:

mov eax, X
cmp eax, Y
jl xlower

Este esquema de comparaciones similar al de varios ensambladores, y consiste en usar una instrucción de comparación o resta, para actualizar el estado de unas banderas de estado y luego usar comparaciones de salto que leen las banderas de estado.

Esta aproximación de comparación nos servirá inicialmente para comparar números.

Llevando el esquema de comparación de la figura 15.1 al ensamblador, tendríamos un código como el que sigue:

<Instrucción de comparación>
<salto condicional a FIN_IF si la comparación da FALSE>
<cuerpo del IF>
<etiqueta FIN_IF>

IF valor>1 THEN
  valor = 0;
END;

    mov eax, valor
    jle fin_if
    mov DWORD PTR valor, 0
fin_if:

.if eax == 123
...
.elseif eax !=123
...
.else
...
.endif

<Operando1> <Operador de comparación> <Operando 2>

La limitación será que el operando 2 debe ser un operando simple: Un literal o una variable. Esta limitación proviene del diseño del evaluador de expresiones (como se explicó en el Capítulo 12), y se aplica a todas las expresiones, no solo a las condicionales.

El operador de comparación puede ser cualquiera de los que definimos en nuestro lenguaje Titan: «<«, «>», «<=», «>=», «<>» o «=».

Para implementar la evaluación de las condiciones, usaremos el siguiente flujo:

Por comodidad, las tareas 3 y 4 se ejecutarán en un solo procedimiento, al que llamaremos Compare() y será el siguiente:

procedure Compare(macro: string; operation: string);
begin
  NextToken();     //Toma token
  GetOperand2();   //Evalúa segundo operando
  if MsjError<>'' then begin exit; end;
  if op1Type<>op2Type then begin
    MsjError := 'No se pueden comparar tipos diferentes';
    exit;
  end;
  //Son del mismo tipo
  if op1Type = 1 then begin  //Comparación de enteros
    asmline(macro + ' ebx ' + operation + ' eax');
  end else if op1Type = 2 then begin  //Comparación de cadenas
    asmline('invoke lstrcmp, addr _strB, addr _strA');
    if operation = '<' then begin
      asmline(macro + ' eax == -1');   // EAX<0 no funciona porque EAX es siempre positivo.
    end else if operation = '>' then begin
      asmline(macro + ' eax == 1');    // EAX>0 no funciona, porque -1 también cumple.
    end else if operation = '<=' then begin
      asmline(macro + ' (eax == -1) || (eax == 0)' );
    end else if operation = '>=' then begin
      asmline(macro + ' (eax == 1) || (eax == 0)');
    end else begin // "=" o "<>"
      asmline(macro + ' eax ' + operation + ' 0');
    end;
  end;
  resType := 1;  //En realidad, el resultado queda en la bandera ZF de la CPU.
end;

En este código también se incluye la compatibilidad de tipos entre los operandos de la condición. Se supone que el Operando 1 ya debe haber sido leído con GetOperand1().

Aquí es donde se escribe la primera línea de la condicional, la que incluye el «.IF». El código generado depende del tipo de operandos de la condición.

Observar que para las cadenas, hacemos una llamada a la función «lstrcmp» que nos devuelve el resultado de la comparación en el registro EAX. Como los valores que se devuelven en EAX, solo pueden ser -1, 0 y 1; es necesario hacer una adaptación de la condición (<, >, <=, >=, <> o =).

Este procedimiento Compare() solo terminan la evaluación de la expresión condicional. La lectura de toda la expresión, incluyendo al Operando 1, se debe hacer desde otro procedimiento, al que llamaremos EvaluateIfExpression():

procedure EvaluateIfExpression();
begin
  //Toma primer operando
  GetOperand1();
  if MsjError<>'' then begin exit; end;
  //Guarda datos del operando
  //Verifica si hay operandos, o la expresión termina aquí
  TrimSpaces();
  //Captura primer operando, asumiendo que es el único
  if srcToktyp = 0 then begin exit; end; //Terminó la línea y la expresión
  if srcToken = 'then' then begin exit; end; //Terminó la expresión
  //Hay más tokens
  //Extrae operador y operando
  if srcToken = '=' then begin
    Compare('.IF', '==');  //Puede salir con error
  end else if srcToken = '<>' then begin
    Compare('.IF', '!=');  //Puede salir con error
  end else if srcToken = '>'  then begin
    Compare('.IF', '>');  //Puede salir con error
  end else if srcToken = '<'  then begin
    Compare('.IF', '<');  //Puede salir con error
  end else if srcToken = '>=' then begin
    Compare('.IF', '>=');  //Puede salir con error
  end else if srcToken = '<=' then begin
    Compare('.IF', '<=');  //Puede salir con error
  end else begin
    MsjError := 'Error de sintaxis: ' + srcToken;
    exit;
  end;
end;

Con este código, que incluye la llamada a Compare(), ya podemos procesar la parte de la condición de las condicionales en Titan, o sea la primera línea.

El código generado tendrá la siguiente forma:

<Código de evaluación del Operando 1>
<Código de evaluación del Operando 2> 
<Llamada a la macro .IF de acuerdo a la condición>

Pero aún falta terminar de procesar la parte de los bloques de la condicional: La que incluye el cuerpo del THEN y del ELSE.

15.6 Procesamiento de los bloques THEN y ELSE.

Como ya podemos leer la condición de un IF de Titan, y solo nos falta procesar los bloques de código; vamos a crear una función adicional, a la que llamaremos processIf(), y tendrá la siguiente definición:

procedure processIf();
begin
  NextToken();  //Pasa del "print"
  EvaluateIfExpression();
  if MsjError<>'' then begin exit; end;
  TrimSpaces();
  if srcToken <> 'then' then begin
      MsjError := 'Se esperaba "then"';
      exit;
  end;
  NextToken();  //Toma el "THEN"
  //Aquí Procesamos el cuerpo de la condicional.
  ProcessBlock();   //Llamada recursiva
  if srcToken = 'end' then begin
    asmline('.ENDIF');
    NextToken();  //Toma el "THEN"
  end else if srcToken = 'else' then begin
    NextToken();
    asmline('.ELSE');
    ProcessBlock();   //Llamada recursiva
    if srcToken <> 'end' then begin
      MsjError := 'Se esperaba "end"';
      exit;
    end;
    asmline('.ENDIF');
    NextToken();  //Toma el "END"
  end else begin
    MsjError := 'Se esperaba "end"';
    exit;
  end;
end;

No hay mucho que describir aquí porque como toda la lógica de saltos de las condicionales la hace la macro .IF; nuestro procesamiento de condicionales solo se remite a leer los bloques y las palabras reservadas ELSE y END para reemplazarlas por sus correspondientes en MASM32, que serían .ELSE Y .ENDIF.

Un detalle notable, que debemos resaltar en este código, es que, para procesar el cuerpo del THEN y del ELSE, estamos haciendo una llamada a ProcessBlock() que es el procedimiento que reconoce a todas las instrucciones implementadas, incluyendo a las mismas condicionales. Esto implica que estamos haciendo uso de la recursividad. Este detalle se debe tener en cuenta cuando intentemos compilar nuestro propio código porque implica que también debemos de dotar a Titan de soporte para recursividad.

15.7 Ajustes finales y pruebas

Para a agregar el procesamiento de las condicionales a nuestro compilador, la primera tarea sería interceptar el procedimiento ProcessBlock() que procesa a las sentencias, donde de momento, solo procesamos asignaciones y la instrucción «print». Allí debemos agregar una condición más:

procedure ProcessBlock;
begin
  while EndOfBlock()<>1 do begin
    if srcToken = 'print' then begin
      processPrint(0);
      if MsjError<>'' then begin break; end;
    end else if srcToken = 'println' then begin
      processPrint(1);
      if MsjError<>'' then begin break; end;
    end else if srcToken = 'if' then begin
      processIf();
      if MsjError<>'' then begin break; end;
    end else if srcToktyp = 2 then begin
      //Es un identificador, debe ser una asignación
      ProcessAssigment();
      if MsjError<>'' then begin break; end;
      ...
  end;
end;

Con eso debería ser suficiente, pero, como estamos haciendo una llamada a ProcessBlock() desde processIf(), es casi seguro que necesitamos agregar una llamada Forward() a ProcessBlock(), en un punto anterior a processIf():

procedure ProcessBlock(); forward;

Con esta instrucción estamos indicando a Pascal que no se preocupe, que asuma que existe un procedimiento llamado ProcessBlock(), pero que lo vamos a implementar más adelante.

Así, finalmente, logramos darle a Titan la potencia como para ejecutar código de forma condicional, en lugar de solo ejecutar instrucciones linealmente.

Hagamos nuestra primera prueba:

Notar que el código ensamblador reproduce la condicional usando la macro .IF en forma similar a como lo escribimos en Titan.

También podemos incluir condicionales con el caso ELSE o inclusive anidadas:

Con las condicionales implementadas, ya tenemos la posibilidad de implementar algunos algoritmos sencillos en nuestro lenguaje de programación.

En la siguiente entrega estaremos implementando soporte para el bucle WHILE.