XL (langage)

XL est défini en quatre niveaux différents :

• XL0 définit comment le texte entré est converti en un arbre syntaxique
• XL1 définit un langage de base avec des possibilités comparables au c++
• XL2 définit la bibliothèque standard qui inclut les types de données communs ainsi que les opérateurs
• XLR définit un Moteur d'exécution dynamique pour XL basé sur XL0

XL n'a ni type primitif ni mot-clé. Tous les opérateurs et les types de données, tels que les entiers ou les additions, sont définis dans la bibliothèque standard XL2. XL1 est portable dans différents environnements d'exécution. Ce qui n'est pas garanti pour XL2 qui n'offre pas de tels garanties : si un processeur particulier n'implémente pas la multiplication en virgule flottante, la définition de l'opérateur correspondant peut être manquante de la bibliothèque standard, et l'utilisation de cette fonctionnalité peut générer une erreur de compilation.

En XL, le programme Hello World peut s'écrire ainsi :

 use XL.TEXT_IO
 WriteLn "Hello World"

Une manière plus convenable pour des programmes plus importants serait :

 import IO = XL.TEXT_IO
 IO.WriteLn "Hello World"

Une implémentation par récurrence de la fonction factorielle :

 0! → 1
 N! → N * (N-1)!

La syntaxe est définie au niveau XL0. La phase XL0 du compilateur peut être configurée en utilisant un fichier de description de la syntaxe, où sont définies des propriétés telles que la représentation du texte et les priorités des opérateurs. Un fichier de syntaxe basique définit les notations mathématiques communes tel que + pour l'addition, ainsi que la priorité des opérations.

L'arbre syntaxique est composé de 7 types de nœuds : 4 types de feuilles (entier, réel, texte et symbole) et 3 types de nœuds internes (infixe, préfixe et bloc).

• un nœud entier est la représentation littérale d'un entier, comme 2. Le signe # peut indiquer une base différente de 10, par exemple (2#1001). Un caractère souligné (ou underscore) comme séparateur peut aider la lecture, par exemple 1_000_000.
• un nœud réel représente un nombre non entier, comme 2.5. Les notations de base et les séparateurs peuvent être utilisés de la même façon pour les entiers, par exemple 16#F.FFF#E-10 est une représentation littérale valide d'un réel.
• un nœud texte représente un contenu textuel. Il est classiquement entouré par un guillemet simple ou double, comme "Salut" ou 'a', mais le fichier syntaxique peut être utilisé pour ajouter d'autres séparateurs, dont ceux dédiés aux textes à lignes multiples.
• un nœud symbole représente un nom ou un opérateur. Un nom est une séquence de caractères alpha-numériques commençant par une lettre, par exemple Salut. XL0 préserve la casse, mais XL1 ignore la casse et le caractère souligné ce qui fait que MonsieurDupont et Monsieur_Dupont sont le même nom. Un symbole est une séquence de caractères non alpha-numériques, par exemple * ou =/=.
• un nœud infixe représente deux nœuds liés par une notation infixée, par exemple A+1 ou 2 and 3. En particulier, un nœud infixe combiné à un infixe "nouvelle-ligne" permet de séparer deux lignes.
• un nœud préfixe représente deux nœuds consécutifs, par exemple Write "Salut". Ceci est aussi utilisé dans la notation postfixe, par exemple 3! ou Open?.
• un nœud bloc représente un nœud entouré par des symboles isolants, par exemple (A) ou [Index]. Une indentation est représentée en interne par un nœud bloc.

Avec le fichier de syntaxe par défaut, le code suivant est valide pour XL0, indépendamment de la sémantique :

A = B + "Salut"

Il est décomposé en :

infix("=",
      symbol("A"),
      infix("+",
            symbol("B"), text("Salut")))

Le niveau XL1 est défini comme une séquence d'opérations sur l'arbre syntaxique du niveau XL0. Ces opérations sont effectuées par divers plugins du compilateur qui sont appelés suivant la forme de l'arbre syntaxique.

Des constructions particulières, translate et translation, sont fournies par un plugin destiné à faciliter l'écriture d'autres plugins. La construction quote génère un arbre syntaxique. Voici comment ces constructions peuvent être utilisées pour implémenter un plugin nommé ZeroRemoval, qui supprime les additions et multiplications par zéro :

translation ZeroRemoval
  when
    'X' + 0
  then
    return X
  when
    'X' * 0
  then
    return parse_tree(0)

Un plugin peut être invoqué sur un fichier complet à partir de la ligne de commande, ou plus localement dans le source du code en utilisant la notation pragma, comme ici :

X := {Differentiate} d(sin(omega * T) * exp(-T/T0)) / dT

Le niveau XL1 contient un grand ensemble de plugins, notamment XLSemantics qui donne les abstractions communes telles que fonction, type de données et déclaration de variable et définition, et aussi les ordres de base de la programmation structurée que sont les boucles et les conditions.

generic [Item : type; Size : integer] type array

// Un type est ordonné en présence d'un opérateur inférieur
generic type ordered if
  A, B : ordered
  Test : boolean := A < B

// Function générique pour au moins un élément
function Min(X : ordered) return ordered is
  return X

function Sum(A : array) return array.Item is
  for I in 0..array.Size-1 loop
    result += A[I]

// Fonction générique pour le minimum de N éléments
function Min(X : ordered;…) return ordered is
  result := Min(…)
  if X < result then
    result := X

// Exemple d'utilisation de la fonction Min précédente
X : real := Min(1.3, 2.56, 7.21)
Y : integer := Min(1, 3, 6, 7, 1, 2)

function Add(X, Y: integer) return integer written X+Y

function Linear(A, B, C : matrix) return matrix written A+B*C

function Equal(A, B : matrix) return boolean written A=B
function IsNull(A : matrix) return boolean written A=0
function IsUnity(A : matrix) return boolean written A=1

import IO = XL.UI.CONSOLE
iterator IntegerIterator (var out Counter : integer; Low, High : integer) written Counter in Low..High is
    Counter := Low
    while Counter <= High loop
        yield
        Counter += 1
// I doit être déclaré, car indiqué comme 'var out' dans l'itérateur
// Une déclaration implicite de I comme entier est alors faite ici
for I in 1..5 loop
   IO.WriteLn "I=", I

XLR est un langage dynamique, conçu dès l'origine comme un exécutant (back-end) pour le compilateur XL1 (d'où le nom, qui représente le runtime de XL). Il partage la syntaxe de base XL0 avec XL1, mais son comportement est plus proche de celui d'un langage fonctionnel, même si XL1 est censé ressembler plus à un langage impératif. XLR n'a pratiquement qu'un seul opérateur de construction, "→", qui indique une réécriture. La notation à gauche de la notation de la réécriture est transformée en notation à droite de la réécriture.

Ce mécanisme est utilisé pour implémenter les notations standards :

 si vrai alors PartieVraie sinon PartieFausse → PartieVraie
 si faux alors PartieVraie sinon PartieFausse → PartieFausse

Le design de XL a commencé aux alentours de 1992, sous le nom LX (Langage eXpérimental). Le projet a été mis dans le domaine du logiciel libre en 2000, dans le cadre du projet « Mozart » qui visait à fournir des capacités de métaprogrammation multi-langage. Les premiers compilateurs étaient écrits en C++, mais cela rendait l'écriture d'extensions de compilateurs compliquée, car C++ ne permettait pas d'offrir le niveau d'abstraction voulu (par exemple un équivalent de translate). Les aspects multi-langage rendaient les arbres syntaxiques difficile à manipuler en respectant la sémantique de chaque langage.

Une réécriture complète du compilateur a commencé en 2003, abandonnant l'idée de support multi-langage qui avait montré ses limites, et focalisant sur la facilité d'écriture des extensions. L'arbre syntaxique abstrait a été réduit à sept types de nœud seulement pour représenter tous les programmes. Ce nouveau compilateur s'est auto-compilé en 2004 (bien qu'avec des capacités réduites et une dépendance à C++ dans le code généré). Depuis, tout le développement se fait en XL.

En 2007, le langage offre un grand nombre de fonctionnalités avancées, mais manque encore d'une bibliothèque fonctionnelle.

• Site SourceForge
• Version historique multi-langage
• Article Byte