Algo Compiler - Extension VS Code

Extension Visual Studio Code pour Algo-Compiler - Écrivez, éditez et exécutez des programmes en pseudocode algorithmique français avec 40 fonctions intégrées !

📥 Installation Rapide

1. Télécharger le Compilateur

🔗 algo-compiler-1.6.0.jar ← Cliquez pour télécharger

📍 Placer le fichier à : c:\algo-compiler-1.6.0.jar

2. Installer Java 21+

☕ Java 21+ ← Télécharger si nécessaire

3. Installer cette Extension

📦 Dans VS Code : Extensions → Rechercher "Algo Compiler" → Installer

C'est tout ! L'extension détectera automatiquement le compilateur.

🌐 Site web : https://oughzal.github.io/Algo-compiler/

🎉 Nouveautés Version 1.8.0

🔄 Passage par Référence

Modifiez les variables directement avec le mot-clé ref :

procedure echanger(ref a : entier, ref b : entier)
variables
    temp : entier
debut
    temp = a
    a = b
    b = temp
fin

variables
    x, y : entier
debut
    x = 10
    y = 20
    echanger(x, y)  // x = 20, y = 10
fin

🌍 Variables Globales

Les fonctions/procédures peuvent accéder et modifier les variables de l'algorithme principal :

variables
    compteur : entier

procedure incrementer()
debut
    compteur = compteur + 1  // Modifie la variable globale
fin

debut
    compteur = 0
    incrementer()  // compteur = 1
fin

✅ Expressions avec Fonctions

Écrivez des expressions naturelles commençant par des fonctions :

resultat = racine(16) + abs(-5)     // 9
valeur = puissance(2, 3) * abs(-2)  // 16

📊 Matrices (Tableaux 2D)

Créez et manipulez des tableaux à deux dimensions :

variables
    M : tableau[3][3] de entier
    i, j : entier

debut
    pour i de 0 à 2 faire
        pour j de 0 à 2 faire
            M[i][j] = (i + 1) * 10 + (j + 1)
        finpour
    finpour
fin

⚡ Opérateur Puissance ^

Deux syntaxes pour la puissance :

resultat = 2 ^ 3   // 8
aire = rayon ^ 2
volume = cote ** 3  // ** fonctionne toujours

✨ Clause `sinonSi`

Testez plusieurs conditions sans imbrication excessive :

si note >= 90 alors
    ecrire("Grade A")
sinonSi note >= 80 alors
    ecrire("Grade B")
sinonSi note >= 70 alors
    ecrire("Grade C")
sinon
    ecrire("Échec")
finsi

🎯 Expression Conditionnelle

max = si a > b alors a sinon b
statut = si age >= 18 alors "Majeur" sinon "Mineur"

📝 Initialisation de Variables

variables
    compteur : entier = 0
    pi : reel = 3.14159
    nom : chaine = "Alice"

📦 Tableaux Littéraux

nombres = [10, 20, 30, 40, 50]
notes = [15.5, 12.0, 18.0]
noms = ["Alice", "Bob", "Charlie"]

Nouveaux snippets ajoutés pour matrices et opérateur puissance !

✨ Fonctionnalités

🎨 Coloration Syntaxique Complète

Mots-clés : algorithme, début, fin, si, sinonSi, pour, tantque, etc.
Types : entier, reel, chaine, caractere, booleen, tableau
40 fonctions intégrées avec coloration dédiée :
- Mathématiques (15) : abs, min, max, racine, sin, cos...
- Chaînes (9) : longueur, contient, position, estVide...
- Caractères (8) : ord, chr, estLettre, estChiffre...
- Conversions (3) : versEntier, versReel, versChaine
- Aléatoires (3) : aleatoire() et variantes
Opérateurs : +, -, *, /, div, mod, et, ou, non
Commentaires : //, #, /* */

▶️ Exécution Directe

Raccourci : Ctrl+Shift+R (Windows/Linux) ou Cmd+Shift+R (Mac)
Bouton dans la barre d'outils
Menu contextuel : Clic droit → "Algo: Exécuter"
Palette : Ctrl+Shift+P → "Algo: Exécuter le fichier Algo"
Sortie dans le terminal intégré avec support interactif (lire)

📦 44+ Snippets Intelligents

Tapez le préfixe et appuyez sur Tab :

Nouveaux snippets v1.4.0 :

sinonsi → Structure si avec sinonSi
siexpr → Expression conditionnelle
varinit → Variable avec initialisation
tablit → Tableau littéral
... et 10 autres !

Snippets classiques :

algo → Structure complète d'algorithme
fonction → Définir une fonction
procedure → Définir une procédure
si → Structure conditionnelle
pour → Boucle pour
tantque → Boucle tantque
tableau → Déclarer un tableau
ord, chr, min, max, contient... → Fonctions intégrées
Et bien plus !

⚙️ Configuration Flexible

Chemin du compilateur (auto-détection ou manuel)
Chemin Java personnalisable
Options d'affichage
Nettoyage de sortie configurable

📦 Installation

Étape 1 : Installer Java 21+

Le compilateur nécessite Java 21 ou supérieur.

Windows

# Vérifier Java
java -version

# Si Java n'est pas installé, télécharger depuis :
# https://www.oracle.com/java/technologies/downloads/
# ou https://adoptium.net/

macOS

# Avec Homebrew
brew install openjdk@21

# Vérifier
java -version

Linux

# Ubuntu/Debian
sudo apt install openjdk-21-jdk

# Fedora
sudo dnf install java-21-openjdk

# Vérifier
java -version

Étape 2 : Télécharger le Compilateur

Option A : Depuis GitHub Releases (Recommandé)

Allez sur GitHub Releases
Téléchargez algo-compiler-1.0.0.jar
Placez-le dans un dossier de votre choix, par exemple :
- Windows : C:\Program Files\algo-compiler\algo-compiler-1.0.0.jar
- macOS/Linux : /usr/local/bin/algo-compiler-1.0.0.jar ou ~/algo-compiler/algo-compiler-1.0.0.jar

Option B : Compiler depuis les sources

# Cloner le repo
git clone https://github.com/oughzal/algo-compiler.git
cd algo-compiler

# Compiler (Windows)
.\gradlew.bat build

# Compiler (macOS/Linux)
./gradlew build

# Le JAR sera dans : build/libs/algo-compiler-1.0.0.jar

Étape 3 : Installer l'Extension VS Code

Option A : Depuis le VS Marketplace (Recommandé)

Ouvrir VS Code
Aller dans Extensions (Ctrl+Shift+X)
Rechercher "Algo Compiler"
Cliquer sur Install

Option B : Depuis un fichier VSIX

Télécharger algo-compiler-1.3.0.vsix depuis GitHub Releases
Dans VS Code : Ctrl+Shift+P → Extensions: Install from VSIX...
Sélectionner le fichier téléchargé

Étape 4 : Configurer l'Extension

Ouvrir les Paramètres : File > Preferences > Settings (ou Ctrl+,)
Rechercher "Algo Compiler"
Configurer Compiler Path :
- Windows : C:\Program Files\algo-compiler\algo-compiler-1.0.0.jar
- macOS/Linux : /usr/local/bin/algo-compiler-1.0.0.jar
Si vous avez compilé depuis les sources, utilisez le chemin vers build/libs/algo-compiler-1.0.0.jar
(Optionnel) Configurer Java Path si Java n'est pas dans le PATH :
- Windows : C:\Program Files\Java\jdk-21\bin\java.exe
- macOS : /usr/libexec/java_home -v 21
- Linux : /usr/bin/java

🚀 Utilisation

Créer votre premier programme

Créer un fichier avec l'extension .algo (ex: test.algo)

Utiliser le snippet : Tapez algo puis Tab

algorithme MonPremierProgramme

variables
    nom : chaine
    age : entier

debut
    ecrire("Entrez votre nom: ")
    lire(nom)

    ecrire("Entrez votre âge: ")
    lire(age)

    ecrireln("Bonjour ", nom, " !")
    ecrireln("Vous avez ", age, " ans.")
fin

Exécuter : Ctrl+Shift+R ou clic droit → "Algo: Exécuter"
Le programme s'exécute dans le Terminal intégré !

Exemples de Code

Boucles avec Pas (Step)

algorithme ExemplesPas

variables
    i : entier

debut
    // Boucle ascendante avec pas par défaut (1)
    ecrireln("Nombres de 1 à 10:")
    pour i de 1 à 10 faire
        ecrire(i, " ")
    finpour
    ecrireln()
    
    // Boucle descendante avec pas par défaut (-1)
    ecrireln("Compte à rebours:")
    pour i de 10 à 0 faire
        ecrire(i, " ")
    finpour
    ecrireln()
    
    // Boucle avec pas positif explicite
    ecrireln("Nombres pairs de 0 à 20:")
    pour i de 0 à 20 pas 2 faire
        ecrire(i, " ")
    finpour
    ecrireln()
    
    // Boucle avec pas négatif explicite
    ecrireln("De 20 à 0 par pas de -2:")
    pour i de 20 à 0 pas -2 faire
        ecrire(i, " ")
    finpour
    ecrireln()
fin

Utiliser les 40 fonctions intégrées

algorithme ExemplesFonctions

variables
    texte : chaine
    c : caractere
    resultat : entier

debut
    // Fonctions de chaînes
    texte = "Bonjour le monde"
    
    si contient(texte, "monde") alors
        resultat = position(texte, "monde")
        ecrireln("'monde' trouvé à la position: ", resultat)
    finsi
    
    ecrireln("Longueur: ", longueur(texte))
    ecrireln("Majuscules: ", majuscule(texte))
    
    // Fonctions de caractères
    c = 'A'
    ecrireln("Code ASCII de 'A': ", ord(c))
    ecrireln("Caractère de code 66: ", chr(66))
    
    si estMajuscule(c) alors
        ecrireln("'A' est une majuscule")
    finsi
    
    // Fonctions mathématiques
    ecrireln("min(5, 10) = ", min(5, 10))
    ecrireln("max(5, 10) = ", max(5, 10))
    ecrireln("racine(16) = ", racine(16))
fin

Type Caractère

algorithme TypeCaractere

variables
    lettre : caractere
    code : entier

debut
    lettre = 'A'
    code = ord(lettre)
    
    ecrireln("Caractère: ", lettre)
    ecrireln("Code ASCII: ", code)
    
    lettre = chr(code + 1)
    ecrireln("Caractère suivant: ", lettre)
fin

Raccourcis Clavier

Raccourci	Action
`Ctrl+Shift+R`	Exécuter le fichier algo
`Ctrl+Space`	Autocomplétion
`Tab`	Compléter un snippet

⚙️ Configuration Avancée

Paramètres Disponibles

Accédez via File > Preferences > Settings → Rechercher "Algo Compiler"

Paramètre	Description	Défaut
`algoCompiler.compilerPath`	Chemin vers algo-compiler-1.0.0.jar	Auto-détecté
`algoCompiler.javaPath`	Chemin vers l'exécutable Java	`java`
`algoCompiler.clearOutputBeforeRun`	Effacer la sortie avant exécution	`true`
`algoCompiler.showExecutionTime`	Afficher le temps d'exécution	`true`

Configuration Manuelle (settings.json)

{
  "algoCompiler.compilerPath": "C:\\Program Files\\algo-compiler\\algo-compiler-1.0.0.jar",
  "algoCompiler.javaPath": "C:\\Program Files\\Java\\jdk-21\\bin\\java.exe",
  "algoCompiler.clearOutputBeforeRun": true,
  "algoCompiler.showExecutionTime": true
}

Vérifier la Configuration

Ouvrir un fichier .algo
Essayer d'exécuter (Ctrl+Shift+R)
Si erreur : vérifier les chemins dans les paramètres

🎓 Ressources

Documentation

🌐 Site web : https://oughzal.github.io/Algo-compiler/
📚 Guide complet : README.md
📖 Aide complète : HELP.md
🚀 Démarrage rapide : QUICKSTART.md
🧮 40+ fonctions : FONCTIONS_INTEGREES_COURANTES.md
📊 Matrices : SUPPORT_MATRICES.md
⚡ Opérateur ^ : OPERATEUR_PUISSANCE_ALIAS.md

Exemples

Plus de 30 exemples disponibles dans le dossier examples/ :

Hello World
Factorielle
Jeu de devinette
Manipulation de chaînes
Type caractère
Tableaux
Et bien plus !

Support

🐛 Signaler un bug : GitHub Issues
💬 Discussions : GitHub Discussions
📖 Releases : GitHub Releases

🔧 Dépannage

L'extension ne trouve pas le compilateur

Solution : Configurer manuellement le chemin dans les paramètres

Ctrl+, → Rechercher "Algo Compiler"
Définir Compiler Path avec le chemin complet vers le JAR

Java n'est pas trouvé

Solution : Vérifier que Java 21+ est installé

java -version

Si non installé, télécharger depuis Oracle ou Adoptium

L'exécution ne fonctionne pas

Vérifications :

Java 21+ installé : java -version
Compilateur téléchargé et chemin correct
Fichier .algo sauvegardé
Vérifier la sortie du terminal pour les erreurs

Erreur "Cannot find Java"

Solution : Configurer le chemin Java manuellement

Paramètres → algoCompiler.javaPath → Chemin vers java.exe (Windows) ou java (macOS/Linux)

📝 Notes de Version

v1.3.0 (Actuelle)

✅ Support de 40 fonctions intégrées
✅ Type caractere avec coloration
✅ 30+ snippets enrichis
✅ Amélioration de la coloration syntaxique
✅ Documentation mise à jour

v1.2.0

✅ Exécution interactive avec lire
✅ Support de ecrireln
✅ Améliorations de stabilité

Voir CHANGELOG.md pour l'historique complet.

🤝 Contribution

Les contributions sont les bienvenues !

Fork le projet
Créer une branche (git checkout -b feature/AmazingFeature)
Commit les changements (git commit -m 'Add AmazingFeature')
Push vers la branche (git push origin feature/AmazingFeature)
Ouvrir une Pull Request

📄 Licence

Ce projet est distribué sous licence libre. Voir LICENSE pour plus de détails.

🙏 Remerciements

Développé avec ❤️ pour faciliter l'apprentissage de l'algorithmique en français.

Algo-Compiler - Compilateur de Pseudo-code Français

🌐 Site web : https://oughzal.github.io/Algo-compiler/
🐙 GitHub : https://github.com/oughzal/Algo-compiler
📦 Releases : https://github.com/oughzal/Algo-compiler/releases

Bon algorithme ! 🚀

Algo Compiler

omar oughzal