|
|
Lors de cette séance, il faudrait essayer de terminer la
réalisation des actions sémantiques. S'il y a des personnes qui
ont déjà terminé l'analyseur sémantique, elles peuvent passer à la
réalisation de l'interprète décrit ci-dessous. Sinon, ignorez pour
l'instant cette page et revenez y lorsque votre analyseur sera
terminé.
Nouveaux fichiers
Ci-dessous les fichiers vous permettant de réaliser l'interprète.
Interprète
Pour réalisez l'interprète, vous devez compléter le fichier
Interpreter.java en écrivant le code d'interprétation
pour les noeuds FunCall et Operation ainsi que
pour tous les noeuds que vous avez rajoutés à l'arbre qui vous
était fourni lors de la quatrième séance. Notez que le code pour
l'appel de méthode vous est déjà fourni en commentaire. Pour vous
aider, voici quelques rappels et indications concernant les
différentes constructions que vous avez à traiter.
-
Assign: Utilisez storeVal pour indiquer
qu'une valeur doit être écrite.
-
Ident: Utilisez storeVal pour déterminer si
vous devez lire ou écrire et les méthodes
JexSymbol.load et JexSymbol.store pour lire
et écrire les valeurs. En cas de lecture, vérifiez que la
valeur est initialisée en utilisant la méthode
JexSymbol.isInitialized. En cas d'écriture, vérifiez
que la valeur peut être assignée à la variable en utilisant
les méthodes JexSymbol.storageClass et
JexValue.isAssignableTo.
-
FieldAccess: Inspirez-vous de MethodCall.
Utilisez les méthodes JexValue.getField et
JexValue.setField pour accéder aux champs et utilisez
storeVal pour déterminer si vous devez lire ou
écrire.
-
New: Similaire à MethodCall. Utilisez la
méthode JexValue.getNew pour créez une nouvelle
instance de la classe.
-
FunCall: Inspirez-vous de MethodCall et des
commentaires fourni dans le code.
-
Operation: Complétez en suivant le même schéma, mais
attention, les opérateurs d'égalités doivent fonctionner pour
les valeurs booléennes, numériques ainsi que pour les objets.
-
Block: Similaire à DefList, mais ici, il
faut penser aux instructions return. Inspirez-vous du
While.
-
Return: Pensez à isReturn.
-
If: Similaire à While.
-
StringLit: Similaire à NumLit.
-
BooleanLit: Similaire à NumLit.
-
BooleanTp: Similaire à IntTp.
Tests
Pour tester votre interprète utilisez le programme
InterpreterTest. Il génère un arbre syntaxique,
l'imprime, l'analyse, puis, s'il n'y a pas eu d'erreurs,
l'interprète. Pour le lancer utilisez la commande suivante:
gmake run.jex.InterpreterTest < examples/interpreter.jex
ou, sans utiliser gmake:
java jex.InterpreterTest < examples/interpreter.jex
Pour faire vos tests, vous pouvez aussi utiliser le programme
principal décrit ci-dessous
.
Le fichier
examples/interpreter.jex contient une série
d'instructions permettant de tester la plupart des constructions
du langage. En principe, il ne devrait provoquer aucune erreur
d'exécution. Chaque instruction de test affiche une ligne de texte
qui, si tout se passe bien, devrait se terminer par un
ok. En cas de problème, vous aurez probablement droit à
un ERROR en lieu et place du ok, mais, si le
problème est plus grave, il se peut aussi que certaines lignes ne
s'affichent tout simplement pas. Comparez votre résultat à celui
retourné par notre interprète:
examples/interpreter.txt.
En cas de problème, repérez la première erreur essayez de la
corriger puis relancez le programme de test. Corrigez toujours la
première erreur, en effet, certains tests ont comme préconditions
que les précédents ont réussi.
Si vous parvenez à exécuter correctement le fichier
examples/interpreter.jex, vous avez réalisé le plus gros
du travail. Il ne vous reste alors plus qu'à vérifier que votre
interprète détecte correctement les erreurs d'exécution. Pour
cela, vous pouvez utiliser les fichiers ci-dessous. Chaque fichier
.jex provoque une erreur d'exécution qui devrait être
détectée par votre interprète. Les fichiers .txt
contiennent le résutat de notre interprète.
Programme principal
Le programme principal vous permet d'évaluer interactivement des
instructions jex. Pour le lancer utilisez la commande
suivante:
gmake run.jex.Main
ou, sans utiliser gmake:
java jex.Main
Chaque instruction que vous entrez est immédiatement exécutée. Si
elle retourne une valeur, celle-ci est affichée. Avec la commande
:load , vous pouvez charger un fichier qui sera
analysé puis exécuté. Vous pouvez ensuite utiliser les variables
et fonctions qui y sont déclarées. Par exemple, pour charger le
fichier examples/factorial.jex, utilisez la commande
suivante:
:load examples/factorial.jex
L'exécution du fichier devrait provoquer l'affichage suivant:
6
5040
Vous pouvez maintenant utiliser la fonction f définie par
ce fichier. Par exemple, pour calculer 10!, il suffit d'évaluer
l'instruction ci-dessous. Celle-ci devrait retourner
3628800 en résultat.
f(10);
Si vous lancez le programme avec des arguments, chaque argument
est interprété comme un nom de fichier qui est lu puis exécuté. Un
argument composé d'un simple tiret (-) n'est pas
interprété comme un nom de fichier, mais provoque le démarrage
d'une session interactive. Il est ainsi possible de charger
automatiquement un ou plusieurs fichiers avant de démarrer la
session interactive. Par exemple, pour chargez la fichier
examples/factorial.jex, on utiliserait la commande
suivante:
gmake run.jex.Main ARGS="examples/factorial.jex -"
ou, sans utiliser gmake:
java jex.Main examples/factorial.jex -
|
