Un langage de programmation interprété en français, avec des fichiers .elg.
Interpréteur écrit en C pur (c/, aucune dépendance externe), avec des
points chauds en assembleur x86-64 inline pour l'arithmétique entière.
Ce README est pour les développeurs. Pour un guide simple destiné aux
utilisateurs de l'éditeur/interpréteur installé, voir
GUIDE_UTILISATEUR.md. Historique des versions :
CHANGELOG.md.
Pas de point-virgule, pas de virgule, pas d'accolade : les blocs sont
délimités par indentation (comme en Python), après un :.
cd c
make linux # easylang, easy_debogueur (pour developper/tester ici)
make windows # + easy_editeur.exe, via cross-compilation mingw-w64
Voir packaging/README.md pour la CI et le detail
de la cross-compilation.
cd c
make tests
Suite de tests maison (c/tests/, aucune dependance externe) : pilote le
binaire easylang/easy_debogueur compile comme boite noire (le
plus simple pour couvrir aussi les cas d'erreur, qui font exit(1)).
192 verifications : variables, boucles, fonctions, fermetures, listes,
erreurs, entree standard, debogueur, bibliotheque standard
(math/os/reseau/gui/texte/temps, y compris un aller-retour TCP reel
contre un serveur d'echo lance par le test lui-meme).
c/easylang exemples/bonjour.elg
c/easylang --version
c/easylang --aide # usage, ou lancé sans argument
c/easylang --aide modules # modules de la bibliotheque standard disponibles
c/easy_debogueur programme.elg [lignes_arret...] # debogueur en ligne de commande
Commandes du debogueur : n (suivant), c (continuer), ba <ligne> /
br <ligne> (ajouter/retirer un point d'arret), v (variables),
p <nom> (une variable), q (quitter).
L'éditeur graphique (c/easy_editeur.exe) est écrit en Win32 C pur
(RichEdit pour la coloration syntaxique, CreateProcess/pipes pour
lancer easylang.exe/easy_debogueur.exe) : F5 = lancer, F6 =
déboguer, Ctrl+F = rechercher, Ctrl+N = nouvel onglet, Ctrl+W = fermer
l'onglet. Une seule barre en haut (le menu ; l'ancienne barre d'outils a
été retirée, ses actions restent accessibles par le menu et les
raccourcis) et une barre d'état en bas (état de l'exécution en cours,
ligne/colonne du curseur) encadrent trois zones :
- Numéros de ligne à gauche de l'éditeur (retour à la ligne automatique désactivé pour qu'une ligne logique reste une ligne visuelle, condition pour que les numéros restent alignés).
- Plusieurs fichiers ouverts en onglets (jusqu'à 20) : Nouveau/Ouvrir
ajoutent un onglet plutôt que de remplacer le fichier en cours ; ouvrir
un fichier déjà ouvert bascule sur son onglet au lieu d'en dupliquer
un ; un
*dans le titre de l'onglet signale des modifications non enregistrées, avec confirmation à la fermeture (Ctrl+W). - Arborescence dans une barre latérale, ouverte par défaut sur le
dossier de l'exécutable (donc toujours peuplée, contrairement au
dossier courant d'une appli GUI lancée par raccourci, imprévisible) ;
bascule sur le dossier du fichier ouvert dès qu'on en ouvre un.
[dossier]pour naviguer,fichier.elgpour l'ouvrir directement.
Menu Fichier > Fichiers récents (jusqu'à 8, persistés par utilisateur dans le registre Windows, HKCU) pour rouvrir rapidement un script. Il vérifie automatiquement (via l'API GitHub Releases, en tâche de fond, au démarrage) si une nouvelle version est disponible, et propose d'ouvrir la page de téléchargement le cas échéant (menu Aide > Vérifier les mises à jour pour relancer la vérification manuellement) ; aucun téléchargement ni exécution automatique, l'utilisateur choisit toujours.
Journal (logs). L'éditeur n'a pas de console visible : les erreurs
(échec d'ouverture/enregistrement, échec de lancement) et un
gestionnaire de plantage (exceptions non gérées, code + adresse) sont
consignés, horodatés, dans %APPDATA%\EasyLanguage\editeur.log,
accessible depuis Aide > Voir le journal. Utile pour diagnostiquer un
problème à distance sans accès à la machine.
Il ne se compile que pour Windows et doit rester dans le même dossier
que les deux autres .exe.
Les trois .exe embarquent le logo du langage (packaging/icone.ico,
compilé via c/ressources.rc). Le script packaging/associer_fichiers.ps1
(ou son wrapper .bat, à double-cliquer) associe l'extension .elg à ce
logo et à l'éditeur pour l'utilisateur courant, sans droit administrateur.
site/index.html est le site de presentation + telechargement (liens
vers github.com/abiyeenzo/easy-language). Voir
.github/workflows/pages.yml pour le publier automatiquement via GitHub
Pages une fois le depot pousse.
soit x = 5
soit nom = "Alice"
x = x + 1 # réaffectation (sans 'soit')
affiche "Bonjour" nom "tu as" age "ans"
demande(age, "Ton age : ")
demande convertit automatiquement en nombre si possible, sinon garde du texte.
La forme sans parentheses (demande age "Ton age : ") reste acceptee.
si age >= 18 alors:
affiche "majeur"
sinon si age >= 13 alors:
affiche "ado"
sinon:
affiche "enfant"
tantque i <= 5 alors:
affiche i
i = i + 1
pour i de 1 jusqua 10 alors:
affiche i
pour i de 10 jusqua 0 pas -2 alors:
affiche i
arrete sort de la boucle, continue passe au tour suivant.
fonction carre(x):
retourne x * x
affiche carre(5)
Les arguments multiples sont séparés par des espaces, pas des virgules :
addition(1 2 3).
Pas de virgule : les éléments sont séparés par des espaces, entre crochets.
soit fruits = ["pomme", "banane", "cerise"]
affiche fruits[0]
fruits[1] = "mangue"
ajoute(fruits "kiwi")
soit x = retire(fruits 0) # retire et retourne l'element a cet index
affiche contient(fruits "kiwi")
pour chaque fruit dans fruits alors:
affiche fruit
soit matrice = [[1, 2], [3, 4]]
affiche matrice[1][0]
Une liste littérale ne peut pas être indexée directement ([1 2][0] est
invalide, à cause de l'ambiguïté avec une liste de listes adjacente sans
virgule) : passez par une variable d'abord.
- Nombres :
5,3.14 - Texte :
"bonjour" - Booléens :
vrai,faux - Rien :
rien - Listes :
[1, 2, 3](la virgule est optionnelle :[1 2 3]marche aussi) - Arithmétique :
+ - * / %(le+concatène aussi textes et listes) - Comparaison :
== != < > <= >= - Logique :
et,ou,non - Fonctions natives :
longueur(x),nombre(x),entier(x),texte(x),ajoute(liste valeur),retire(liste index),contient(liste valeur)
Chaque fichier .elg peut être importé comme module, avec ses fonctions
et variables accessibles via module.nom. Le chemin est relatif au
fichier qui importe (les imports imbriqués fonctionnent).
importe "modules/mathutils.elg" comme math
affiche math.PI
affiche math.carre(5)
Sans comme alias, le nom du module est déduit du nom de fichier
("mathutils.elg" → mathutils). Un module n'est chargé qu'une seule
fois même s'il est importé plusieurs fois (mis en cache par chemin), et
un import circulaire est détecté et signalé comme erreur plutôt que de
boucler indéfiniment.
Le dossier bibliotheque/ contient un petit équivalent
des modules math, os et socket de Python (plus des boîtes de
dialogue simples), sous forme de fichiers .elg important les fonctions
natives correspondantes (implémentées en C dans c/natifs_*.c).
Ces modules-là s'importent sans chemin, par leur simple nom (comme
import math en Python) :
importe math
importe os
importe reseau
importe gui
importe texte
importe temps
affiche math.racine(2)
affiche os.fichier_existe("notes.txt")
soit s = reseau.connecter("example.com" 80)
gui.message("Titre" "Un message")
affiche texte.majuscules("bonjour")
affiche temps.formater(temps.maintenant() "%Y-%m-%d")
importe <nom> (identifiant nu, sans guillemets) est résolu contre le
dossier bibliotheque/ fourni à côté de l'exécutable, quel que soit le
dossier depuis lequel le script est lancé (contrairement à importe "chemin.elg", résolu relativement au script). Un alias reste possible
(importe math comme m). Importer un nom qui n'existe pas dans la
bibliothèque standard donne une erreur claire listant les modules
disponibles ; la liste est aussi accessible via easylang --aide modules (voir Utilisation).
Ce mécanisme est réservé aux six modules ci-dessous. Pour importer votre
propre fichier .elg (les vôtres, ou ceux de quelqu'un d'autre), la
syntaxe historique par chemin continue de fonctionner exactement comme
avant (voir Modules plus haut) : importe "chemin.elg".
math:racine,puissance,sin,cos,tan,abs,plancher,plafond,arrondi,log,exp,alea,alea_entier,min,max, constantesPIetE.os:fichier_existe,lire_fichier,ecrire_fichier,ajouter_fichier,supprimer_fichier,repertoire_courant,variable_environnement,horodatage,dormir.lire_fichiersur un fichier absent retournerien(pas une erreur : c'est un cas normal pour ce type d'opération, à la différence des erreurs de programme qui arrêtent le script).reseau: client TCP basique (connecter,envoyer,recevoir,fermer). Pas de serveur, pas de HTTP/TLS : juste un socket brut.gui: deux niveaux.message(titre texte)/question(titre texte)sont de simples boîtes de dialogue (vraie boîte Win32MessageBoxWsous Windows, repli console ailleurs pour rester exécutable et testable partout).creer(titre largeur hauteur),bouton,etiquette,champ_texte,lire_champ,definir_champ,sur_clic(bouton fonction)etexecuter()créent de vraies fenêtres Win32 avec de vrais composants et de vrais événements (un clic sur un bouton peut rappeler directement une fonction Easy Language) ; disponible uniquement sous Windows (.exe), erreur claire ailleurs. Exemple complet dansbibliotheque/gui.elg.texte:decouper(split),joindre(join),remplacer,majuscules,minuscules,rogner(trim),commence_par,finit_par,sous_texte(substring, indices bornés sans erreur),inverse,position(index ou-1),contient_texte.temps:maintenant(horodatage courant),annee,mois,jour,heure,minute,seconde,jour_semaine(0 = dimanche),formater(horodatage motif)avec les codesstrftimestandards (%Y-%m-%d %H:%M:%S, etc.). Toutes ces fonctions décomposent un horodatage (le même type queos.horodatage()) dans le fuseau horaire local de la machine.
Ces fonctions natives sont aussi appelables directement sans import
(affiche racine(4)), le module ne fait qu'ajouter un espace de noms.
# ceci est un commentaire
- L'éditeur graphique (Win32) n'a pas pu être testé visuellement dans cet environnement de developpement (pas de Windows/Wine disponible) ; sa compilation croisee reussit sans erreur, mais un test manuel sur une vraie machine Windows est recommande.
Deux anciennes limitations de cette section ont ete corrigees :
- Fermetures (closures). Une fonction definie a l'interieur d'un bloc
(
si/boucle/appel de fonction) peut maintenant etre retournee ou stockee ailleurs et rester appelable, en gardant ses variables capturees, meme apres la fin de ce bloc :Techniquement : chaquefonction creer_compteur(): soit n = 0 fonction incrementer(): n = n + 1 retourne n retourne incrementer soit compte = creer_compteur() affiche compte() # 1 affiche compte() # 2Environnementcompte ses references (une par portee enfant, plus une par fonction qui l'a capture) et n'est recycle que lorsqu'il n'est plus reference nulle part, au lieu d'etre detruit inconditionnellement a la fin du bloc. Cout mesure : ~15-20% plus lent sur de la recursion tres intensive (fib(30)) ; negligeable ailleurs. - Ambiguite
3 -4. Un-precede d'une espace mais colle a l'operande suivant (aucune espace apres) marque desormais le debut d'un nouvel argument plutot qu'une continuation de l'expression courante (meme principe que Ruby pour le meme probleme) :affiche 3 -4affiche maintenant deux arguments (3 -4), alors queaffiche 3 - 4etaffiche 3-4(espaces des deux cotes, ou aucune) restent des soustractions (-1), inchangees. - Ambiguite
f(x [1 2]). Meme famille de probleme que3 -4, mais pour[: sans virgule dans les arguments,f(x [1 2])etait lu comme l'indexationx[1 2]plutot que deux arguments distincts (x, puis le litteral de liste[1 2]). Un[colle a ce qui le precede (aucune espace avant, comme toujours pour indexer :fruits[0]) reste de l'indexation ; un[precede d'une espace marque desormais le debut d'un nouvel argument.
Ces additions (et les precedentes) sont exercees ensemble dans
exemples/nouveautes_demo.elg, un
script qui verifie chaque fonctionnalite et affiche un bilan.
Face a notre propre tout premier prototype (le tres original
interpreteur ecrit en Python, avant la reecriture complete en C) : sur
fib(30) recursif, ~30x plus rapide en temps reel (2min26s -> 4.9s),
jusqu'a ~38x en temps CPU pur. Le gain vient surtout de la compilation
native (pas d'interpretation bytecode, pas de typage dynamique par objet
Python) ; les quelques routines en assembleur inline sur l'arithmetique
entiere (+ - * -unaire) ne font que documenter une integration ASM
reelle sur le chemin le plus emprunte, un -O2 C fait deja aussi bien
sur des operations aussi simples.
Face a du vrai CPython (3.13), sur fib(30) recursif (mesures sur
cette machine de developpement, a prendre comme un ordre de grandeur) :
| Version | fib(30) | Boucle simple (20M iterations) |
|---|---|---|
| Avant optimisation | ~1.0-1.2s | ~2.5s |
| Apres reutilisation des environnements | ~0.7s | ~1.8s |
| Apres cache de resolution (appels + variables) | ~0.22s | ~1.5s |
| CPython 3.13 (reference) | ~0.09s | ~1.4s |
Sur la boucle simple, on est desormais dans le bruit de mesure par
rapport a CPython. Sur fib(30), l'ecart est tombe d'environ 8-10x a
environ 2.5x. Honnetement : toujours plus lent que du vrai CPython sur
de la recursion intensive, mais l'ecart s'est nettement resserre, sans
rien casser (158 tests toujours au vert a chaque etape).
Deux optimisations ont fait le gros du travail :
- Reutilisation des environnements. Chaque appel de fonction ou
entree de bloc (
si, boucle) allouait et liberait un nouvel environnement (jusqu'a 4malloc/freepar appel), un cout qui dominait le temps d'execution sur du code recursif (visible en temps systeme). Les environnements sont maintenant recycles via une pile de reutilisation, et les noms de variables ne sont plus dupliques (ils vivent deja aussi longtemps que le programme, dans l'arbre syntaxique). - Cache de resolution sur les noeuds de l'arbre syntaxique. Chaque
appel de fonction verifiait d'abord si le nom appelait une fonction
native, en parcourant sequentiellement toutes les tables de fonctions
natives (jusqu'a une soixantaine de comparaisons de chaines) avant de
chercher une fonction utilisateur : sur une fonction recursive comme
fib, ce parcours se repetait des millions de fois pour le meme site d'appel, en pure perte. De meme, chaque acces a une variable remontait la chaine des portees parentes avec une comparaison de chaines a chaque niveau. Comme ces deux resolutions ne dependent que du code (jamais de l'etat d'execution), leur resultat est maintenant mis en cache directement sur le noeud d'AST concerne des la premiere execution, et reutilise ensuite sans reparcourir quoi que ce soit. Le cache est invalide-safe : toute incoherence retombe automatiquement sur la recherche complete plutot que de retourner un mauvais resultat.
La prochaine vraie piste pour aller plus loin serait de resoudre les variables a des emplacements fixes au moment du parsing plutot qu'a la premiere execution, ou de passer a un modele par bytecode plutot que tree-walking : un chantier plus consequent que les deux ci-dessus.
Aucune dépendance à installer sur la machine cible : les trois .exe
(easylang.exe, easy_debogueur.exe, easy_editeur.exe) ne
dépendent que de DLL systeme presentes par defaut sur Windows
(kernel32, msvcrt, user32, gdi32, comdlg32, comctl32 pour la
barre d'outils/d'état de l'éditeur, ws2_32 pour le reseau). Voir
packaging/README.md pour la compilation, et
packaging/installateur.iss pour
l'installateur (menu Demarrer, association .elg, ajout au PATH).
Tous droits reserves © 2026 Abiye Enzo / AE Corporation. Voir
LICENSE.