Introducción a JS-PdL para la Práctica de "Procesadores de Lenguajes"

El programa principal (por donde comenzará la ejecución del programa) estará formado por todas las sentencias ubicadas fuera de las funciones.

Por tanto, la ejecución comenzaría por la primera sentencia que se encuentre en el fuente (fuera de una función) y proseguiría secuencialmente hasta el final del fichero ejecutando todas las sentencias situadas fuera de las funciones. Hay que tener en cuenta que una función se ejecuta únicamente cuando es invocada.

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 dobles ("¡Hola, mundo!") o entre comillas simples ('¡Hola, mundo!') [cada grupo deberá implementar obligatoriamente solo la que le corresponda]. 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 (por tanto, no es válido un salto de línea como tal; para usar el salto de línea, se pueden emplear las secuencias de escape).

Para representar caracteres especiales dentro de una cadena se utiliza una secuencia de escape. Una secuencia de escape se representa mediante el carácter barra inversa seguido de un determinado carácter. Algunos de estos caracteres son: el salto de línea (\n) o el carácter de barra inversa (\\) [la implementación de estos caracteres especiales es opcional].

Una cadena no puede contener más de 64 caracteres.

En JS-PdL existen dos constantes lógicas para representar verdadero y falso: true y false [es opcional implementar las constantes lógicas, que son las palabras reservadas true y false].

Son los operadores que permiten realizar la suma, resta, producto, división y módulo: +, -, *, / y % [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 y negación: &&, || y ! [obligatorio implementar al menos uno y dos como máximo]. Se aplican sobre datos lógicos y devuelven un resultado lógico.

Permiten auto-incrementar o auto-decrementar el valor de una variable entera: ++ y -- (pueden actuar como prefijos o como sufijos) [algunos grupos tienen que implementar uno de estos operadores]. Se aplican sobre variables enteras y devuelven un resultado entero modificando también el valor de la variable. Ejemplo:

a = j++; /* si j valía 5, ahora a == 5 y j == 6 */
a = ++j; /* si j valía 5, ahora a == 6 y j == 6 */

Permiten realizar asignaciones simples o realizando simultáneamente una operación: = (asignación), += (asignación con suma), -= (asignación con resta), *= (asignación con producto), /= (asignación con división), %= (asignación con módulo), &= (asignación con y lógico) y |= (asignación con o lógico) [todos los grupos tienen que implementar la asignación simple (=) y algunos grupos deberán implementar uno de los operadores de asignación con operación]. Ejemplo:

n += m;    /* es equivalente a n = n + m */
b1 &= b2;  /* es equivalente a b1 = b1 && b2 */

No se permite usar estos operadores de asignación como parte de las expresiones.

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].

Existe una sentencia de asignación en JS-PdL, que se construye mediante el símbolo de asignación = [es obligatorio implementar la sentencia de asignación por todos los grupos; los grupos que tengan el operador de asignación con operación deberán implementar también la sentencia de asignación con operación con el operador asignado]. Su sintaxis general es la siguiente: variable, operador-asignación y 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 el identificador como la expresión han de ser del mismo tipo.

let i int = 123; // i es una variable entera
let cad string;
put i;         // imprime el valor entero 123
cad= 'hola';
put 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 una función que debe estar previamente definida [implementación obligatoria].

La llamada a una función se realiza mediante el nombre de la función seguido de los parámetros actuales (separados por comas) entre paréntesis (si no tiene parámetros, hay que poner los paréntesis vacíos). Los parámetros pueden ser cualquier expresión válida en el lenguaje:

p1 (5);         /* llamada a una función con un argumento entero */ 
p2 ();          /* llamada sin parámetros a una función */ 
p3 ("", i - 8); /* llamada con dos argumentos a una función */

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

Si una función devuelve un valor, podrá incluirse una llamada a dicha función dentro de cualquier expresión. Si la llamada se realiza como una sentencia (no se realiza en una expresión), se invocará a la función pero el valor devuelto se perderá:

if (fun1 (9))    /* llamada a una función con un argumento entero */ 
c= b + fun2 (b, fun3() != 8); /* llamada con dos argumentos a una función, 
                 siendo fun3, una llamada a otra función sin argumentos */
fun2 (c, true);  /* el valor devuelto por fun2 se pierde */

JS-PdL dispone de la sentencia return para finalizar la ejecución de una función y volver al punto desde el que fue llamada [implementación obligatoria].

Una función finalizará su ejecución cuando se ejecute una instrucción return o al llegar al final del cuerpo de la función (es decir, no es obligatorio que aparezca la instrucción return).

Si una función tiene 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.

Si una función no tiene tipo devuelto (void), sus sentencias return no deberán contener una expresión.

No es necesario que todas las funciones tengan instrucción de retorno (independientemente del tipo devuelto con que se haya declarado la función) ni tampoco hay ninguna restricción a la cantidad o ubicación de las instrucciones de retorno dentro de una función.

function SumaAlCuadrado int (int a, int b)
{
  j= a + b;
  return j * j;
  /* La función finaliza y devuelve el valor entero de la expresión */
}
function pro void (int x)
{
  x= SumaAlCuadrado (x - 1, x);
   /* x contendrá el valor devuelto por la función: (x+x-1)^2 */
  if (x > (194/2)) return; /* finaliza la ejecución si se ejecuta */
  put SumaAlCuadrado (x, x);
} /* 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) sentencia

Si la condició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 función o retorno (también break o sentencias de auto-incremento o auto-decremento [para los grupos que tengan dichas opciones]); en caso contrario, se finaliza su ejecución:

if (a > b) c= b;
if (fin) put("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)
  {
     cuerpo1
  }

• if (condición) 
  {
     cuerpo1
  }
  else 
  {
     cuerpo2
  }

Si la condició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 o declaraciones, siempre entre llaves.

if (a > b)
{
  c= b;
}
else 
{
  c= a;
  if (fin)
  {
    put"adiós";
  }
}

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) 
{
   cuerpo
}

Se evalúa la condición lógica y, si resulta ser cierta, se ejecuta el cuerpo (que será un bloque de sentencias o declaraciones de variables entre llaves). Este proceso se repite hasta que la condición sea falsa:

while (n <= 10) 
{
    n= n + 1;
    put n;
} // mientras que n sea menor o igual que 10...

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

do {
   cuerpo
} while (condición);

En esta instrucción se ha de colocar un bloque de sentencias o declaraciones de variables encerradas entre llaves. Primero, se ejecuta el cuerpo; seguidamente, se evalúa la condición lógica y, si resulta ser cierta, se ejecuta de nuevo el cuerpo. Este proceso se repite hasta que la condición sea falsa:

do {
  c= a++;
  c*= b;
} while (a < b);

Esta sentencia for permite ejecutar un bucle según una condición [implementación obligatoria para algunos grupos]. La sintaxis es:

for (inicialización; condición; actualización)
{
   cuerpo
}

La inicialización debe ser una sentencia de asignación o nada; la condición debe ser una expresión lógica; y la actualización puede ser una asignación (sencilla o con operación [para los grupos que tengan esta opción]), un autoincremento o autodecremento [para los grupos que tengan esta opción] o estar vacía. El cuerpo (con cero, una o más sentencias o declaraciones de variables) está en un bloque delimitado por llaves.

El funcionamiento de este bucle es como sigue:

1. Se ejecuta la inicialización
2. Se evalúa la condición
3. Si la condición lógica es falsa, se abandona la ejecución del bucle
4. Se ejecuta el cuerpo
5. Se ejecuta la actualización
6. Se vuelve al paso 2.

for (i = 1; i < 10; i++)
{
 f *= i;
}

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:

switch (expresión)
{
  case valor1: cuerpo1
  case valor2: cuerpo2
  /* . . . */
  default: cuerpon
}

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 o declaraciones de variables). Una vez ejecutado, se continúa la ejecución de todos los cuerpos asociados a todos los valores que se encuentren a continuación hasta el final del switch. Si no se encuentra el valor, se ejecutan las sentencias asociadas a default, si el programador la ha incluido [el default es opcional para la implementación]:

switch (dia)
{
   case 1: put 'lunes';
   case 2: put 'martes';
   case 3: put 'miércoles';
   case 4: put 'jueves';
   case 5: 
           put 'viernes';
   default: put'fiesta';
} /* si dia == 4, se imprimirá: jueves viernes fiesta */

Esta sentencia aborta la ejecución de un switch [implementación obligatoria para los grupos que tengan switch]. No hay ninguna restricción en cuanto al lugar o número de veces que se puede poner la sentencia break en cada case:

switch (dia)
{
   case 0: break;
   case 1: put "lunes"; break;
   case 2: put "martes";
   case 3: put "miércoles";
           break;
   case 4: put "jueves"; break;
   case 5: put "viernes"; break;
   case 6: if (error) break; put("sábado");
   default: if (dia < 8) put  "fiesta";
} /* si dia == 4, se imprimirá: jueves */