Introducción a Boreal para la Práctica de "Traductores de Lenguajes"

El programa principal (por donde comenzará la ejecución del programa) estará identificado por un subprograma especial identificado como PROGRAM con un nombre definido por el usuario, que no tiene parámetros ni devuelve nada.

Por tanto, la ejecución comenzaría por la primera sentencia que se encuentre en el PROGRAM y proseguiría secuencialmente hasta el final ejecutando todas sus sentencias. Hay que tener en cuenta que los otros subprogramas se ejecutan únicamente cuando son invocados. Ejemplo:

PROGRAM nombre; 
VAR declaración de variables
BEGIN
  sentencias
END;

Para representar las constantes enteras se utilizan los dígitos decimales. Por ejemplo: 378.

Los números enteros se tienen que poder representar con una palabra (16 bits, incluido el signo), por lo que el máximo entero válido será el 32767.

Las constantes cadena van encerradas entre comillas simples ('¡Hola, mundo!'). Se utiliza internamente el carácter nulo (cuyo código ASCII es 0) como carácter de fin de cadena. Puede aparecer cualquier carácter imprimible en la cadena (excepto los saltos de línea).

Una cadena no puede contener más de 64 caracteres (incluyendo el nulo de fin de cadena).

En Boreal existen dos constantes lógicas para representar verdadero y falso: TRUE y FALSE [es opcional implementar las constantes lógicas, que son palabras reservadas].

Son los operadores que permiten realizar la suma, resta, producto, división y módulo: +, -, *, / y MOD [obligatorio implementar al menos uno y dos como máximo]. Se aplican sobre datos enteros, proporcionando un resultado entero (en el caso de la división, redondeando el valor si es necesario).

También existen los operadores más y menos unarios: +, - [implementación opcional]. Estos operadores se pueden utilizar delante de una constante entera, una variable o una expresión.

Son los operadores que permiten realizar las comparaciones de igual, distinto, menor, mayor, menor o igual, mayor o igual: =, <>, <, >, <= y >= [obligatorio implementar al menos uno de los operadores y dos como máximo]. Se aplican sobre datos enteros y proporcionan un resultado lógico.

Representan las operaciones de conjunción, disyunción, disyunción exclusiva y negación: AND, OR, XOR y NOT [obligatorio implementar al menos uno y dos como máximo]. Se aplican sobre datos lógicos y devuelven un resultado lógico.

Representa la operación de potencia (**), es decir, un número elevado a otro número (por ejemplo, 2**8, y**x). Se aplica sobre datos enteros y devuelve un resultado entero [implementación obligatoria para los grupos que les corresponda].

Representa la operación de concatenación de cadenas (+), es decir, devuelve una cadena formada por la unión de dos cadenas. Se aplica sobre cadenas y devuelve una cadena [implementación obligatoria para los grupos que les corresponda].

Representa la pertenencia a una lista de valores (IN), es decir, devuelve cierto si el valor aparece en la lista y falso en caso contrario. La lista está formada por paréntesis con varias expresiones separadas por comas en su interior. Su notación es Expresión IN ListaExpresiones (la lista debe tener al menos una expresión). Por ejemplo, a IN (2, b, fun(9), c-(d/2)). Se aplica sobre enteros y devuelve un lógico [implementación obligatoria para los grupos que les corresponda].

Obtiene el valor máximo (MAX) o mínimo (MIN) de una lista de valores enteros. Devuelve, respectivamente, el mayor o el menor valor numérico de los elementos de una lista. La lista está formada por paréntesis con varias expresiones separadas por comas en su interior. Su notación es MAX ListaExpresiones (la lista debe tener al menos una expresión). Por ejemplo, MIN (2, b, fun(9), c-(d/2)). Se aplican sobre enteros y devuelve un entero [implementación obligatoria para los grupos que les corresponda].

En la tabla siguiente se muestra la precedencia de los operadores con el siguiente significado: los operadores del mismo grupo tienen la misma precedencia y, conforme se desciende por la tabla, la precedencia aumenta. La asociatividad de cada grupo de operadores se indica también en la tabla. En cualquier caso, el uso de paréntesis permite alterar el orden de evaluación de las expresiones [es obligatorio para todos los grupos tener en cuenta la precedencia y asociatividad de los operadores utilizados, así como el uso de paréntesis].

Las variables globales se declaran siempre fuera de los subprogramas, al principio del fichero y antes de comenzar la declaración de los subprogramas.

Cuando se declara una variable fuera de los subprogramas, la variable será global y visible hasta el final del programa. Por tanto, todos los subprogramas podrán usar todas las variables globales.

Las variables locales se declaran siempre dentro de los subprogramas.

Cuando se declara una variable en un subprograma, la variable será local y visible hasta el final del subprograma.

Hay que tener en cuenta que si una variable local tiene el mismo nombre que una variable global, la variable local "oculta" a la global y, por tanto, en ese subprograma se podrá usar esa variable local pero no la global.

Los subprogramas se declaran siempre fuera de otros subprogramas. La notación de estas declaraciones se muestra detalladamente en la sección de subprogramas.

Existe una sentencia de asignación en Boreal, que se construye mediante la operación de asignación := [es obligatorio implementar la sentencia de asignación por todos los grupos]. Su sintaxis general es la siguiente: variable := expresión;. Esta sentencia asigna a la variable el resultado de evaluar la expresión:

i:= 8 + 6;

Como ya se ha indicado, no hay conversiones entre tipos, por lo que tanto la variable como la expresión han de ser del mismo tipo.

var i: integer; { i es una variable entera }
    cad: string;
{...}
i := 123;
write (i);      { imprime el valor entero 123 }
cad:= 'hola';
write (cad);    { imprime el valor cadena “hola” }
i:= i > 88; { Error: no se puede asignar un lógico a un entero }

Esta sentencia permite invocar la ejecución de un subprograma que debe estar previamente definido [implementación obligatoria].

La llamada a un subprograma de tipo procedimiento se realiza mediante su nombre seguido de los parámetros actuales (separados por comas) entre paréntesis (si no tiene parámetros, no hay que poner los paréntesis). Los parámetros pueden ser cualquier expresión válida en el lenguaje:

p1 (5);         {llamada a un subprograma con un argumento entero} 
p2;             {llamada sin parámetros a un subprograma} 
p3 ('', i - 8); {llamada con dos argumentos a un subprograma}

Los parámetros actuales en la llamada tienen que coincidir en número y tipo con los parámetros formales de la declaración del subprograma.

Si un subprograma devuelve un valor (es una función), la llamada a dicha función deberá estar siempre dentro de una expresión:

if (fun1 (9)) {llamada a una función lógica con un argumento entero} 
c:= b + fun2(b, fun3<>8); {llamada con 2 argumentos a una función entera, 
        siendo fun3, una llamada a una función entera sin argumentos}
write (fun2 (c, true));  {se imprime el valor devuelto por fun2}

Boreal dispone de la sentencia RETURN para finalizar la ejecución de un subprograma y volver al punto desde el que fue llamado [implementación obligatoria]. El uso de la instrucción de retorno varía dependiendo de si el subprograma es de tipo función (devuelve un valor) o de tipo procedimiento (no devuelve nada).

Un subprograma finalizará su ejecución cuando se ejecute una instrucción RETURN o al llegar al final del cuerpo deL subprograma (es decir, no es obligatorio que aparezca la instrucción RETURN).

Si es un procedimiento (no tiene tipo devuelto), sus sentencias RETURN no deberán contener una expresión.

Si es una función con tipo devuelto, sus sentencias RETURN deberán contener una expresión. El tipo de la expresión retornada deberá coincidir con el tipo devuelto de la función.

No es necesario que todos los subprogramas tengan instrucción de retorno ni tampoco hay ninguna restricción a la cantidad o ubicación de las instrucciones de retorno dentro de los subprogramas.

FUNCTION SumaAlCuadrado  (a: integer; b: integer): integer;
BEGIN
  j:= a + b;
  return j * j;
  { La función finaliza y devuelve el valor entero de la expresión }
END;
PROCEDURE pro (x: integer);
Begin
  if (x > (362/2)) return; { finaliza, si se cumple la condición }
  x:= SumaAlCuadrado (x - 1, x);
   { x contendrá el valor devuelto por la función: (x+x-1)^2 }
  write (SumaAlCuadrado (x, x));
End;  { finaliza la ejecución si antes no se ejecutó el return }

Selecciona la ejecución de una sentencia, dependiendo del valor correspondiente de una condición de tipo lógico [implementación obligatoria para todos los grupos]:

IF condición THEN sentencia

Si la condición (que puede ser cualquier expresión lógica) se evalúa como cierta, se ejecuta la sentencia que puede ser cualquier sentencia simple del lenguaje, es decir, asignación, instrucción de entrada/salida, llamada a procedimiento o retorno [también exit si el grupo tiene la sentencia loop]; en caso contrario, se finaliza su ejecución:

If a > b Then c:= b;
if (fin) then write('adiós');

Selecciona la ejecución de una de las secuencias de sentencias que encierra, dependiendo del valor correspondiente de una condición de tipo lógico. Tiene dos formatos [implementación obligatoria de ambos para los grupos que les corresponda]:

• IF condición THEN
  BEGIN
     cuerpo1
  END;

• IF condición THEN
  BEGIN
     cuerpo1
  END;
  ELSE 
  BEGIN
     cuerpo2
  END;

Si la condición (que puede ser cualquier expresión lógica) se evalúa como cierta, se ejecuta el cuerpo1; en caso contrario, se ejecuta el cuerpo2 (si el programador lo ha escrito). Cada uno de estos cuerpos contendrán cero, una o más sentencias, siempre en el bloque BEGIN-END.

if a > b then
begin
  c:= b;
end;
else 
begin
  c:= a;
  if fin then
  begin writeln('adiós'); end;
end;

Esta sentencia permite repetir la ejecución de unas sentencias basándose en el resultado de una expresión lógica [implementación obligatoria para algunos grupos]. La sintaxis es:

WHILE condición DO
BEGIN
   cuerpo
END;

Se evalúa la condición (que puede ser cualquier expresión lógica) y, si resulta ser cierta, se ejecuta el cuerpo (que será un bloque de sentencias, que puede estar vacío). Este proceso se repite mientras que la condición sea verdadera:

while n <= 10 do
begin
    n:= n + 1;
    writeln (n);
end; { mientras que n sea menor o igual que 10...}

Esta sentencia permite repetir la ejecución de las sentencias del bucle hasta que se cumpla una condición [implementación obligatoria para algunos grupos]. La sintaxis es:

repeat 
   cuerpo
UNTIL condición;

En esta instrucción se ha de colocar un bloque de sentencias (puede estar vacío). Primero, se ejecuta el cuerpo; seguidamente, se evalúa la condición (que puede ser cualquier expresión lógica) y, si resulta ser falsa, se ejecuta de nuevo el cuerpo. Este proceso se repite hasta que la condición sea verdadera:

repeat
  c:= a;
  a:= a+1;
  c:= c*b;
until not (a < b);

Esta sentencia permite repetir la ejecución de las sentencias del bucle hasta que se cumpla una condición [implementación obligatoria para algunos grupos]. La sintaxis es:

LOOP 
   cuerpo
END;

Dentro del cuerpo (que puede contener cualquier cantidad de sentencias) tendrá que aparecer, una vez y solo una vez, una sentencia especial EXIT WHEN condición.

Se ejecuta el cuerpo iterativamente hasta que la condición de la sentencia EXIT sea cierta; en ese momento, se abandona el bucle:

loop 
  n:= n + 1;
  exit when n > 32766; { sale cuando n sea mayor que 32766 }
  write (n);
end;

Esta sentencia FOR permite ejecutar un bucle un número determinado de veces mientras varía un índice [implementación obligatoria para algunos grupos]. La sintaxis es:

for VariableÍndice := expresión1 to expresión2 do
BEGIN
   cuerpo
END;

La variable índice y las dos expresiones deben ser enteras. El cuerpo (con cero, una o más sentencias) está en un bloque BEGIN-END.

El funcionamiento de este bucle es como sigue:

1. Se evalúan las dos expresiones
2. Se inicializa la VariableÍndice con el valor de la expresión1
3. Si la VariableÍndice es mayor al valor obtenido al evaluar la expresión2 en el paso 1, se abandona la ejecución del bucle
4. Se ejecuta el cuerpo
5. Se incrementa en una unidad la VariableÍndice
6. Se vuelve al paso 3.

read (a);
for i:= 1 to a + 1 do
begin
  writeln (i, '^2=', i * i);
end;

Esta sentencia selecciona y ejecuta unas sentencias basándose en el resultado de una expresión [implementación obligatoria para algunos grupos]. La sintaxis de la sentencia de selección múltiple es:

CASE expresión OF
  valor1: BEGIN cuerpo1 END;
  valor2: BEGIN cuerpo2 END;
  { ... }
  OTHERWISE: BEGIN cuerpon END;
END;

Su funcionamiento es como sigue: Se evalúa la expresión (que debe ser de tipo entero), se busca el valor que coincida con el resultado (los valores tienen que ser constantes enteras) y se ejecuta su cuerpo asociado (cada cuerpo puede estar formado por cero, una o más sentencias en un bloque BEGIN-END). Una vez ejecutado el cuerpo correspondiente, se abandona la sentencia de selección. Si no se encuentra el valor, se ejecutan las sentencias asociadas a OTHERWISE, si el programador la ha incluido [otherwise es opcional para la implementación]:

case dia of
   1: begin writeln ('lunes');    end;
   2: begin writeln ('martes');   end; 
   3: begin writeln ('miércoles');end;
   4: begin writeln ('jueves');   end;
   5: begin writeln('viernes');write('¡Llega el finde!');end;
   otherwise: begin write ('Fiesta'); end;
end;

Todo programa debe tener un subprograma (y solo uno) denominado programa principal (por donde comenzará la ejecución del programa). El programa principal no lleva parámetros ni devuelve nada y no puede ser llamado explícitamente desde el programa (la llamda se produce automáticamente al ejecutar el programa). Pueden declararse variables locales (si no se declara ninguna no se pone VAR) y debe contener un bloque. El programa principal puede tener alguna instrucción return en su cuerpo, pero no es obligatorio que sea la última instrucción.

Su sintaxis es:

PROGRAM NombreProgramaPrincipal;
VAR
   declaración de variables
BEGIN
   sentencias
END;

Se pueden declarar subprogramas de tipo procedimiento. Los procedimientos pueden llevar parámetros pero no devuelven nada. Por tanto, solamente pueden ser llamados como una sentencia, y no pueden aparecer en ninguna expresión. Pueden declararse variables locales (si no se declara ninguna no se pone VAR) y debe contener un bloque. No es obligatorio que un procedimiento tenga una instrucción return en su cuerpo ni que tenga que ser la última instrucción. [Implementación de los procedimientos a los grupos que les corresponda, junto al paso de parámetros por valor y por referencia.]

Su sintaxis es:

PROCEDURE NombreProcedimiento ListaDeArgumentos;
VAR
   declaración de variables
BEGIN
   sentencias
END;

Se pueden declarar subprogramas de tipo función. Las funciones pueden llevar parámetros y tienen que devolver un valor de uno de los tipos del lenguaje. Por tanto, solamente pueden ser llamados desde una expresión que recoja el valor retornado, no pudiendo ser llamados como una sentencia. Pueden declararse variables locales (si no se declara ninguna no se pone VAR) y debe contener un bloque. [Implementación de las funciones a los grupos que les corresponda.]

El tipo de retorno de la función se determina según el Tipo que aparezca en su declaración. En caso de que alguna de instrucción return de una función tenga una expresión de un tipo distinto al declarado, será un error. No es obligatorio que una función tenga una instrucción return expresión en su cuerpo ni que tenga que ser la última instrucción. Si una función termina sin ejecutar una instrucción return expresión, devolverá un valor indeterminado.

Su sintaxis es:

FUNCTION NombreFunción ListaDeArgumentos : TipoRetorno;
VAR
   declaración de variables
BEGIN
   sentencias
END;