Projet assembleur

Projet 2011
Architecture des ordinateurs
DEMI2E – Semestre 1
Machine à pile
Réalisé par :
Sok Daline
Lien William

SOMMAIRE
I. INTRODUCTION .......................................................... 1
II. ASSEMBLEUR ........................................................1 - 3
A. ORGANISATION DES DONNEES DANS LE PROGRAMME ................................................. 1
B. CHARGEMENT ET VERIFICATION DU FICHIER ............................................................... 2
C. CREATION DU FICHIER LANGAGE MACHINE ................................................................. 3
III. SIMULATEUR .........................................................4 - 5
A. IMPLEMENTATION GENERALE ................................................................................... 4
B. CHARGEMENT DES INSTRUCTIONS ............................................................................ 4
C. EXECUTION DES INSTRUCTIONS ................................................................................ 5
IV. CODE ................................................................... 6 - 24
A. ASSEMBLEUR ........................................................................................................ 6
B. SIMULATEUR ....................................................................................................... 17
C. EXEMPLE D’EXECUTION ......................................................................................... 22

1
I. Introduction
L’utilisateur doit écrire un programme en assembleur dans un fichier texte nommé «
Assembleur.txt » et le mettre dans le même dossier que les programmes.
Le programme doit respecter les règles suivantes :
 Le programme ne doit comporter que les instructions suivantes : push, push#, ipush, pop, ipop, read,
write, op, dup, jmp, jpc, call, ret, rnd, et halt. Il ne faut pas dépasser 3000 instructions par fichier.
 Chaque ligne ne doit comporter qu’une seule instruction. Les instructions ne sont pas sensibles à la
casse.
 Il ne faut pas sauter de ligne entre deux instructions.
 Si une ligne commence par une étiquette, ceci doit se terminer par ‘:’. De plus, chaque étiquette est
sensible à la casse.
 Il faut respecter l’orthographe, la syntaxe et le nombre de donnée de chaque instruction. Il faut
mettre un espace entre les instructions et les données. Par exemple : « ins donnée » alors que «
insdonnée » n’est pas correcte.
 Le programme se termine par l’instruction « halt ». Il ne faut pas aller à la ligne après la dernière
instruction.
II. Assembleur
Le but de ce programme est de transformer un fichier écrit en assembleur (assembleur.txt) en un
programme écrit en langage machine (fichier binaire.txt).
A. Organisation des données dans le programme
Nous avons crée une structure de l’instruction qui permettra un contrôle et une utilisation
simplifiée pour la traduction du fichier assembleur.
Instructions
assembleur Assembleur Simulation
struct Instruction {
char *nomIns;/*le nom de l'instruction*/
unsigned short codeOpe;/*code d'opération*/
unsigned short nbrDonnee; /*le nombre de donnée de l'instruction*/
int donnee; /*valeur de la donnée*/
char *donneeEnChaine; /*valeur de la donnée en chaine de caractère*/
char *etiq; /*étiquette de l'instruction s'il y en a*/
};

2
B. Chargement et vérification du fichier
Tout d’abord, on récupère un fichier texte dans lequel est écrit un programme en assembleur.
Si le fichier n’est pas trouvé ou si la dernière ligne du fichier ne se termine pas par « halt », le programme
se finit. Sinon, on traite le fichier ligne par ligne. Pour ce faire, nous avons stocké chaque ligne d’instruction
dans une structure qui est elle-même « stockée » par un tableau de structure à portée globale. Puis, durant
le remplissage du tableau de structure « instruction » on vérifie si chaque ligne est écrite correctement. Si
la ligne n’est pas correcte, un message d’erreur sera affiché avec la ligne d’erreur et le programme
s’arrêtera.
La vérification de chaque ligne se fera de la manière suivante :
Traitement du texte brut
•On traite ligne par ligne le fichier assembleur contenant les instructions
Traitement des étiquettes
• On teste la présence de l’étiquette par la fonction "presenceetiq " et on sauvegarde la position du
“ : ” si l’étiquette est présente dans la variable pos. Si une ligne commence par ":" la fonction
renvoie -2, car il y a une erreur d'étiquetage. Et s'il n'y a pas d'étiquette la fonction renvoie -1.
• On stocke l’étiquette grâce à la fonction “stockageetiq". En effet, "stockageetiq" ne stocke que le
nom de l'étiquette dans un tableau etiq en sautant tous les espaces. Pour ce faire, on récupère la
position du ":" grâce à la fonction "presenceetiq". Si "presenceetiq" renvoie une valeur négative
c'est qu'il y a une erreur donc on ne stocke pas l'étiquette. Si la fonction renvoie une valeur
positive alors on avance tant qu'il y a des espaces ou des tabulations. Dès que l'on trouve un
caractère différent de l'espace ou de tabulation, on teste si ce caractère est un ":" si c'en est un on
renvoie -1 car ce n'est pas bon puisqu'une étiquette ne peut pas commencer par ":". Sinon, on part
de la positon du ":" et on enlève tous les espaces avant le ":" afin de récupérer que le nom de
l'étiquette. Pour récupérer le nom on fait une boucle for qui remplit le tableau etiq caractère par
caractère.
Formalisation de la ligne
•On formalise la ligne pour un traitement uniforme et plus simple, en effet chaque ligne sera de la
forme suivante: etiquette+espace+':'+espace+instruction+espace+donnée. Pour cela on utilise la
fonction supBlanc. Cette formalisation permet de connaître exactement la position de chaque
élément de la ligne.
•La fonction « supBlanc » regroupe tous les espaces en un seul. En effet, on fait une boucle sur la
chaine, on teste si un caractère de la chaine est un espace. Si c’est diffèrent, on sauvegarde le
caractère dans une chaine auxiliaire. Sinon, on avance tant que c’est un espace. Ensuite, on
sauvegarde le caractère.
•On récupère la nouvelle position des ':' pour mettre en minuscule seulement les instructions car
les étiquettes et les données sont sensibles à la casse. Afin de mettre les instructions en minuscule
on utilise la fonction « str_tolower ». Cette fonction parcourt chaque caractère de la chaine, si la
position du caractère en cours est inférieure à la position de ‘:’ (pos) ou que le booléen est à 0 alors
on met le caractère en minuscule. Lorsque la position du caractère est supérieure à la position de
(pos+ 1) alors on test si celui ci est un espace, si c’est le cas on mets le booléen à 1. Concrètement,
si le booléen est à 1 cela indique que les caractères qu’on va lire représentent la donnée qui est
sensible à la casse et donc on sauvegarde le caractère sans modification.

3
Traitement des instructions
• On sépare chaque ligne les instructions des données par la fonction “separationLigne”. Le nom de
l’instruction sera stocké dans la structure "instruction" sur le pointeur "nomIns" et les données le
seront sur le pointeur "donneEnChaine". Pour ce faire, on part de pos+1, autrement dit un
caractère après la position du “ :”, on avance tant qu’il y a des espaces ou des tabulation. Si, c’est
une ligne vide un message d’erreur sera affiché et le programme s’arrêtera. Si la ligne n’est pas vide,
on appelle à la fonction « testeEspace » qui teste si un caractère est un espace, tabulation, retour à
la ligne, ou le caractère 0. Tant que cette fonction renvoie 0 on stocke chaque caractère dans tab
instruction. Quand on a terminé avec les instructions on refait les même tests pour les données. Si
tout va bien on stocke les données dans le tableau donnee et on renvoie le nombre données lues.
•On vérifie si les instructions et les données sont entrées de manière correcte avec la fonction
“testIns_Don”. On traite tous les cas possibles avec des sous-fonctions. C'est à dire s'il n'y a pas
d'erreur de syntaxe. S’il y a une erreur un message d’erreur sera affiché et le programme s’arrête. De
plus, on teste également les données de l’instruction, c’est à dire si le nombre des données est bien
respecté pour l’instruction correspondante, si le type des données est correcte et ainsi de suite.
• Si la fonction “testIns_Don” ne renvoie pas -1, on stocke les informations de l’instruction (nomIns,
codeOpe, nbrDonnee, etiq, donneeEnChaine, donnee) dans la structure.
Vérification générale
• Problème doublage d’étiquette : on vérifie qu'il n’y a pas de doublon d’étiquette (des étiquettes qui
ont le même nom) grâce à la fonction “doublonEtiq”. S’il y en a une, un message d’erreur sera affiché
et le programme s’arrêtera.
•Vérification de « halt ». En effet, si le fichier assembleur n’a pas de « halt » un message d’erreur sera
affiché et le programme s’arrêtera.
• Problème d’appel d’étiquette : On teste si les l’appel des instructions “call”, “jmp”, “jpc” existent
bien(c'est à dire qu'ils font référence à une étiquette existante) grâce à la fonction “occurEtiqAvant”.
S‘il n’existe pas un message d’erreur sera affiché et le programme s’arrêtera.
C. Création du fichier langage machine
Franchit l’étape de vérification de syntaxe du fichier assembleur, un message indiquera que la
syntaxe du fichier d’assembleur est correct que le programme va procéder à la traduction vers le langage
machine :
On crée un fichier « fichier binaire.txt », qu’on écrit ligne par ligne les codes opération et les données de
chaque instruction en langage machine.
Affichage du résultat.
Fermeture du programme.