Scripts Qubes 2010

Avec la version Qubes 2010.4 (5.4.25), le langage de script Qubes évolue.

Syntaxe

La syntaxe reste dans le cadre général des langages "Pascal Objet", et introduit des éléments empruntés à Delphi, Prism et FreePascal.

Nouvelles fonctionnalités du langage

Programmation par contrats: les contrats sont désormais supportés.

Chaque méthode ou procedure peut déclarer une section require pour héberger ses pré-conditions, et ensure pour ses post-conditions.
Le mot-clef old est aussi supporter dans les post-conditions.
Pour plus de détails, voir contrats.

Inférence de type: lors d'une déclaration de variable initialisée, il est désormais possible de laisser le compilateur déduire le type

var monEntier = 1234;

var monObjet := TSomeObject.Create;

est équivalent à

var monEntier : Integer = 1234;

var monObjet : TSomeObject := TSomeObject.Create;

Opérateur "in": l'opérateur "in" est désormais disponible, il permet d'utiliser la syntaxe des cas d'un "case of" au sein d'expressions booléennes. La forme not in est aussi supportée.

if (num in [4, 6..8, 10]) then ...

if (str in ['abc', 'def', 'ghi']) then ...

est équivalent à

if (num=4) or ((num>=6) and (num<=8)) or (num=10) then ...

if (str='abc') or (str='def') or (str='ghi') then ...

Directives conditionnelles: les directives de compilation conditionnelle suivantes sont supportées

$DEFINE et $UNDEF définissent des conditionnels.

$IF, $IFDEF, $IFNDEF, $ELSE et $ENDIF définissent des blocs de compilation conditionnelles.

$HINT, $WARNING, $ERROR et $FATAL définissent des messages de compilation utilisateur.

Tableaux initialisables en ligne: le code suivant est désormais supporté

var abc : array [1..3] of String = ['a', 'b', 'c'];

abc := [ 'hello', 'world', '!'];

"step" pour "for to do": les boucles for to do supportent désormais la spécification d'un pas.

for i := 0 to 10 step 2 do ... // 0, 2, 4, 6, 8

for i := 9 downto 1 step 3 do ... // 9, 6, 3

for <iterator> in <enumeration>: introduit une forme simplifiée de la boucle "for" dans le cas du parcours des valeurs d'un type énuméré.

for i in TMonEnumeration do ...

est équivalent à

for i:=Low(TMonEnumeration) to High(TMonEnumeration) do ...

Paramètres tableau ouvert: les tableaux ouverts sont désormais supportés, en tant que "const paramName : array of const".

Le type des éléments est assimilé à Variant, et le nombre d'élément quelconque (utiliser Length(), Low() ou High() pour en connaître le nombre).

Entiers 64 bits: le type Integer est désormais un entier 64 bits.

Les valeurs possible sont donc entre +/- 2⁶³, ie. +/- 9.22x10¹⁸, ou encore plus ou moins 9 milliards de milliards.

Opérateurs "shr" & "shl": les opérateurs de décalage binaire à droite (shr) et à gauche (shl) sont désormais supportés.
Détection de boucles infinies: le compilateur signalera certains cas de boucles infinies (boucles à conditions de rebouclage constante, n'incluant ni break, ni exit).
Détection de variables non utilisées: le compilateur signalera les variables locales ou à visibilité limité non utilisées, ainsi que les fonctions ne spécifiant jamais leur Result.
Evaluation retardée "lazy": un nouveau type de passage de paramètre en évaluation retardée est supporté en sus du passage "var" ou "const".
Dans le mode "lazy", ce n'est ni la valeur ni la référence qui est transmise, mais l'expression elle-même, qui sera évaluée uniquement lors de son utilisation, et autant de fois qu'elle est utilisée.
Opérateur de classe: il est désormais possible de définir des opérateurs de classe, tels que "+=, "-=", "*=" et "/=".
Par exemple "class operator += type uses Add" sur une liste indique que "List.Add(valeur)" et "List += valeur" sont équivalents.

Syntaxes étendues (compatibilité avec d'autres dialectes Pascal Objet)

Opérateur d'initialisation ":=": il est désormais possible d'utiliser soit "=" soit ":=" pour initialiser une variable

Toutes le variantes ci-dessous sont équivalentes

var monEntier = 1234;

var monEntier := 1234;

var monEntier : Integer = 1234;

var monEntier : Integer := 1234;

"Exit" étendu: "exit" accepte désormais une valeur de retour directe, les formes ci-dessous sont équivalentes

Result:=<expression>; Exit;

Exit(<expression>);

Exit <expression>;

Mot clef "method": les méthodes d'un objet peuvent désormais être déclarée en utilisant le mot clef "method", alternativement à "procedure" et "function"

method TMyClass.MyMethodWithNoResult;

method TMyClass.ReturnsAString : String;

Opérateurs d'affectation composites: les opérateurs "+=", "-=", "*=" et "/=" sont désormais supportés pour les variables.
Information de compilation: $I et $INCLUDE peuvent désormais inclure les information de compilation %FILE%, %LINE%, %FUNCTION%, %DATE% et %TIME%.
Opérateur booléen "implies": l'opérateur booléen "implies" est désormais supportés, "a implies b" est équivalent à "(not a) or b", et est donc faux si a est vrai mais b est faux. Cependant si a est faux, b ne sera pas évalué du tout. Il correspond à l'implication au sens logique/mathématique.
Assertions: des assertions peuvent désormais être placées dans le code avec la fonction spéciale Assert.
Exceptions: la classe Exception dispose désormais d'un propriété StackTrace contenant la pile d'appel jusqu'à la ligne ayant généré l'exception.
Classes scellées: les classes peuvent désormais être qualifiées avec "class abstract" ou "class sealed", une classe abstraite devra être sous-classée avant de pouvoir être instanciée (même si aucune de se méthodes ne sont abstraites) et une classe scellée ne pourra être sous-classée.
Visibilités de classes: les directives de visibilité "private", "protected", "public" et "published" sont désormais supportés et contraignants à la compilation. La visibilité par défaut est "published".
Constantes de classe: il est désormais possible de déclarer des constantes au sein d'une classe, leur visibilité est contrôlé par les directives de visibilité, et elles sont accessibles via l'espace de nom de la classe.
Sections "const" et "var" multiples: il est désormais possible des les déclarer locales à une procédure ou méthode, il suffit de les positionner entre le prototype et "begin". Chaque section peut définir plusieurs constantes ou variables, sans répéter le mot-clef "const" ou "var".

Eléments dépréciés

SetCharAt() n'est plus supportée, utilisez directement l'opérateur []
SetCharAt(chaine, pos, char) -> chaine[pos]:=char