FR-ALGO (prononcé F-R-ALGO) est un interpréteur pour le pseudo-langage de programmation ALGO.
Avant d'installer FR-ALGO, vérifiez que python version 3.10 ou plus, python-build et pipx sont installés sur votre système :
$ python --version
Python 3.11.8
$ python -c "import build"
$ which pipx
/usr/bin/pipxCloner ce dépôt :
git clone https://github.com/teegre/fr-algo
Puis :
$ cd fr-algo
$ python -m build
Et installer FR-ALGO à l'aide de la commande suivante :
$ pipx install dist/fralgo-0.11.2b7.tar.gz
/!\ Le numéro de version peut être différent.
Ce programme en ligne de commande permet d'exécuter un programme écrit en ALGO préalablement enregistré dans un fichier.
fralgo <fichier>
où <fichier> est un fichier contenant un programme écrit en ALGO.
Début
Ecrire "Bonjour le monde !"
Fin
Pour exécuter le programme ci-dessus enregistré dans le fichier bonjour.algo, il suffit d'entrer cette commande dans un terminal :
$ fralgo bonjour.algo
Après un appui sur la touche Entrée, nous obtenons :
$ fralgo bonjour.algo
Bonjour le monde !
$
Ce programme est un REPL (Read-Eval-Print-Loop), en français : boucle de lecture, d'évaluation et d'affichage. C'est un environnement interactif qui permet d'exécuter des expressions écrites en ALGO.
Pour charger l'environnement interactif, entrer la commande suivante :
$ fralgorepl
Une invite de commande est alors affichée...
$ fralgorepl
_______ ______ _______ _____ _______ _______
| ___| __ \______| _ | |_| __| |
| ___| <______| | | | | - |
|___| |___|__| |___|___|_______|_______|_______|
|A|L|G|O|R|I|T|H|M|E|S| fr-v100 0.11.2.beta.6mg
(c) 2024 Stéphane MEYER (Teegre)
Bonjour, Teegre !
En attente de vos instructions.
:::
... Et l'on peut entrer n'importe quelle expression en ALGO qui sera exécutée après un appui sur la touche Entrée
$ fralgorepl
_______ ______ _______ _____ _______ _______
| ___| __ \______| _ | |_| __| |
| ___| <______| | | | | - |
|___| |___|__| |___|___|_______|_______|_______|
|A|L|G|O|R|I|T|H|M|E|S| fr-v100 0.11.2.beta.6mg
(c) 2024 Stéphane MEYER (Teegre)
Bonjour, Teegre !
En attente de vos instructions.
::: 1 + 1
--- 2
::: Ecrire "Bonjour le monde !"
Bonjour le monde !
Pour annuler une saisie en cours, appuyer sur CTRL+c.
Pour réinitialiser l'environnement interactif, taper REINIT.
Il est possible de naviguer dans l'historique avec les touches ↑ et ↓ et d'effectuer une recherche avec CTRL+r.
Pour quitter, appuyer sur CTRL+d.
Elle doit être scrupuleusement appliquée sous peine d'avoir des erreurs lors de l'exécution des programmes !
Les mots reservés sont sensibles à la casse et aux accents, par exemple :
Debut, debut, Début seront traîtés différemment par l'interpréteur.
En effet, si Début est un mot reservé indiquant le commencement d'un programme ALGO, Debut et debut sont considérés comme des variables.
Il est à noter que chaque instruction d'un programme ALGO, doit être suivie d'un retour à la ligne et les éventuels sauts
de ligne après le mot réservé Fin provoquent une erreur de syntaxe.
Il est possible d'ajouter des commentaires comme suit :
# Ceci est commentaire.
Variable c en Chaîne
# Ceci est un autre commentaire.
Début
# Encore un commentaire.
Ecrire "Bonjour le monde !"
Fin
Les commentaires en fin de ligne ne sont pas acceptés.
VRAI ou FAUX
1, -2, 3
1.2, -3.4, 5.67
"Bonjour"
"A"
On peut spécifier une longueur comme suit : Caractère*10
Attention, si l'on affecte une chaîne de longueur différente, soit la valeur est tronquée, soit des espaces sont ajoutés à la fin.
En d'autres termes, une variable de type Caractère aura toujours la même longueur, peu importe sa valeur.
Exemples :
Variable c en Caractère*5
c <- "ABC"
Longueur(c) = 5
# VRAI
c = "ABC "
# VRAI
c <- "ABCDEF"
c = "ABCDEF"
# FAUX
c = "ABCDE"
# VRAI
Longueur(c) = 5
# VRAI
Variable a en Caractère
a <- ""
Longueur(a)
# 1
a = ""
# FAUX
Variable a en Entier
Variables c1, c2, c3 en Chaîne
a <- (12 * 2 / 4) + 1
c1 <- "Chaîne1"
c2 <- "Chaîne2"
c3 <- c1 & " et " & c2
a = 7
# VRAI
c3 = "Chaîne1 et Chaîne2"
# VRAI
Tableau t1[3] en Entier
# t1[3] désigne un tableau pouvant contenir 4 éléments (numérotés de 0 à 3).
Tableau u[]
# u[] désigne un tableau qui sera dimensionné ultérieurement (voir plus bas).
Tableaux v[1,1], w[7,7,7] en Entier
t[0] <- 1
t[1] <- 2
t[2] <- 3
t[3] <- 4
v[0,0] <- 1
v[0,1] <- 2
v[1,0] <- 3
v[1,1] <- 4
...
w[0,0,0] <- 1
...
w[7,7,7] <- 512
Redim u[3]
u <- t
u = t
# VRAI
u[3] = t[3]
# VRAI
u[3] = 4
# VRAI
Une Table est un tableau associatif.
Plutôt que d'utiliser des index comme dans un Tableau, le type Table utilise des clefs qui seront associées à des valeurs.
Table t
Clef en Chaîne
Valeur en Entier
FinTable
t["A"] <- 65
t["B"] <- 66
t["A"] = 65
# VRAI
Structure Personne
prenom en Chaîne
nom en Chaîne
FinStructure
# Déclaration d'une variable de type Personne
Variables p1, p2 en Personne
p1.prenom <- "John"
p1.nom <- "Wick"
# ou
p1 <- "John", "Wick"
# aussi
p2 <- p1
p2 = p1
# VRAI
# Addition
a + b
# Soustraction
a - b
# Multiplication
a * b
# Division
a / b
# Note : si a et b sont de type Entier, le quotient sera également de type Entier.
# Modulo (reste de la division)
a % b
# Divisible par (retourne VRAI si a est divisible par b)
a DP b
# Puissance
a ^ b
# Concaténation de chaînes de caractères
a & b
# Egal
a = b
# Différent
a <> b
# Supérieur
a > b
# Supérieur ou égal
a >= b
# Inférieur
a < b
# Inférieur ou égal
a <= b
# Et
a ET b
# Ou
a OU b
# Ou exclusif
a OUX b
# Pas
NON(x)
# Si x est FAUX, NON(x) retourne VRAI et vice et versa.
Variable n en Entier
Lire n
# Affecte la valeur entrée par l'utilisateur à la variable 'n'.
Ecrire n
# Affiche la valeur de n.
Ecrire n, x
# Affiche les valeurs de n et de x séparées par un espace.
# Par exemple :
# 74 19
Ecrire n
Ecrire x
# 74
# 19
Ecrire n \
Ecrire x
# 7419
# Le caractère '\' indique à la fonction Ecrire de ne pas
# passer à la ligne suivante, et lors du second appel à
# Ecrire, la valeur de x est affichée directement après
# celle de n.
#
# Application :
Ecrire "Entrer un nombre : " \
Lire n
# Entrer un nombre : _
# _ indique la position du curseur.
#
# Note :
# La fonction Lire essayera de convertir la valeur d'entrée (toujours
# de type Chaîne) en le type attendu par la variable donnée en paramètre.
# Par exemple :
Variable n en Entier
Lire n
# Valeur entrée par l'utilisateur = 12
n = 12
# VRAI
# Si la conversion de type échoue, une erreur est générée :
Lire n
# Valeur entrée par l'utilisateur = 12.34
*** Type Entier attendu
Variable temperature en Entier
Ecrire "Température de l'eau ?"
Lire temperature
Si temperature <= 0 Alors
Ecrire "C'est de la glace"
SinonSi temperature < 100 Alors
Ecrire "C'est de l'eau"
Sinon
Ecrire "C'est de la vapeur"
FinSi
Variable i en Entier
i <- 1
TantQue i < 6
Ecrire i
i <- i + 1
FinTantQue
# 1
# 2
# 3
# 4
# 5
Variable i en Entier
Pour i <- 1 à 5
Ecrire i
i Suivant
# 1
# 2
# 3
# 4
# 5
Pour i <- 1 à 10 Pas 2
Ecrire i
i Suivant
# 1
# 3
# 5
# 7
# 9
Pour i <- 10 à 1 Pas -2
Ecrire i
i Suivant
# 10
# 8
# 6
# 4
# 2
# 'Longueur' renvoie la longueur d'une chaîne de caractères.
Longueur("ABC")
# 3
# 'Extraire' renvoie une sous-chaîne contenue dans une chaîne selon un
# index et une longueur donnés.
Extraire("Carte de crédit", 1, 5)
# Carte
# 'Gauche' renvoie la sous-chaîne d'une longueur donnée à partir du
# début d'une chaîne.
Gauche("Carte de crédit", 5)
# Carte
# 'Droite' renvoie la sous-chaîne d'une longueur donnée à partir de
# la fin d'une chaîne.
Droite("Carte de crédit", 6)
# crédit
# 'Trouve' renvoie l'index d'une sous-chaîne dans une chaîne.
Trouve("Carte de crédit", "crédit")
# 10
# 'CodeCar' retourne le code ASCII du caractère donné en paramètre :
CodeCar("A")
# 65
# Car retourne le caractère correspondant au code ASCII donné en paramètre :
Car(65)
# A
# Lecture simple d'un fichier contenant les lignes suivantes :
# Ligne 1
# Ligne 2
# Ligne 3
Variable tampon en Chaîne
# Ouverture du fichier sur le 'canal' 1 en mode lecture.
Ouvrir "fichier.txt" sur 1 en Lecture
# Tant que la fin du fichier (FDF(1)) n'est pas atteinte...
TantQue NON(FDF(1))
# ... on lit une ligne dans le fichier ouvert sur le 'canal' 1
# que l'on affecte à la variable 'tampon' de type Chaîne.
LireFichier 1, tampon
# On affiche la ligne lue à l'écran.
Ecrire tampon
FinTantQue
# Fermeture du fichier ouvert sur le 'canal' 1
Fermer 1
# 10 'canaux' étant disponibles, il est possible d'ouvrir
# 10 fichiers simultanément.
#
# La fonction FDF retourne VRAI si la fin du fichier est atteinte sur
# le 'canal' spécifié en paramètre.
# Elle retourne FAUX dans le cas contraire.
# Modes d'ouverture :
# * Lecture permet de lire un fichier.
# * Ecriture permet d'écrire dans un fichier. Dans ce mode le contenu
# du fichier est préalablement effacé si le fichier existe, sinon le
# fichier est créé.
# * Ajout permet d'ajouter des lignes dans un fichier.
# Pour écrire dans un fichier, on utilise la fonction 'EcrireFichier'
# Exemple :
Variable i en Entier
Ouvrir "fichier.txt" sur 2 en Ecriture
Pour i <- 1 à 3
EcrireFichier 2, "Ligne " & Chaîne(i)
i Suivant
Fermer 2
# De même en mode Ajout :
Ouvrir "fichier.txt" sur 1 en Ajout
EcrireFichier 1, "Ligne 4"
Fermer 1
Chaîne(123)
# "123"
Chaîne(1.23)
# "1.23"
Entier("123")
# 123
Entier(1.23)
# 1
Numérique("1.23")
# 1.23
Numérique(1)
# 1.0
Tableau t[7] en Entier
# 'Taille' retourne la taille du tableau donné en paramètre.
Taille(t)
# 8
# Dans le cas d'un tableau multidimensionnel, 'Taille' retourne
# un tableau contenant les tailles de chaque sous-tableau.
Tableau t2[7,7]
Taille(t2)
# [8, 8]
Table t
Clef en Chaîne
Valeur en Entier
FinTable
Variable idx en Entier
Pour i <- 65 à 90
t[Car(idx)] <- idx
i Suivant
# 'Longueur' ou 'Taille' retourne le nombre d'éléments dans une table.
Longueur(t)
# 26
Taille(t)
# 26
# 'Existe' retourne VRAI si une clef existe dans une table donnée.
Existe(t, "A")
# VRAI
Existe(t, "0")
# FAUX
# 'Clefs' retourne la liste des clefs.
Clefs(t)
# ["A", "B", "C", ..., "X", "Y", "Z"]
# 'Valeurs' retourne la liste de valeurs.
Valeurs(t)
# [65, 66, 67, ..., 88, 89, 90]
# 'Aléa' retourne un `Numérique` entre 0 et 1.
# Exemple :
# Aléa()
# 0.54575648
# 'Dormir' suspend l'exécution du programme pendant une durée en
# secondes donnée en paramètre.
# La durée peut être de type Entier ou Numérique.
# Exemples :
Dormir(1)
Dormir(0.5)
# 'TempsUnix' retourne un "unix timestamp" de la date et l'heure courante.
# Exemple :
TempsUnix()
# 1714070687.823757
Fonction somme(a, b en Entier) en Entier
Retourne a + b
FinFonction
Note : une fonction doit nécessairement retourner une valeur.
somme(3, 4)
# 7
Fonction double_produit(a, b en Entier) en Entier
# Double la produit de a et b
Fonction mul(a, b en Entier) en Entier
Retourne a * b
FinFonction
Retourne 2 * mul(a, b)
FinFonction
double_produit(4, 5)
# 40
Fonction factorielle(n en Entier) en Entier
Si n = 0 Alors
Retourne 1
FinSi
Retourne factorielle(n - 1) * n
FinFonction
factorielle(10)
# 3628800
Procédure remplir(&t[] en Entier, taille en Entier)
Variable i en Entier
Si taille < 1 Alors
Ecrire "Erreur : taille invalide [", taille, "]"
Sinon
Redim t[taille - 1]
Pour i <- 0 à taille - 1
t[i] <- Entier(Aléa() * 9 + 1)
i Suivant
FinSi
FinProcédure
Note : une procédure ne retourne jamais de valeur.
Tableau tab[] en Entier
Variable n en Entier
n <- 8
remplir(tab, n)
# Exemple de résultat :
# t = [1, 2, 8, 6, 8, 5, 7, 3]
Dans l'exemple précédent, le tableau tab[] est passé par référence (&t[])
en paramètre de la procédure. C'est-à-dire que la variable globale tab est directement modifiée dans la procédure.
En ce qui concerne le paramètre taille, au contraire, seule la valeur de n, soit 8
dans notre exemple, est passée. Lors de l'appele à la procédure remplir, une variable taille est créée localement et la valeur 8 est affectée à taille.
Enfin, la variable est détruite lorsque l'exécution de la procédure est terminée, laissant
intacte la variable originale n.
n = 8
# VRAI
Début- Instructions
Fin
- Déclaration de variables, de tableaux, de structures...
- Déclaration de fonctions, de procédures...
Début- Instructions
Fin
Une librairie est un fichier qui peut contenir des variables, des structures, des tableaux, des fonctions et des procédures qui pourront être réutilisées dans d'autres programmes ALGO.
La structure d'une librairie se présente comme suit :
Librairie- Déclarations
Au besoin, si des variables doivent être initialisées ou si des ajustements sont
nécessaires (comme par exemple remplir un tableau, appeler une fonction, etc.),
on utilise le mot réservé Initialise :
Librairie- Déclarations
Initialise- Instructions
.
..
lib/
|__ librairie.algo
|
|_ projet.algo
|_ utilitaires.algo
# Ma librairie
Librairie
Variable ma_variable en Chaîne
Fonction ma_fonction(...) en ...
...
FinFonction
Procédure ma_procedure(...)
...
FinProcédure
Initialise
ma_variable <- "Bonjour"
# Utilitaires
Librairie
Fonction date() en Chaîne
...
FinFonction
Fonction heure() en Chaîne
...
FinFonction
# Mon projet
# La fonction 'Importer' permet d'inclure une librairie
Importer "lib/librairie"
Début
# On accède aux membres d'une librairie de la manière suivante :
librairie:ma_fonction(...)
librairie:ma_procedure(...)
Ecrire librairie:ma_variable
Fin
# Il est également possible de définir un 'alias' pour une librairie :
Importer "utilitaires" Alias utils
Début
Ecrire utils:date(), utils:heure()
Fin
Une variable spéciale nommée _ARGS de type Tableau est disponible pour
gérer des arguments de la ligne de commande. Ses éléments sont tous du type
Chaîne
Exemple :
# mon_programme.algo
Procédure repete(phrase en Chaîne, nombre en Entier)
TantQue nombre > 0
Ecrire phrase
nombre <- nombre - 1
FinTantQue
FinProcédure
Début
repete(_ARGS[1], Entier(_ARGS[2]))
Fin
$ fralgo mon_programme.algo "Bonjour tout le monde !" 2
Bonjour tout le monde !
Bonjour tout le monde !Par défaut _ARGS[0] contient le nom du programme ALGO courant. Dans notre exemple,
_ARGS[0] est égal à mon_programme.algo.
Pour rendre un programe ALGO exécutable, il suffit d'abord d'y insérer la ligne suivante en en-tête :
#! /usr/bin/env fralgo
Puis de changer les permissions du programme comme suit :
chmod +x mon_programme.algo
Êtes-vous sûr de vouloir désinstaller FR-ALGO ?
$ pipx uninstall fralgo