Lenguaje Nyota

Este documento contiene la especificación técnica del lenguaje de programación Nyota.

Historia

Aquí se enlistan las correcciones, aclaraciones y cambios que ha sufrido este documento.

2009-06-09: Publicación original de esta especificación.

Elementos Léxicos

En las siguientes secciones, una letra se considera cualquier carácter del alfabeto inglés de la A a la Z mayúscula o minúscula. Un dígito se considera cualquier carácter del 0 al 9. En general los espacios, tabuladores y nuevas líneas sirven como delimitadores entre elementos léxicos, pero fuera de eso son ignorados.

Comentarios

Existen dos tipos de comentarios: de línea y de bloque. Los comentarios de línea comienzan con los caracteres -- y terminan al finalizar la línea. Los comentarios de bloque comienzan con los caracteres (* y terminan con los caracteres *). Los comentarios no se anidan y no pueden estar dentro de literales de cadenas de caracteres.

Identificadores

Un identificador está conformado por un carácter de letra y una secuencia de cero o más letras, dígitos y caracteres de subguión (_). Las letras minúsculas y mayúsculas son consideradas diferentes. Los identificadores pueden tener cualquier longitud.

Enteros

Una literal entera es una secuencia de uno o más dígitos. Estas literales están en base diez en un rango de 0 a 2³¹ - 1.

Reales

Una literal real consta de una parte entera, un punto decimal, una parte fraccionaria y un exponente opcional. Las partes entera y fraccionaria constan de una secuencia de uno o más dígitos. El exponente consiste de una e o E, un signo + o - opcional, y una secuencia de uno o más dígitos. Los números reales se representan internamente usando el formato de 64 bits de números de precisión doble según el estándar IEEE 754.

Cadenas

Una literal de cadena de caracteres es una secuencia de cero o más caracteres delimitados por comillas dobles, por ejemplo: "esta es una cadena". Estas literales no pueden contener caracteres de nueva línea. Las secuencias de caracteres \" (diagonal invertida, comillas dobles) y \\ (diagonal invertida, diagonal invertida) sirven para incluir en una cadena a los caracteres " (comillas dobles) y \ (diagonal invertida), respectivamente.

Booleanos

Las literales booleanas son true y false.

Sintaxis

Los elementos en mono-espacio representan símbolos terminales (tokens).

‹programa›	→	[ `var` ‹declaración_variables›+ ] ‹declaración_procedimiento›* `program` ‹enunciado›* `end` `.`
‹declaración_variables›	→	‹identificador› ( `,` ‹identificador› )* `:` ‹tipo› `;`
‹tipo›	→	`integer` \| `real` \| `string` \| `boolean`
‹declaración_procedimiento›	→	`procedure` ‹identificador› `(` ‹declaración_parámetros› `)` [ `:` ‹tipo› ] `;` [ `var` ‹declaración_variables›+ ] `begin` ‹enunciado›* `end` `;`
‹declaración_parámetros›	→	[ ‹identificador› `:` ‹tipo› ( `,` ‹identificador› `:` ‹tipo› )* ]
‹enunciado›	→	‹enunciado_asignación› \| ‹enunciado_invocación› \| ‹enunciado_if› \| ‹enunciado_loop› \| ‹enunciado_return› \| ‹enunciado_exit›
‹enunciado_asignación›	→	‹identificador› `:=` ‹expresión› `;`
‹enunciado_invocación›	→	‹identificador› `(` [ ‹expresión› ( `,` ‹expresión› )* ] `)` `;`
‹enunciado_if›	→	`if` ‹expresión› `then` ‹enunciado›* ( `elseif` ‹expresión› `then` ‹enunciado›* )* [ `else` ‹enunciado›* ] `end` `;`
‹enunciado_loop›	→	`loop` ‹enunciado›* `end` `;`
‹enunciado_return›	→	`return` [ ‹expresión› ] `;`
‹enunciado_exit›	→	`exit` `;`
‹expresión›	→	‹expresión_lógica›
‹expresión_lógica›	→	‹expresión_lógica› ‹operador_lógico› ‹expresión_relacional› \| ‹expresión_relacional›
‹operador_lógico›	→	`and` \| `andalso` \| `or` \| `orelse` \| `xor`
‹expresión_relacional›	→	‹expresión_relacional› ‹operador_relacional› ‹expresión_aditiva› \| ‹expresión_aditiva›
‹operador_relacional›	→	`=` \| `<>` \| `<` \| `>` \| `<=` \| `>=`
‹expresión_aditiva›	→	‹expresión_aditiva› ‹operador_aditivo› ‹expresión_multiplicativa› \| ‹expresión_multiplicativa›
‹operador_aditivo›	→	`+` \| `-`
‹expresión_multiplicativa›	→	‹expresión_multiplicativa› ‹operador_multiplicativo› ‹expresión_unaria› \| ‹expresión_unaria›
‹operador_multiplicativo›	→	`*` \| `/` \| `div` \| `rem`
‹expresión_unaria›	→	`not` ‹expresión_unaria› \| `-` ‹expresión_unaria› \| ‹expresión_simple›
‹expresión_simple›	→	`(` ‹expresión› `)` \| ‹invocación› \| ‹identificador› \| ‹literal›
‹invocación›	→	‹identificador› `(` [ ‹expresión› ( `,` ‹expresión› )* ] `)`
‹literal›	→	‹literal_entera› \| ‹literal_real› \| ‹literal_cadena› \| ‹literal_booleana›

Semántica

Generalidades

Todo programa escrito en lenguaje Nyota comienza su ejecución a partir del primer enunciado posterior a la palabra clave program.
Una literal entera es de tipo integer. Una literal real es de tipo real. Una literal cadena es de tipo string. Una literal booleana es de tipo boolean.
Toda expresión de tipo integer se convierte a real automáticamente cuando así se requiera en el contexto de su uso. En una operación con dos operandos, si uno de ellos es de tipo real y el otro es integer, éste último se convierte automáticamente en real.
Todas las variables declaradas, ya sean locales o globales, toman un valor inicial por omisión:
- Los integers se inicializan con 0.
- Los reals se inicializan con 0.0.
- Los booleans se inicializan con false.
- Los strings se inicializan con "" (cadena vacía).
Los procedimientos no requieren forzosamente una instrucción return para terminar. En caso de omitirse dicha instrucción, por omisión debe devolverse: nada si el procedimiento no tiene tipo de regreso, 0 si el tipo de regreso es integer, 0.0 si el tipo de regreso es real, una cadena vacía si el tipo de regreso es string, o false si el tipo de regreso es boolean.
El programa termina abruptamente cuando se llega a producir cualquier clase de excepción.

Enunciados

Enunciado	Descripción
var `:=` exp	Asigna a var el resultado de evaluar exp. var debió haber sido declarado previamente y debe ser del mismo tipo que exp.
proc`(` args, ... `)` `;`	Invoca al procedimiento proc, evaluando y enviando args, ... como sus parámetros actuales. proc debió haber sido declarado previamente y no debe tener tipo de regreso. El tipo y número de los parámetros actuales y formales deben corresponder. Los parámetros se pasan por valor. Una llamada puede ser recursiva.
`if` exp₁ `then` enun₁, ... ( `elseif` exp₂ `then` enun₂, ... )* [ `else` enun_n, ...] `end`	Evalúa exp₁ y si resulta `true`, ejecuta los enunciados enun₁, ... . De otra forma evalúa exp₂ y si resulta `true`, ejecuta los enunciados enun₂, ... , y así sucesivamente. Si ninguno de exp₁, exp₂, ... resulta en `true`, ejecuta los enunciados enun_n, ... después del `else`, si es que dicho elemento está presente. Todas las expresiones exp₁, exp₂, ... deben ser de tipo `boolean`.
`loop` enun, ... `end`	Ejecuta repetidas veces los enunciados enun,... . Para terminar el ciclo se debe usar el enunciado `exit`.
`return` [ exp ] `;`	Termina un procedimiento devolviendo el resultado de evaluar exp en caso de estar presente. Si exp no está presente, el procedimiento que contiene este enunciado no debe tener tipo de regreso declarado, o debe ser un enunciado que forma parte de la sección de `program`. En caso de que exp sí esté presente, debe ser del mismo tipo que el tipo de regreso declarado en el procedimiento que contiene este enunciado.
`exit` `;`	Termina el ciclo `loop` más anidado en el que se encuentra este enunciado. Es un error si usa este enunciado fuera de un ciclo.

Operadores

Operador	Nombre	Tipo			Notas
Operador	Nombre	op1	op2	resultado	Notas
op₁ `and` op₂	Conjunción Estricta	`boolean`	`boolean`	`boolean`	Evalúa op₁ y op₂. Si ambos resultan `true`, devuelve `true`. De otra forma devuelve `false`.
op₁ `andalso` op₂	Conjunción Corto Circuito	`boolean`	`boolean`	`boolean`	Evalúa op₁. Si resulta `true`, evalúa y devuelve el resultado de op₂. De otra forma devuelve `false`.
op₁ `or` op₂	Disyunción Estricta	`boolean`	`boolean`	`boolean`	Evalúa op₁ y op₂. Si ambos resultan `false`, devuelve `false`. De otra forma devuelve `true`.
op₁ `orelse` op₂	Disyunción Corto Circuito	`boolean`	`boolean`	`boolean`	Evalúa op₁. Si resulta `false`, evalúa y devuelve el resultado de op₂. De otra forma devuelve `true`.
op₁ `xor` op₂	Disyunción Exclusiva	`boolean`	`boolean`	`boolean`	Evalúa op₁ y op₂. Si ambos resultan con el mismo valor devuelve `false`. De otra forma devuelve `true`.
op₁ `=` op₂	Igualdad Booleana	`boolean`	`boolean`	`boolean`	Devuelve `true` si op₁ y op₂ tienen el mismo valor, `false` en otro caso.
op₁ `=` op₂	Igualdad Numérica	`integer`/ `real`	`integer`/ `real`	`boolean`	Devuelve `true` si op₁ y op₂ tienen el mismo valor, `false` en otro caso.
op₁ `<>` op₂	Desigualdad Booleana	`boolean`	`boolean`	`boolean`	Devuelve `true` si op₁ y op₂ tienen distinto valor, `false` en otro caso.
op₁ `<>` op₂	Desigualdad Numérica	`integer`/ `real`	`integer`/ `real`	`boolean`	Devuelve `true` si op₁ y op₂ tienen distinto valor, `false` en otro caso.
op₁ `<` op₂	Menor	`integer`/ `real`	`integer`/ `real`	`boolean`	Devuelve `true` si op₁ es menor que op₂, `false` en otro caso.
op₁ `>` op₂	Mayor	`integer`/ `real`	`integer`/ `real`	`boolean`	Devuelve `true` si op₁ es mayor que op₂, `false` en otro caso.
op₁ `<=` op₂	Menor o Igual	`integer`/ `real`	`integer`/ `real`	`boolean`	Devuelve `true` si op₁ es menor o igual a op₂, `false` en otro caso.
op₁ `>=` op₂	Mayor o Igual	`integer`/ `real`	`integer`/ `real`	`boolean`	Devuelve `true` si op₁ es mayor o igual a op₂, `false` en otro caso.
op₁ `+` op₂	Suma	`integer`/ `real`	`integer`/ `real`	`integer`/ `real`	Devuelve la suma aritmética de op₁ más op₂. Genera una excepción de desbordamiento si el resultado está fuera de rango.
op₁ `-` op₂	Resta	`integer`/ `real`	`integer`/ `real`	`integer`/ `real`	Devuelve la resta aritmética de op₁ menos op₂. Genera una excepción de desbordamiento si el resultado está fuera de rango.
op₁ `*` op₂	Multiplicación	`integer`/ `real`	`integer`/ `real`	`integer`/ `real`	Devuelve la multiplicación aritmética de op₁ por op₂. Genera una excepción de desbordamiento si el resultado está fuera de rango.
op₁ `/` op₂	División	`integer`/ `real`	`integer`/ `real`	`real`	Devuelve la división aritmética real de op₁ entre op₂.
op₁ `div` op₂	Cociente	`integer`	`integer`	`integer`	Devuelve el cociente aritmético resultante de dividir op₁ entre op₂. Genera una excepción de división entre cero si op₂ es cero.
op₁ `rem` op₂	Residuo	`integer`	`integer`	`integer`	Devuelve el residuo aritmético resultante de dividir op₁ entre op₂. Genera una excepción de división entre cero si op₂ es cero.
`not` op₁	Complemento	`boolean`	N/A	`boolean`	Devuelve `true` si op₁ es `false`, `false` en otro caso.
`-` op₁	Negación	`integer`/ `real`	N/A	`integer`/ `real`	Devuelve la negación aritmética de op₁. Genera una excepción de desbordamiento si el resultado está fuera de rango.
proc`(`...`)`	Invocación	El número y los tipos de los parámetros actuales, así como el tipo de regreso, dependen de la declaración del procedimiento.			Devuelve el resultado de invocar a proc, el cual debe haber sido declarado previamente. El tipo y número de los parámetros actuales y formales deben corresponder. Los parámetros se pasan por valor. Los parámetros y variables locales de la función existen en un espacio de nombres distinto al de los nombres globales. Una llamada puede ser recursiva.

Biblioteca de Tiempo de Ejecución

Los siguientes procedimientos integran la biblioteca estándar del lenguaje Nyota.

Categoría	Firma	Descripción
Entrada y salida	`WrInt( i: integer );`	Escribe en la salida estándar el valor de `i`, sin producir un salto de línea.
	`WrReal( r: real );`	Escribe en la salida estándar el valor de `r`, sin producir un salto de línea.
	`WrStr( s: string );`	Escribe en la salida estándar el valor de `s`, sin producir un salto de línea.
	`WrBool( b: boolean );`	Escribe en la salida estándar el valor de `b`, sin producir un salto de línea.
	`WrLn();`	Escribe en la salida estándar un salto de línea.
	`RdInt(): integer;`	Lee de la entrada estándar un `integer` y devuelve su valor. Se debe ciclar hasta que se lea un valor válido.
	`RdReal(): real;`	Lee de la entrada estándar un `real` y devuelve su valor. Se debe ciclar hasta que se lea un valor válido.
	`RdStr(): string;`	Lee de la entrada estándar un `string` (hasta el final de línea) y devuelve su valor.
Operaciones sobre cadenas de caracteres	`AtStr( s: string, i: integer ): string;`	Devuelve como un `string` el carácter contenido en el índice `i` de la cadena `s`. El primer carácter está en la posición 0. Genera una excepción si `i` resulta ser un índice fuera de rango.
	`LenStr( s: string, ): integer;`	Devuelve el número de caracteres contenidos en la cadena `s`.
	`CmpStr( s1: string, s2: string ): integer;`	Compara los contenidos de dos `string`s. Devuelve cero si `s1` es igual a `s2`, un número negativo si `s1` es menor que `s2`, o un número positivo mayor a cero si `s1` es mayor a `s2`.
	`CatStr( s1: string, s2: string ): string;`	Devuelve un nuevo `string` resultado de concatenar `s1` con `s2`.
Operaciones de Conversión	`IntToReal( i: integer ): real;`	Devuelve el resultado de convertir `i` a un `real`.
	`RealToInt( r: real ): integer;`	Devuelve el resultado de convertir `r` a un `integer`, truncando su parte fraccionaria. El resultado es indefinido si el valor de `r` no puede ser convertido a `integer`.
	`IntToStr( i: integer ): string;`	Devuelve el resultado de convertir `i` a un `string`.
	`StrToInt( s: string ): integer;`	Devuelve el resultado de convertir `s` a un `integer`. Genera una excepción si no se puede realizar la conversión.
	`RealToStr( r: real ): string;`	Devuelve el resultado de convertir `r` a un `string`.
	`StrToReal( s: string ): real;`	Devuelve el resultado de convertir `s` a un `real`. Genera una excepción si no se puede realizar la conversión.

Traductores