intprom
Anterior | Documentación de referencia de programas | Siguiente

## Nombre de referencia

intprom — Interprete del lenguaje `prom`, apropiado para efectuar promedios y cálculos sencillos

## Sinopsis

intprom [`opciones`] `arch-prom` [`arch-prom ...`]

## Descripción

intprom recibe uno o más programas en lenguaje `prom`. Por defecto chequea sintacticamente e interpreta cada uno de los programas que recibe (ver opciones `-interp` y `-interp-no`) ejecutando antes el prologo si lo hay (ver opción `-prologo`). Opcionalmente

- Si se indica el tipo del valor que debe retornar, puede realizar un chequeo de tipos (opción `-chtipo `tipo``)

- Puede indentar e imprimir cada programa que recibe (opción `-indent`)

- Puede presentar el estado de todas las variables después de interpretar cada programa (opción `-estado`).

Las opciones son las siguientes:

`-ayuda`

  Presenta ayuda corta y opciones

`-D`

  Establece otro directorio en el cual buscar archivos con más precedencia

`-man`

  Presenta página del manual

`-refentry`

  Presenta página del manual en formato DocBook

`-V`

  Versión de este programa

`-prologo`

  Prologo por anteponer al programa. Útil por ejemplo para inicializar variables.

`-chtipo`

  Indica que debe chequearse tipo y el tipo por esperar.

`-chtipo-no`

  Indica que no debe chequearse tipo (por defecto).

`-indenta`

  Indica que debe indentarse e imprimirse.

`-indenta-no`

  Indica que no debe indentarse e imprimirse (por defecto).

`-estado`

  Indica que debe imprimirse estado al final de ejecución.

`-estado-no`

  Indica que no debe imprimirse estado al final de ejecución (por defecto).

`-interp`

  Indica que debe interpretarse y presentar resultado (por defecto).

`-interp-no`

  Indica que no debe interpretarse.

`-regtest`

  Para ejecutar pruebas de regresión y terminar

### Lenguaje `prom`

Algunas características del lenguaje `prom` son:

- Es un lenguaje con tipos, los tipos tienen orden (inclusión), el tipo entero es menor que el tipo flotante (análogo para vector de enteros y flotantes). Los tipo cadena y vector de cadenas no son comparables con otros. Durante el chequeo, en caso de conflicto entre dos tipos comparables se escoge el mayor.

- Las expresiones tienen tipo, el tipo puede ser flotante, entero o cadena. Las variables pueden tener uno de estos tipos o ser vector de uno de estos tipos. En caso de error al evaluar una expresión (como división por cero) el programa termina e informa.

- Todas las variables y vectores son globales, no requieren declaración. El tipo de una variable es el de la primera expresión que se le asigne. Así para declarar una variable flotante `f` que inicie en 1, debe usarse antes de cualquier otra asignación o uso de `f`:

      f=1.0;

  pero si se deseara entera debería inicializarse con:

      f=1;

- Las expresiones emplean una sintaxis similar a la del lenguaje C, aunque sin efectos laterales (i.e la evaluación de una expresión NO modifica el estado). Las palabras reservadas son palabras del español.

- Los vectores se indexan con enteros. El tipo de un vector será el de la primera posición que se inicialice (por ejemplo v[3]=2.0 como primera asignación a una posición de `v` indica que es un vector de flotantes).

- El programa termina normalmente sólo con la instrucción `retornar `expresión``, que hará que intprom evalúe la expresión y presente el valor evaluado.

#### Sintaxis

Un programa en lenguaje `prom` es una secuencia de sentencias. Se ejecuta una después de otra, empezando por la primera. Cada sentencia puede ser:

Ciclo

      mientras (condición) {
              sentencias
      }

  que ejecuta las sentencias mientras la condición sea cierta.

Condicional

      si (condición) {
              sentencias
      }

  que ejecuta las sentencias una vez si la condición es cierta, o bien

      si (condición) {
              sentencias
      }
      sino {
              sentencias
      }

  que ejecuta la primera secuencia de sentencias si la condición es cierta y el segundo si es falsa.

Asignación

                variable=expresión;

  asigna a la variable el resultado de evaluar la expresión. Si es el primer uso de la variable, el tipo de la variable será el tipo de la expresión. Si la variable ya tenía un tipo, el tipo de la expresión debe ser compatible.

Retorno

      retornar expresión;

  que termina normalmente la ejecución retornando el valor al que la expresión evalúe.

Verificación de una aserción

      aserción(condición);

  que evalúa la condición, si es falsa termina anormalmente la ejecución, si es cierta no tiene efecto.

Mensaje de depuración

      mensaje(expresión expresión ...  expresión);

  Evalúa cada una de las expresiones e imprime el valor de cada una por `stderr`. El tipo de cada expresión es arbitrario.

Pueden intercalarse comentarios, comenzando con `/*` y terminando con `*/`.

#### Expresiones

Las expresiones pueden ser:

- Al igual que en Ocaml, las constantes enteras pueden ser decimales como `72` o hexadecimales como `0x52` o octales como `0o21` o binarias como `0b101`. Los enteros son de 32 bits.

- Constantes flotantes decimales como `32E-4`, `.25`, `3f`, `7F`, `0.`

- Cadenas constantes encerradas entre comillas. Puede emplear las secuencias de escape `\"` comillas, `\n` fin de línea, `\t` tabulador y `\\` slash invertido.

- Variables cuyos identificadores no sean palabras reservadas y que comiencen por letra o barra (_) y consten sólo de letras, dígitos y barra. Para referirse a posiciones de un vector se emplea ``variable` [`índice`]`

- Pueden emplearse paréntesis para agrupar expresiones

- Con expresiones enteras y flotantes puede emplearse el operador unário prefijo `-` inverso aditivo.

- Entre expresiones enteras y flotantes pueden usarse los operadores binarios infijos `*` multiplicación, `/` división, `%` residuo, `+` suma, `-` resta. Multiplicación y división tienen más precedencia y asociatividad izquierda. La división entre enteros se considera entera. Si se operan expresiones de distintos tipos, pero comparables, la evaluación se realiza en el tipo mayor. Por ejemplo `3/2` dará el resultado entero `1`, pero `3/2.0` dará el flotante `1.5`

- Entre expresiones tipo cadena puede emplearse el operador binario infijo `+` para concatenar.

- Cómo expresión entera puede emplearse `tamaño(`variable`)`, donde `variable` es el nombre de un vector. Evalúa en la cantidad de elementos asignados al vector (si se trata de un valor retorna 0). Por ejemplo el siguiente programa retorna 2:

      v[-3]=10;
      v[5]=5;
      retorna tamaño(v);

- Las expresiones cadena(u), flotante(u) y entero(u) convierten el valor u a cadena, flotante y entero respectivamente.

#### Condiciones

Las condiciones pueden emplear paréntesis y deben ser:

- Uno de los identificadores reservados `verdadero` o `falso`

- Una de las siguientes relaciones binarias infíjas: `<` menor; `>` mayor; `<=` menor o igual; `>=` mayor o igual; `==` igual; `!=` diferente. Las cuales están definidas para todos los tipos con tipos comparables. Entre cadenas se usa orden lexicográfico.

- Negación de una condición con el operador unario prefijo `!`

- Operación entre dos condiciones mediante un operario binario infijo: `&&` conjunción, `||` disyunción. El primero tiene más precedencia. Ambos evalúan primero la condición izquierda si es falsa `&&` evalúa a falso, si es verdadera `||` evalúa a verdadero.

## Ejemplos

El siguiente programa calcula el máximo divisor común de dos enteros positivos (algoritmo de Euclides). Supone que las variables `y` y `x` tienen los dos enteros. Así si estuviera en un archivo `mcd.prom`, podría usarse por ejemplo: intprom -prologo 'x=150; y=1050;' mcd.prom

    aserción(x>0);
    aserción(y>0);

    r=1;
    mientras (r>0) {
           r=x%y;
           x=y;
           y=y-r;
    }

    mensaje(x " " y " " r "
    ");
    retorna y;

## Historia

Este lenguaje hereda la sintaxis de expresiones de C, las sentencias del lenguaje expuesto en 'Theoretische Informatik', la idea de un análisis de tipos fuerte de Ocaml, más flexibilidad mediante un orden inspirado en OBJ.

## Fallas

Los reconocedores léxico y sintáctico no dan ayuda para determinar la causa de problemas.

Anterior | Subir | Siguiente
repasa | Inicio | edcla