Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : AMOS - Interpréteur d'expressions
(Article écrit par François Lionet et extrait d'Amiga News Tech - novembre 1991)
|
|
Bonjour les z'amis, aujourd'hui je m'en vais vous proposer un programme d'évaluation d'expressions. Holà,
ça va être rasoir ça. Je vous vois déjà tourner la page pour aller lire les excellents jeux de mots de Max...
Non, restez, ce que je vous propose est complètement hypra-dément (excusez du peu). Parmi les 10 385 129
questions posées sur AMOS à ce jour, une revient très souvent (10 385 128 fois exactement), je cite :
"Pouvez-vous mettre une fonction EVAL, pour que je puisse faire un traceur de courbes ?".
Ma réponse étant invariablement, je cite également : "Non !".
Le rôle d'une telle fonction est de permettre à l'utilisateur d'entrer une équation, et de pouvoir la calculer à
l'intérieur du programme. C'est très pénible à réaliser dans un interpréteur : la fonction EVAL fait appel
à des routines de l'éditeur, se trouvant à un niveau totalement différent de celui de l'interpréteur. De plus, la
compilation d'une telle fonction est tout à fait impossible. La seule solution pour programmer un traceur de
courbe est de réaliser une fonction EVAL en AMOS. C'est ce que je vous propose aujourd'hui.
Le principe
Le principe du programme que je propose est totalement pompé sur les routines d'évaluation d'expressions de
l'AMOS et du compilateur. Je vais me gêner, tiens ! Vous allez voir que c'est complètement récursif :
les procédures n'arrêtent pas de s'appeler l'une l'autre.
Il faut, pour tracer une courbe sur un écran haute résolution (HIRES), calculer la même expression au moins 640
fois. Le programme a donc intérêt à être rapide, pour ne pas finir à la poubelle. Or, explorer une chaîne de
caractères n'est pas des plus performant. C'est pourquoi le programme d'aujourd'hui se divise en deux parties :
- Analyse de la chaîne de caractères et fabrication d'une liste des fonctions à appeler pour le calcul.
Cette partie, la plus lente, s'appelle la tokenisation (transformation en "tokens"). Elle n'est effectuée qu'une
fois.
- Exploration de la liste des fonctions fabriquée par la tokenisation et appel des routines correspondantes.
C'est la partie rapide, appelée 640 fois pour dessiner la courbe.
Le programme
Comme aujourd'hui je veux vous faire comprendre le principe de l'évaluation, eh bien, je garde le traceur de
courbes pour le mois prochain.
Initialisation
- La variable MXE contient la taille maximum des expressions. Chaque élément d'une expression compte pour une
unité. Ainsi, 1+1 prend trois positions dans les tableaux.
- Suit la définition des variables. PILE(), PILE#() et PILE$() sont les tableaux importants, contenant les noms
des routines à appeler.
- La variable OPE$ contient les opérateurs disponibles. Voir plus loin pour rajouter vos propres opérateurs.
- La variable FUN$ contient, elle, les fonctions disponibles. Voir également plus loin pour ajouter vos propres fonctions.
- Suit une petite boucle d'initialisation de variables internes, à titre d'exemple.
- La boucle principale du programme se contente de demander une expression et d'afficher le résultat.
La tokenisation
Nous n'allons pas trop nous éterniser dessus. Elle est constituée de quatre procédures :
- Procedure _TOKENISE[a$] : c'est la procédure à appeler pour lancer la tokenisation. Elle initialise
les variables, et appelle la procédure suivante.
- Procédure _TEVALUE : se charge de digérer une expression entière, comme "1+1". Elle peut être
appelée plusieurs fois, pour les expressions entre parenthèses (quand je vous disais que c'était récursif !).
- Procedure _TOPERAND : se charge d'appréhender un opérande, un chiffre ou une fonction. Dans le
dernier cas, elle appelle la procédure _TEVALUE pour récolter les paramètres, etc.
- Procedure CHAR : ramène les lettres de la chaîne à tokeniser, une par une.
Donc, il suffit d'appeler _TOKENISE["Expression"] pour faire la première partie du travail. En sortie, la
variable SYNT vous indique la présence d'une erreur de syntaxe dans l'expression. Dans ce cas, vous ne
devez évidemment pas appeler les routines de calcul !
Le calcul
Beaucoup plus courte, cette partie n'est constituée que de deux procédures :
- Procedure EVALUE : point d'entrée d'un calcul, cette procédure est également appelée par la suivante.
Le résultat du calcul se trouve dans la variable réservée Param#.
- Procedure EVALIT : une petite boucle explore le tableau PILES, contenant les noms des fonctions à
appeler. Chaque fonction fait son travail et revient à la boucle.
- Les opérateurs (PLUS, MINS, DIVD, TIME, POWR) prennent les valeurs sur la pile PP#(), effectuent
leur opération, et empilent le résultat.
- Les fonctions appellent la routine d'évaluation pour récupérer les paramètres, puis poussent le résultat
sur la pile. Seule exception, la fonction =PI.
Fonctionnement
Le programme affiche les noms des fonctions appelées par la procédure EVALIT. Pour mieux comprendre, voici
voici quelques expressions et la liste des fonctions appelées pour chacune.
La logique de calcul utilisée ici est donc la logique polonaise inverse, que tous les utilisateurs de
calculatrices HP connaissent bien. Plus compliqué :
Ajouter des fonctions
Il est très facile d'ajouter ses fonctions et ses opérateurs. Par exemple, ajoutons l'opérateur Modulo,
qui sera codé par le caractère tilde "~". Nous devons modifier la chaîne OPE$ : celle-ci est classée en ordre
inverse des priorités. MOD ayant une priorité basse, nous devons le mettre en premier dans la liste.
Vous devez maintenant programmer la fonction dans la procédure EVALIT :
_MODU: Dec PP : PP#(PP)=PP#(PP) Mod PP#(PP) Return
|
Par la même méthode, on peut ajouter des fonctions. On va mettre la fonction HSIN().
Entre les accolades {} se trouve le nom de l'instruction. Vient ensuite le nom du label de la routine,
sur quatre lettres. Le chiffre qui suit donne le nombre de paramètres à récupérer.
Et la routine de traitement :
_HSIN: EVALIT : PP#(PP)=Hsin(PP#(PP)) : Return
|
Voilà, c'est tout pour aujourd'hui, j'ai déjà dépassé la taille autorisée par mon rédacteur en chef adoré
(sur tranche). Le mois prochain, Daisy fera le traceur de courbes, et moi je parlerai d'autre chose. A plus !
|
