El lenguaje de programación Gnome Vala

ARTÍCULO EN DESARROLLO

Si quieres colaborar con nosotros completando este apartado o cualquier otra parte del Curso, puedes informarte en el enlace siguiente.

>[Documentación para desarrolladores]

Introducción

Este documento es un resumen de las características del lenguaje de programación Vala. Diseñado para el sistema GObject de GNOME.

Ficheros fuente

No hay restricciones en la escritura del código fuente. Esto significa que se pueden crear tantas clases como se quieran dentro del mismo fichero. En algunos lenguajes de programación hay que cumplir unas reglas. Por ejemplo: en java, el nombre del fichero con el código fuente se tiene que corresponder con el nombre de la clase que se está definiendo; y los nombres de los directorios se tienen que corresponder con los nombres de los paquetes que se están implementando.

El enfoque quizás sea parecido al que se sigue en el lenguaje de programación C. Donde todas las funciones de una misma librería se agrupan en un fichero objeto. Por este motivo, para crear un paquete, es necesario compilar a un fichero binario pasando al compilador todos los ficheros fuente necesarios. Y posteriormente es posible incluir ese paquete, al compilar otro fichero, indicándoselo al compilador mediante el parámetro "--pkg".

Tipos de datos

Se diferencian tres tipos de datos:

• Tipos por referencia: los valores no son copiados cuando se asigna a un nuevo identificador. Lo que se copia es su referencia. Son tipos por referencia cualquier tipo definido con el modificador class. Independientemente de que descienda, o no, de Glib.Object.

• Tipos por valor: los valores son copiados cuando se asigna a un nuevo identificador. Esto permite operar con cada identificador de forma independiente ya que las modificaciones que se hagan en uno no afectan al otro.

• Constantes. Las constantes se definen utilizando el modificador const delante del tipo. Por convención, los nombres de las constantes deben ser en LETRAS_MAYÚSCULAS separadas por guiones bajos.

A continuación los tipos de datos soportados en el lenguaje.

Tipos por valor

Los siguientes tipos son equivalentes a los soportados por compiladores de lenguaje C. Estos tipos pueden tener tamaños diferentes según la arquitectura del computador en el que se vaya a compilar:

• unichar. Es un character unicode UTF-8. Por ejemplo 'u'.

• char, uchar (unsigned char). Es un byte de C.

• int, uint (unsigned int). Es un int de C. En una arquitectura x86 tiene un tamaño de 4 bytes.

• long, ulong (unsigned long). Es un "long int" de C. El estándar no especifica cuánto más grande que integer debe ser una variable long integer. Sólo dice que no puede ser menor. Por lo tanto puede que incluso tengan el mismo tamaño.

• short, ushort (unsigned short). Es un "short int" de C. Como en el caso anterior no está determinado un tamaño concreto. Sirve para indicarle al compilador que no vamos a usar todo el tamaño definido para int y así, posiblemente, ahorrar memoria.

• float. Es un float de C. Para números de coma flotante. En arquitecturas x86 tiene un tamaño de 4 bytes.

• double. Es un double de C. Para números de coma flotante de precisión doble. En arquitecturas x86 tiene un tamaño de 8 bytes.

En cualquier caso, es posible determinar el tamaño mínimo y máximo de un tipo númerico utilizando los atributos .MIN y .MAX respectivamente: short.MIN.

A continuación los tipos específicos de Vala (y de cualquier lenguaje de alto nivel moderno como Java o C#):

• bool. Tipo booleano cuyos valores pueden ser true o false.

• struct. Para estructuras o también llamados tipos compuestos.

• enum. Para enumeraciones. Representadas por valores enteros (no por clases como ocurre en las enumeraciones de Java).

• string. Para cadenas de texto UTF-8. Al contrario de lo que ocurre en Java, se puede utilizar el operador == para comparar dos tipos string. Esto es debido a que se trata de un tipo por valor.

Cadenas de caracteres (Strings)

Señalar que, además del tipo de dato string mencionado anteriormente, también existen tipos de strings más complejos:

• verbatim strings. Cadenas de texto sin interpretación de secuencias de escape (saltos de línea, tabulaciones, comillas, etc). Para definir un verbatim string hay que introducir la cadena de caracteres dentro de tripes comillas:

  """Hola.\n esto es un ejemplo de "texto bruto".
  Los saltos de línea y tabulaciones no serán interpretados""" 

• string templates. Plantillas de cadenas de texto. En las que se pueden introducir expresiones (variables y operadores) que serán interpretados en tiempo de ejecución. Las expresiones deben ser señaladas con $. Y la cadena completa, la plantilla, con una arroba:

   @"$variable1 * $variable2 = $(a*b)" //"6 * 7 = 42" 

Además, es posible partir una cadena de caracteres utilizando la expresión [inicio:fin]. Donde inicio es la posición (incluyente) del primer caracter (empezando en 0) y fin es la posición (excluyente) del último carácter:

string saludo = "hola mundo";
string s1 = saludo[5:11]; // "mundo"

Se puede acceder a un carácter en concreto, teniendo en cuenta que se está utilizando, de forma predeterminada, la codificación UTF8:

unichar c = saludo[7];

Sin embargo, las cadenas de caracteres en Vala son inmutables. Esto significa que no se puede modificar directamente un carácter individual de una cadena. No son simples Arrays. La cadena tiene que ser procesada internamente ya que en UTF8 cada carácter puede ocupar diferentes cantidades de bytes.

Finalmente, decir que la mayoría de los tipos básicos disponen de métodos de conversión a, y desde, string:

bool b = "false".to_bool();
string s1 = true.to_string();
int i = "-52".to_int();
string s2 = 21.to_string();