Pout

6 files changed, 357 insertions, 31 deletions

diff --git a/doc/Makefile.am b/doc/Makefile.am
index d707057..08651de 100644
--- a/doc/Makefile.am
+++ b/doc/Makefile.am
@@ -1,13 +1,13 @@
 EXTRA_DIST = registres.txt archi.tex bib.tex compilateur.tex conclusion.tex description.tex encodage.tex exemples.tex extensions.tex intro.tex manuel.tex probs.tex simulateur.tex Makefile.doc
 
-all: archi.ps
-
-source.tex:
-	make -f Makefile.doc source
+#all: archi.ps
 
 archi.dvi: archi.tex bib.tex compilateur.tex conclusion.tex description.tex encodage.tex exemples.tex extensions.tex intro.tex manuel.tex probs.tex simulateur.tex source.tex
 	make -f Makefile.doc
 
+source.tex:
+	make -f Makefile.doc source
+
 archi.ps: archi.dvi
 	make -f Makefile.doc archi.ps
 
diff --git a/doc/archi.tex b/doc/archi.tex
index 20a1df8..f522549 100644
--- a/doc/archi.tex
+++ b/doc/archi.tex
@@ -11,6 +11,7 @@
 \usepackage{fancyhdr}
 \usepackage{oldstyle}
 \usepackage{listings}
+\usepackage{verbatim}
 %fin des initialisations--------------------------------------------------------
 
 \pagestyle{fancyplain}
diff --git a/doc/conclusion.tex b/doc/conclusion.tex
index 263ea97..951ef8d 100644
--- a/doc/conclusion.tex
+++ b/doc/conclusion.tex
@@ -2,16 +2,12 @@
 \addcontentsline{toc}{chapter}{Conclusion}
 \markboth{CONCLUSION}{CONCLUSION}
 
-
-
-A MODIFIER
-
-
-
-Nous avons présenté ici nos idées pour la conception du projet. Ce
-document constitue donc un premier "cahier des charges". Nous tenterons
-de nous y tenir le plus possible afin de mener le projet à bien. Toutefois, nous
-serons peut-être (sans doute) amenés à effectuer des modifications au
-fil du développement. C'est pourquoi nous rééditerons ce document
-ultérieurement, afin d'y reporter les changements éventuels que nous
-aurons jugé utile d'effectuer.
+Ce projet a été mené à terme, et l'ensemble des idées de l'anayse ont pu être implémentées.
+L'effort de recherche mené sur l'évaluation des expression et des langages de programmation a
+sans aucun doutes été profitable pour notre connaissance personnelle. La programmation sur le simulateur
+nous a apporté une rigueur de programmation imposée par le sujet (programmation en binaire)
+L'ensemble des objectifs du projet ont été atteint et il est certain que nous avons dépassé
+les objectifs de base, pour notre propre amusement et intérêt. Il pourrait être intéressant de
+continuer à programmer quelques application en assembleur pour ce simulateur, et pourquoi pas, un compilateur
+d'un langage haut niveau vers cet assembleur. Mais ce dernier objectif ne pourra être réalisé qu'en maîtrise,
+lors du cours sur les compilateurs.
diff --git a/doc/exemples.tex b/doc/exemples.tex
index b68790b..c02ed87 100644
--- a/doc/exemples.tex
+++ b/doc/exemples.tex
@@ -1,4 +1,171 @@
 \chapter{Exemples de simulations}
 
-%exemple de simulation avec "screenshots"
-%        . codes d exemple commentes
+Nous avons créé quelques exemples en assembleur dont voici les codes sources et l'exécution par le simulateur:
+
+\section{Hello World 1: hello.s}
+Nous commençons doucement par une petite procédure appelée plusieures fois.\\
+
+hello.s:
+\verbatiminput{../samples/hello.s}
+
+Simulation:
+\begin{verbatim}
+$ ./hello
+Simul v1.0
+
+
+Performing initialisation...
+
+ o Initialising the simulator...    Done!
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+ 
+Performing shutdown...
+ 
+Exitting, bye!
+\end{verbatim}
+
+\section{Hello World 2: fichier1.s fichier2.s}
+Pour montrer l'éditeur de liens, deux fichiers séparés.\\
+
+fichier1.s
+\verbatiminput{../samples/fichier1.s}
+
+fichier2.s
+\verbatiminput{../samples/fichier2.s}
+
+Simulation:
+\begin{verbatim}
+$ ./helloworld 
+Simul v1.0
+
+
+Performing initialisation...
+
+ o Initialising the simulator...    Done!
+Hello World
+
+Performing shutdown...
+
+Exitting, bye!
+\end{verbatim}
+
+\section{Somme d'entiers: sommeentiers.s}
+Un exemple simple, l'addition de quelques entiers.\\
+
+sommeentiers.s
+\verbatiminput{../samples/sommeentiers.s}
+
+Simulation:
+\begin{verbatim}
+$ ./sommeentiers 
+Simul v1.0
+
+
+Performing initialisation...
+
+ o Initialising the simulator...    Done!
+La somme des 97 premiers entiers est égale à 4656
+
+Performing shutdown...
+
+Exitting, bye!
+\end{verbatim}
+
+\section{Recherche d'un caractère: rechcara.s}
+Un exemple un peu plus complexe, nous cherchons un caractère dans une chaîne.\\
+
+rechcara.s
+\verbatiminput{../samples/rechcara.s}
+
+Simulation:
+\begin{verbatim}
+$ ./rechcara 
+Simul v1.0
+
+
+Performing initialisation...
+
+ o Initialising the simulator...    Done!
+Le caractere 0x0D a été trouvé dans la chaine à l'index 26
+
+Performing shutdown...
+
+Exitting, bye!
+\end{verbatim}
+
+\section{Recherche de caractères identiques: recherche.s}
+Un exemple avancé: nous recherchons le premier caractère identique entre deux chaînes.\\
+
+recherche.s
+\verbatiminput{../samples/recherche.s}
+
+Simulation:
+\begin{verbatim}
+$ ./recherche 
+Simul v1.0
+
+
+Performing initialisation...
+
+ o Initialising the simulator...    Done!
+TAB1 et TAB2 ont un élément en commun à l'index 82
+
+Performing shutdown...
+
+Exitting, bye!
+\end{verbatim}
+
+\section{Relogement: testtout.s}
+Cet exemple va montrer le mécanisme de relogement: il va charger tous les exemples précédents.\\
+
+testtout.s:
+\verbatiminput{../samples/testtout.s}
+
+Simulation:
+\begin{verbatim}
+$ ./testtout 
+Simul v1.0
+
+
+Performing initialisation...
+
+ o Initialising the simulator...    Done!
+Exécution du programme numéro 0 appelé helloworld...
+Hello World
+Le programme s'est terminé!
+Exécution du programme numéro 1 appelé hello...
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+Hello World!
+Le programme s'est terminé!
+Exécution du programme numéro 2 appelé sommeentiers...
+La somme des 97 premiers entiers est égale à 4656
+Le programme s'est terminé!
+Exécution du programme numéro 3 appelé rechcara...
+Le caractere 0x0D a été trouvé dans la chaine à l'index 26
+Le programme s'est terminé!
+Exécution du programme numéro 4 appelé recherche...
+TAB1 et TAB2 ont un élément en commun à l'index 82
+Le programme s'est terminé!
+Tout est terminé, bye!
+
+Performing shutdown...
+
+Exitting, bye!
+\end{verbatim}
diff --git a/doc/manuel.tex b/doc/manuel.tex
index 7eec7ba..89bd407 100644
--- a/doc/manuel.tex
+++ b/doc/manuel.tex
@@ -27,7 +27,7 @@ méta-langage est indispensable à toute exécution de compilo.
 Exemple d'exécution :
 
 \begin{verbatim}
-$ compilo ../samples/recherche.s recherche.o
+$ ./compilo ../samples/recherche.s recherche.o
 Assembler v1.0
 
 
@@ -47,13 +47,79 @@ Performing initialisation...
    
 \end{verbatim}
 
+\section{L'Editeur de liens : linker}
+La ligne de commande que nous livre l'exécution sans argument du programme 'linker' est la suivante:
+\begin{verbatim}
+$ ./linker
+Linker v1.0
 
+Usage: linker obj1 [obj2 [obj3 [...]]] binary
+\end{verbatim}
 
+Nous devons donc spécifier au moins un fichier objet, et un nom de fichier binaire de sortie.
 
-\section{L'Editeur de liens : linker}
+Exemple d'exécution:
+\begin{verbatim}
+$ ./linker recherche.o recherche
+Linker v1.0
 
-\section{Le Simulateur : simul }
 
+Performing initialisation...
+
+ o Initialising the linker...    Done!
+ Linking files...
+ Generating output file...
+ Statistics: 29 words of text, 297 words of data and reserving 0 words
+ Output file size: 343 words containing 10 relocating offsets.
+ 
+ Performing shutdown...
+ 
+ Exitting, bye!
+\end{verbatim}
+
+\section{Le Simulateur : simul }
 \subsection{la ligne de commande}
+Le nom de la commande à lancer pour exécuter le simulateur est 'simul'. La ligne de commande est la suivante:
+\begin{verbatim}
+$ ./simul 
+Simul v1.0
+
+Usage: linker [-s] [-d] binary
+\end{verbatim}
+L'option -s sert à sélectionner une ALU différente, et plus instable. L'option -d sert à déclanger le debugger dès la
+première instruction. Bien évidemment, il faut donner le nom d'un fichier binaire à exécuter.
+
+\subsection{le mode interactif}
+Lors de l'exécution du simulateur, le programme exécuté tourne jusqu'à ce qu'une instruction HALT est rencontrée. Pour
+interrompre l'exécution et déclanger le debugger, il est possible de frapper la combinaison de touche CTRL-C. Si l'option
+-d a été spécifiée sur la ligne de commande, nous obtenons le même résultat:
+
+\begin{verbatim}
+ o Initialising the simulator...    Done!
+   R00      R01      R02      R03      R04      R05      R06      R07   
+00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
+   R08      R09      R10      R11      R12      R13      R14      R15   
+00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
+   R16      R17      R18      R19      R20      R21      R22      R23   
+00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 
+   R24      R25      R26      R27      R28      R29      R30      R31   
+00000000 00000000 00000000 00000000 00000002 000027FF 00000002 00000000 
+Rg: 00000000  | Rd: 00000000 | Flag: 00000000 | PC: 00000000
+Opcode: 0A, extension: 00, champ1: 00, champ2: 00, champ3: 00
+00000000:0000000A - 00000000 - 00000000 > 
+\end{verbatim}
+Cette interface nous présente l'ensemble des registres du CPU, ainsi que les quelques flags spéciaux.
+De plus, les champ de l'instruction suivante sont décodés, et la dernière ligne nous indique les trois mots mémoire
+pour le compteur ordinal en cours. Le prompt > nous invite à taper une commande parmi:
+
+\begin{verbatim}
+> Help:
+G: go
+P: Proceed
+R: display registers
+Q: quit
+\end{verbatim}
 
-\subsection{le mode interactif}
\ No newline at end of file
+Go stoppe le debugger et relance l'exécution du CPU. Proceed avance d'une instruction. Display registers réaffiche la
+page des registres, au cas où l'écrant ait été corrompu par l'exécution du programme. Enfin, quit permet de sortir immédiatement
+du simulateur.
\ No newline at end of file
diff --git a/doc/probs.tex b/doc/probs.tex
index 220edad..5b7a640 100644
--- a/doc/probs.tex
+++ b/doc/probs.tex
@@ -1,17 +1,109 @@
 \chapter{Description des solutions technologiques}
 
-\section{Parseur et Meta-Parseur}
-
-
-\section{Assembleur}
+\section{Meta-Parseur}
 
 %description du meta langage
 %format du fichier instructions.txt
 %description du langage asm...
+Le meta langage a été développé comme nous l'avons proposé dans notre analyse, et voici sa decription complète\\
+Le fichier écrit en méta langage doit être écrit et analysé ligne par ligne, chaque ligne ayant une signification
+discincte suivant son premier caractère:
+\begin{itemize}
+\item F sert à décrire un champ de bits. Le champ appelé 'I' est le champ d'instruction principal et sera utilisé pour
+créer les instructions finales. Sa syntaxe est la suivante://
+\begin{verbatim}
+Fnom:champ1,taille1;champ2;taille2;...
+\end{verbatim}
+Par exemple, notre FI:c3,6;c2,6;c1,6;e,6;op,8 nous sert à décrire parfaitement le champ d'opcode général tel que décrit
+dans notre analyse. c1, c2, et c3 sont les noms des trois champs arguments, e est le nom du champ d'extension, et op est
+le nom du champ d'opcode.
+\item P sert à décrire une "pattern". Toute instruction va suivre un schéma particulier, et nous pouvons le quantifier grâce
+à ce système de partition. La variable générée par l'évaluation d'une pattern sera égale à l'indice de la chaîne trouvée
+dans la pattern. Voici la syntaxe d'une telle ligne:
+\begin{verbatim}
+Pnom:pattern1;pattern2;pattern3;...
+\end{verbatim}
+Chaque pattern possède elle même une syntaxe propre pouvant se classifier en 5 groupes principaux:
+\begin{itemize}
+\item Une chaîne de caractères qui sera reconnue telle quelle.
+\item Une autre pattern qui sera stoquée dans une variable suivant la syntaxe: nomvar=.Pnom
+\item Une déclaration d'adresse stoquée dans une valeur immédiate suivant la syntaxe: .I=.O
+\item Une déclaration de décalage (utilisant l'opérateur [) qui peut se faire soit par une pattern immédiate sous la syntaxe [nomvar=.Pnom
+soit par le décalage d'une autre adresse sous la syntaxe .I=.O[nomvar=.Pnom
+\end{itemize}
+Ainsi nous avons une pattern pour les registres (Pr:R0;R1;R2;...) et une pattern pour toutes les adresses (Pm::regop=.Pr;.I=.O;[regop=.Pr;.I=.O[regop=.Pr)
+et les numéros d'indices de chaque élément correspond bien aux spécifications données dans notre analyse.
+\item I sert à décrire une instruction. Une ligne I est décomposée en deux partie. La ligne ne suit pas de syntaxe particulière dans sa première partie,
+car nous devons pouvoir décrire n'importe quelle style d'instruction. Par exemple, nous avons I:ADD c1=.Pr,c2=.Pr,c3=.Pr; qui signifie que nous décrivons
+l'instruction ADD suivie de trois registres dont les indices correspondants seront mis dans les variables c1, c2 et c3 respectivement. La deuxième partie
+de la ligne (après le ;) sert à donner la listes des variables implicites. Dans l'exemple de notre ADD, nous avons ceci: op=0x0;e=0x0 ce qui signifie que les
+variable op et e doivent être mises à zéro. Ainsi, chaque ligne sera évaluée récursivement en fonction des différentes variables et des différents champs spécifiés.
+Dans notre cas, comme nous avons FI qui déclare les variables c1, c2, c3, e, et op, il nous faut obligatoirement ces 5 variables pour chaque instruction.
+Enfin, chaque élément de l'instruction peut suivre aussi des formes différentes. En voici la liste:
+\begin{itemize}
+\item Nous pouvons avoir une chaîne toute seule (comme ADD dans notre cas) pour dire qu'il faut que cette chaîne soit présente dans
+le code source assembleur.
+\item Nous pouvons avoir comme nous l'avons vu la syntaxe variable=.Pnom. Cela signifie qu'à cet endroit de la ligne source assembleur
+doit se trouver un mot pouvant évaluer la pattern, et qu'il faut placer l'indice évalué dans la variable spécifiée.
+\item Nous pouvois avoir .I=.C ce qui signifie qu`à cet endroit là doit se trouver une constante, qui sera placée immédiatement après
+l'opcode de l'instruction.
+\item Nous pouvons enfin avoir .I=.O ce qui signifie qu'à cet endroit là doit se trouver une adresse directe.
+\end{itemize}
+Dans la liste des instructions de la seconde partie, nous pouvons avoir aussi la déclaration variable=.Fnom, ce qui signifie que la variable
+indiquée sera évaluée par le champ de bit spécifié. Enfin nous pouvons aussi avoir la déclaration variable1=variable2.
+\end{itemize}
+Ce meta langage nous a permi de décrire une grande partie des instructions dont nous avons parlé dans l'analyse. Voici ce fichier:
+\verbatiminput{../samples/instructions.txt}
+
+\section{Parseur}
+Le parseur est un morceau de code relativement simple. Il va lire une ligne en entrée et va la décomposer en deux catégorie d'éléments:
+\begin{itemize}
+\item Des symboles
+\item Des opérateurs
+\end{itemize}
+Tout est traité suivant une pile polonaise inversée. Par exemple, l'expression 1 + 2 * 3 + 4 sera traitée comme suit:
+\begin{verbatim}
+PushSymbol(1)
+PushSymbol(2)
+PushSymbol(3)
+ActPile(*)
+ActPile(+)
+PushSymbol(4)
+ActPile(+)
+\end{verbatim}
+Les fonctions PushSymbol et ActPile sont des symboles globaux et sont définis dans l'assembleur.
 
+\section{Assembleur}
+L'assembleur, s'il a l'air complexe par la taille de son code source, est en fait relativement simple aussi. Il est articulé sur un mécanisme
+très simple: tout symbole provenant du parseur sera encapsulé dans des bulles qui seront évaluées au fur et à mesure de la progression de
+l'assemblage du code source. Au pire, au stade final de l'assemblage, lors de la génération du fichier objet, nous aurons des symboles
+que l'éditeur de liens se fera une joie de résoudre et de compléter. Dans tous les cas, l'analyse du fichier se fait sur quatre niveaux:
+\begin{itemize}
+\item Lors de l'ajout d'un symbole par le parseur.
+\item Lors de l'ajout d'un opérateur par le parseur.
+\item Lors d'une fin de ligne.
+\item Lors de la fin du fichier source.
+\end{itemize}
+A chacun de ces quatre niveaux se trouve des paliers d'évaluations. Si un symbole, une expression ou une ligne ne peut pas
+passer ce palier, une erreur sera générée. Ces paliers deviennent de plus en plus stricts suivant les niveaux passés. Ainsi, comme décrit
+plus haut, le dernier palier ne peut que laisser passer des valeurs immédiates ou bien des symboles à reloger par l'éditeur de liens.\\
+L'assembleur possède aussi quelques symboles prédéfinis:
+\begin{itemize}
+\item .text pour déclarer l'écriture dans le segment de text
+\item .data pour déclarer l'écriture dans le segment de data
+\item .bss pour déclarer l'écriture dans le segment bss
+\item .start pour déclarer le point d'entrée
+\item DB, DW et DD pour enregistrer un ou plusieurs mots mémoires
+\item DS pour enregistrer une chaîne de caractères
+\item DR pour enregistrer un tableau de mots non initialisés.
+\end{itemize}
 \section{Editeur de liens}
 
-%mecanisme de relocation
+Les fichiers objets générés par l'assembleur ont une struture suffisamment simple pour que l'éditeur de liens ait un travail très simplifié:
+il charge d'affilé tous les fichiers objets à lier, et va créer une table de tous les symboles internes. Puis il va concaténer tous les
+segments de text ensemble, tous les segments de data ensemble, et va reloger les références croisées suivant la table des symboles internes.
+Le fichier de sortie est un binaire qui suit les spécification de notre analyse. La table de relogement nous sert à indiquer toutes
+les références à des symboles absolus, de sorte à pouvoir placer le binaire n'importe où dans la mémoire de notre CPU virtuel.
 
 \section{Operations ALU} %algos ALU lente
 
@@ -38,11 +130,15 @@ Pour la division, nous utilisons comme pour la multiplication deux registres, un
 division et pour ce faire on utilise l'algorithme de notre jeunesse.
 Pour les deux fonctions de décalage, nous décalons les bits du nombre demandé et on remplace les bits manquants par 0.
 
+\section{MiniOS}
 
+Notre MiniOS n'a qu'un role très restreint: celui de charger un binaire et le reloger correctement en mémoire, et d'effectuer
+des petits travaux d'interfaces homme/machine. Toutes les fonctions d'interface pensées pendant l'analyse ont été implémentées.
+Lors du chargement d'un binaire, il va initialiser correctement toutes les informations nécessaires au bon déroulement du programme.
 
 \section{Contrôleur}
 
-%decodage, execution, gestion de la ram
-
-\section{MiniOS}
+Le contrôleur va prendre la main dès qu'un binaire aura été chargé en mémoire. Il va décoder le binaire instructions par instructions,
+et va activer les différents composants de notre CPU: les registres, l'alu et la mémoire. L'accès à la mémoire fait l'objet d'un code
+très spécifique, car c'est en écrivant à certains offsets mémoire que nous pouvons récupérer des informations devant aller vers le MiniOS.