Lazi

translate

Présentation

"translate" est un programme ayant pour fonction la traduction entre les différents formats de fichiers de code sources Lazi. Il prend en entrée un ou des fichiers et retourne le résultat sous forme d'un fichier.
En général il est utilisé pour fournir les fichiers nécessaire à compute à partir de fichiers sources, puis pour traduire le résultat retourné par compute.

Deux formats

translate distingue deux formats pour la traduction :

  • celui du conteneur : syntaxe de déclaration d'une définition, éventuellement d'une notation, sans les formules elles-même
  • celui des formules

Les formats conteneur

sources

Fichier sources Lazi.
Disponible seulement en lecture.

XMLDefs

Fichier XML contenant les définitions.
Disponible seulement en écriture.

XMLFormulas

Fichier XML quelconque où les tags <formula> sont traduits et le reste intouché.

Les formats des formules

sources

C'est le format normal du code source Lazi.
Disponible seulement en lecture.

xml

Les formules sont exprimées en xml (par exemple le tag "<apply>" pour l'application).
Disponible en lecture et écriture.

computeFm

C'est un format à la syntaxe très simple et reproduisant la grammaire minimale des formules interprétées par compute.
Disponible en lecture et écriture.

lazi0a

C'est la grammaire de lazi.0.0 (pas de fonction, juste les mots clés et l'application).
Disponible en écriture.

lazi0aDepth

Ce n'est pas une syntaxe de formule mais juste l'écriture de la profondeur de la formule lazi.0.0. On peut donc par une sortie à ce format connaître la profondeur de la formule lazi.0.0 correspondante.
Disponible en écriture.

Cœur de la traduction

Le cœur de la traduction est la traduction de formule Lazi dans les différents langages. Actuellement il existe deux langages pour le logiciel:

  • xml Le langage Lazi utilisé par compute et utilisant une syntaxe XML
  • sources Les expressions Lazi telles que rencontrées dans le code source.

Les différentes traductions possibles

Remarquons que les fichiers sources contiennent des définitions d'opérateurs, ce qui change la syntaxe des sources. Il est donc souvent nécessaire d'indiquer à lazi-translate les fichiers sources à inclure.

lazi-translate a deux modes de traduction :

Traduction d'un fichier XML

Dans ce mode le logiciel prend en entrée un fichier XML pouvant contenir des tags .... Il traduit ces formules d'un format (xml,sources ou sourcesNoOp) à l'autre. Le format "sourcesNoOp" est comme le format "sources" mais l'expression n'est pas simplifié (cela sert par exemple quand on veut vérifier le résultat d'une commande, car il ne faut pas simplifier le résultat attendu).

Production d'un fichier XML de définitions

Ce fichier contient la liste des définitions, il est au format XML (les formules aussi).

Options de la ligne de commande

  • -i FILE ... -i FILE Fichiers sources à inclure, ce sont les fichiers de définitions de noms ou d'opérateurs qui seroit soit :
    • lus , concaténés et traduit en fichiers de définitions (options -a et -a1)
    • lus pour obtenir les définitions nécéssaires à la lecture d'un autre fichier (option -x)
  • -a Génère le fichier des définitions au format XMLDefs/XML à partir de tous les sources lus (voir -i et -o). L'option -f et -x n'ont alors pas d'effet.
  • -a1 name : comme -a (et exclusif avec -a), la sortie est pour lazi1: une variable définie (name) avec une valeur contenant toutes les sources.
  • -x FILE Traduit un fichier XML "FILE", si l'option est absente alors STDIN est utilisée.
  • -o FILE Chemin du fichier de sortie, si l'option est absente alors STDOUT est utilisée.
  • -f FORMAT Pour l'option -x : spécifie le format des formules en sortie. Peut être xml, sources, computeFm
, lazi0a ou lazi0aDepth.
  • -s Optimise le code produit après la traduction provenant du format "sources". Cela peut être utile (car les notations peuvent engendrer du bavardage) pour passer le résultat à compute, mais nuisible si le but est une lecture humaine car alors des notations peuvent ne plus être reconnues.
  • -h --help Affiche l'aide et stoppe.
  • -v Afficher le numéro de version et stoppe.

Les modules internes

Représentation interne des formules

Ces modules définissent une représentation interne des formules ainsi que la traduction dans d'autres représentations. Les deux représentations sont :

ComputeFm

Cette représentation est le plus proche possible du langage Lazi utilisé par compute : Lazi-0 plus les noms définis et les fonctions avec var-places.

Le module ComputeFm.Definitions représente une liste de noms définis. Il fournit aussi des fonctions de vérification (par exemple pour pouvoir vérifier que les noms utilisés dans les formules sont définis).

SourcesFm

Cette représentation est le plus proche possible des formules du code sources. Par exemple elle inclue une représentation de la notation $Let ou encore des dictionnaires.

Le sous-module VarExp représente les expressions de variables. Ces expressions sont un véritable sous-langage et ont donc leur propre représentations.

Traduction de ComputeFm vers SourcesFm

Cette traduction doit reconnaître les formules simples de ComputeFm correspondant à des notations (comme $Let ou encore les varExp).

Traduction de SourcesFm vers ComputeFm

En plus de traduire les notations, des modifications peuvent être effectuées pour optimiser le code (voir l'option "-s"), cela permet au développeur de se concentrer sur la clarté du code. Les modules ComputeFm.BasicCompute et ComputeFm.Factorize définissent ces modifications :

  • Factorisation : Si dans une formule une sous-expression est utilisée plusieurs fois alors elle est factorisée, par exemple f (g . x y , h . x y) devient ($F a -> f (g a, h a)) . x y (x y est factorisé). Cela permet le partage des calculs dans lazi-compute.
  • "$F x -> y x" ==> "y" (où x n'apparait pas dans y)
  • si body utilise 'x' zero fois : "($F x -> body) y" ==> "body"
  • si body utilise 'x' une fois et s'il n'y a pas de collision de variable : "($F x -> body) y" ==> "body2" avec body2 = body où x est remplacé par y.
  • Si body n'utilise pas f : "recurse $F f -> body" ==> body
  • $Let $T[v1,...,vn] = $T[a1,...,an], body ==> $Let v1=a1, $Let ..., $Let vn=an, body (ce qui, avec les autres optimisations, amène au remplacement dans body de vk par ak s'il n'y apparaît qu'une fois.

Parsing et Rendering des formules

format xml

Parsec est utilisé pour le parsing.

format sources

Le parsing utilise Parsec, des données (comme les opérateurs définis ou les noms définis) sont stockées dans le "user-state".

Le module ItemsInfos s'occupe de la représentation des opérateurs.

La gestion des parenthèses et des priorités des opérateurs est faite par le module Opparenth.

Rendering

Le module PrintText gère le formatage des sources (quand retourner à la ligne, ajouter ou non des espaces autour des virgules, l'indentation etc). Pour l'utiliser on définit des structures PrintText puis on lui demande de les convertir en texte. C'est une espèce de mini HTML spécialisé pour le rendu du code source.

Gestion des fichiers

Le module LaziTranslate.FormulaXML permet de produire un fichier XML des définitions et aussi de traduire les formules d'un fichier XML.

Le module LaziTranslate.Sources permet de récupérer la liste des définitions de noms ou la liste des définitions d'opérateurs à partir d'une représentation du contenu des sources.

Testes

@todo (relire et finir "testes")