Programme pox.java

Fermé
etudiant1 - 26 oct. 2011 à 18:28
Bonjour,

écrire un Programme Pox.java qui implémente une machine virtuelle capable d'exécuter des programmes POX. On supposera que les programmes donnés à la machine virtuelle sont corrects (pas de piège). On suposera de plus qu'un programme POX sera spécifié en premier argument de votre programme. Voici les synopsis possibles que votre programme doit comprendre:

java Pox prog.pox
java Pox prog.pox AFFICHE
java Pox prog.pox TRACE
java Pox prog.pox SIMPLIFIE

Toute tentative de lancement de votre programme d'une autre façon doit être repérée et traitée adéquatement à l'utilisateur de votre programme. Voici quelques exemples de lancements illégitimes:

java Pox % manque le no du programme pox
java Pox GRACE % commande non connue

On supposera que le nom du programme POX (premier argument) existe et est un programme écrit dans le language POX.

Votre programme Pox.java doit effectuer 4 tâches différentes qui sont décrites ci-après.
A- Mode Exécution
Il s'agit du mode de fonctionnement par défaut où un programme spécifié en argument de la ligne de commande est exécuté. Voici quelques exemples de lancement de votre programme:

Saisie de 2 et 127:

java Pox somme2entiers.pox
? 2
? 127
129
Pox: steps=7, @mem=2 totalsize=15

Saisie de 10:

java Pox affiche1aN.pox
? 10
1
2
3
4
5
6
7
8
9
10
Pox: steps=93, @mem=2 totalsize=25

Dans ces deux exemples, la dernière ligne est spécifique à mon implémentation et ne vous est pas demandée. Elle indique le nombre d'instructions exécutées, la taille mémoire des données et la taille mémorie totale (données + programme).
B- Mode Affichage
Ce mode, controllé par l'option AFFICHE spécifiée à la ligne de commande permet d'afficher le contenu de la mémoire (données et programme). Les mnémoniques des instructions seront affichées plutôt que le code qui leur est associé dans votre machine virtuelle. Les commentaires éventuels du programme en entrée seront de facto éliminés. Chaque instruction et son argument (le cas échéant) sont affichés sur une ligne. Voici des sorties de la commande pour les fichiers données en exemple.

java Pox somme2entiers.pox AFFICHE > somme2entiers.affiche
java Pox affiche1aN.pox AFFICHE > affiche1aN.affiche
java Pox maxof3.pox AFFICHE > maxof3.affiche
java Pox prod1aN.pox AFFICHE > prod1aN.affiche
java Pox somme1aN.pox AFFICHE > somme1aN.affiche

Le signe > dans les appels précédents indiquent une redirection de la sortie standard vers le fichier dont le nom est indiqué à droite. C'est comme cela que j'ai produit les fichiers résultats. En cas de doute, voici un appel et sa sortie sans utiliser ce mécanisme:

java Pox somme2entiers.pox AFFICHE
MEM 2
INST 13
READ 1
READ 2
LOAD 1
ADD 2
STORE 1
WRITE 1
STOP

C- Mode Trace
Ce mode, controllé par l'option TRACE permet d'afficher l'exécution pas à pas d'un programme. Avant l'exécution d'une instruction, vous devez afficher:

l'indice d'itération; cet indice commence à 1 et est incrémenté de 1 à chaque exécution d'une instruction
le pointeur d'instruction (l'indice de l'instruction en mémoire en cours d'exécution)
la valeur de l'accumulateur
l'instruction (et son argument le cas échéant) en cours d'exécution
et la mémoire au complet, en prenant soin de séparer les données du programme à l'aide d'une barre verticale et en mettant entre crochet l'instruction en cours d'exécution

Les traces d'exécution complètes sont indiquées plus bas pour chaque programme exemple. La première ligne de l'exécution de affiche1aN.pox est rapportée ci-après. Vous devez respecter ce format d'affichage. Il s'agit de la première instruction exécutée (STEP 1), le pointeur d'instruction (ip) est à 2, la première case mémoire après les données du programme (car ce programme déclare 2 octets de données : MEM 2); l'accumulateur n'a pas de valeur spécifiée (ici il vaut 0), l'instruction qui va être exécutée est READ 1 (qui possède un argument: 1); le contenu de la mémoire est ensuite indiqué: les 2 données dont le programme a besoin précèdent le code, qui suit immédiatement la barre verticale. Les codes indiqués (par exemple le 2 qui est encadré est équivalent à la mnémonique READ) sont ceux utilisés par mon programme; vous aurez très probablement choisi des codes différents.

STEP 1 ip=2 acc=0 [READ 1] mem: 0 0 |[2] 1 6 1 5 2 3 2 4 2 7 5 2 4 1 8 5 1 14 2 13 -15 16

Les traces d'éxécution au complet sont indiquées ci-après pour une entrée utilisateur spécifique. Bien que cela ne soit pas nécéssaire, voici pour information les codes utilisés pour représenter les instructions en mémoire.

Trace correspondant à la saisie des valeurs 10 et 20 (résultat attendu 30)
java Pox somme2entiers.pox TRACE > somme2entiers.trace
Trace correspondant à la saisie des valeurs 10, 20 et 30 (résultat attendu 30)
java Pox maxof3.pox TRACE > maxof3.trace
Trace correspondant à la saisie de la valeur 10 (résultat attendu 55)
java Pox somme1aN.pox TRACE > somme1aN.trace
Trace correspondant à la saisie de la valeur 10 (résultat attendu: 3628800)
java Pox prod1aN.pox TRACE > prod1aN.trace
Trace correspondant à la saisie de la valeur 7
java Pox affiche1aN.pox TRACE > affiche1aN.trace

Là encore, si la redirection ne vous plait pas, voici une trace d'exécution:

java Pox somme2entiers.pox TRACE
STEP 1 ip=2 acc=0 [READ 1] mem: 0 0 |[2] 1 2 2 4 1 10 2 5 1 3 1 16
? 5
STEP 2 ip=4 acc=0 [READ 2] mem: 5 0 | 2 1 [2] 2 4 1 10 2 5 1 3 1 16
? 7
STEP 3 ip=6 acc=0 [LOAD 1] mem: 5 7 | 2 1 2 2 [4] 1 10 2 5 1 3 1 16
STEP 4 ip=8 acc=5 [ADD 2] mem: 5 7 | 2 1 2 2 4 1 [10] 2 5 1 3 1 16
STEP 5 ip=10 acc=12 [STORE 1] mem: 5 7 | 2 1 2 2 4 1 10 2 [5] 1 3 1 16
STEP 6 ip=12 acc=12 [WRITE 1] mem: 12 7 | 2 1 2 2 4 1 10 2 5 1 [3] 1 16
12
STEP 7 ip=14 acc=12 [STOP] mem: 12 7 | 2 1 2 2 4 1 10 2 5 1 3 1 [16]
Pox: steps=7, @mem=2 totalsize=15

D- Mode Simplifie
Ce mode, controllé par l'option SIMPLIFIE permet d'afficher sur la sortie standard une version simplifiée du code POX lu en entrée, ou le code lui même, si le programme n'est pas simplifiable. Il existe de multiples façons de simplifier un programme écrit en POX (d'autant plus que l'écriture d'un programme POX est fastidieuse...); notamment, vous pouvez par exemple retirer deux instructions consécutives comme INC DEC. La simplification que je vous demande de programmer vérifie qu'un programme POX qui réclame de l'espace pour stocker les données qu'il manipule n'est pas trop gourmand. Il est en effet possible qu'un programme POX demande un nombre de cases mémoires pour les données qui est plus grand que le nombre de cases mémoire utilisées en pratique. C'est pas exemple le cas du programme asimplifier.pox qui déclare avoir besoin de 50 données (MEM 50), or une analyse des instructions du programme révèle que seulement 3 cases de données sont utilisées (ici les cases d'adresse 11, 22 et 33). Le programme suivant est une version simplifiée du programme précédent, où seules 3 cases mémoire sont nécessaires pour stocker les données (MEM 3). Vous noterez que toutes les instructions qui touchaient aux cases 11, 22 et 33 sont mondifiées de manière à référer aux indices respectifs 1, 2 et 3. Voici deux exemples d'exécution de votre programme. Dans le second cas, aucune simplification (selon les instructions) n'est possible et la sortie produite correspond au code lu en entrée:

java Pox asimplifier.poxSIMPLIFIE > asimplifier-easier.pox
java Pox asimplifier-easier.poxSIMPLIFIE > asimplifier-easier2.pox

Une idée de l'algorithme à implémenter est donnée ici:

identifier toutes les adresses mémoires utilisées dans un programme, en passant en revue toutes les instructions les utilisant (ex: READ, WRITE, etc.)
si le nombre d'adresses différentes utilisées par le programme est inférieur au nombre de cases mémoires demandées par le programme (via l'instruction MEM), c'est qu'il existe une simplification (aller à la suite), sinon afficher le programme tel quel.
rechercher pour chaque adresse de donnée utilisée l'adresse dans le programme simplifié (par exemple, la case d'adresse 11 est relocalisée en l'adresse 1)
faire les transformations de code en conséquence

Ce mode d'exécution du TP est de loin la plus compliqué de ce qui vous est demandé. Prenez le temps d'y réfléchir. Rappelez vous qu'un programme simplifié doit fonctionner de la même façon que le programme POX original. Vérifiez-le !