init

diff --git a/Rapport Pietrzak Emery Fran%E7ois Bertrand.doc b/Rapport Pietrzak Emery Fran%E7ois Bertrand.doc
new file mode 100755 (executable)
index 0000000..f5b5c5e
Binary files /dev/null and b/Rapport Pietrzak Emery Fran%E7ois Bertrand.doc differ

diff --git a/dasm/dasm b/dasm/dasm
new file mode 100755 (executable)
index 0000000..2cd4e9c
Binary files /dev/null and b/dasm/dasm differ

diff --git a/dasm/dasm.c b/dasm/dasm.c
new file mode 100755 (executable)
index 0000000..1804c7e
--- /dev/null
+++ b/dasm/dasm.c
@@ -0,0 +1,374 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define OUTS   1
+#define OUTD   2
+#define JMP    27
+#define JSP            28
+#define RET            29
+#define STP            32
+#define ADDS   39
+#define ADDD   40
+#define SUBS   41
+#define SUBD   42
+#define MULS   43
+#define MULD   44
+#define DIVS   45
+#define DIVD   46
+#define ABSS   47
+#define NGS    48
+#define NGD    49
+#define EQS            50
+#define EQD    51
+#define LES            52
+#define LED            53
+#define LLS            54
+#define LLD            55
+#define MVS    56
+#define MVD    57
+#define LDS            58
+#define LDD    59
+#define STS            60
+#define STD            61
+#define ABSD   62
+
+int lire_nb_instr(FILE * fichier);
+int str2int(const char *chaine);
+int lire_instr(FILE *source);
+void lire_arg_8(const char *chaine);
+void lire_adr(const char *chaine);
+void lire_symbole(const char *ligne, int i);
+
+int main (int argc, char *argv[])
+{
+       FILE *source;                   //flux sur le fichier source
+
+       int nbinstr;                            //nombre d'instructions du programme
+       int i;
+       char ligne[64];                 //ligne d'instruction du programme
+       char * fichier;                 //nom du fichier programme à désassembler
+
+
+       if (argc == 2)  //regarde si un nom de fichier a été passé en argument
+               fichier = strdup(argv[1]);
+       else                    //sinon demande à l'utilisateur de le taper au clavier
+       {
+               fprintf(stdout,"Entrez le nom du fichier source: ");
+
+               if ((fichier = (char*) malloc(32 * sizeof(char))) == NULL)
+                       return(0);
+
+               fscanf(stdin,"%s",fichier);
+       }
+
+       if ((source = fopen(fichier,"r")) == NULL)
+       {
+               fprintf(stderr,"Erreur à la lecture du fichier\n");
+               return (0);
+       }
+
+       //lecture du nombre d'instructions
+       if ((nbinstr = lire_nb_instr (source)) == -1)
+       {
+               fprintf(stderr,"Erreur de fichier\n");
+               fclose(source);
+               return (0);
+       }
+
+       //lecture des instructions
+       for (i=0; i < nbinstr; i++)
+       {       fprintf(stdout,"%3d : ",i+1);
+               if (lire_instr(source) == 0)
+                       return (0);
+       }
+
+       fprintf(stdout,"\n");
+
+       //lecture des symboles
+       i = 0;
+       while (fgets(ligne,64, source) != NULL)
+       {
+               if(ligne[strlen(ligne) - 1] == '\n')
+                       ligne[strlen(ligne) - 1] = '\0';
+
+               lire_symbole(ligne, i);
+               i++;
+       }
+
+
+       fclose(source);
+       return (1);
+}
+
+int lire_nb_instr(FILE * fichier)
+{
+       char ligne[64];         //ligne à lire
+
+       if ( fgets(ligne,64,fichier) == NULL)
+               return (-1);
+
+       if(ligne[strlen(ligne) - 1] == '\n')
+               ligne[strlen(ligne) - 1] = '\0';
+
+       return (str2int(ligne));
+}
+
+int str2int(const char *chaine)
+{
+       int i;
+       int total=0;
+       int puiss2=1;
+
+       for(i = strlen(chaine) ; i>0 ; i--)
+       {
+               total += (chaine[i-1]-'0') * puiss2;
+               puiss2 *= 2;
+       }
+       return total;
+}
+
+int lire_instr(FILE *source)
+{
+       char ligne[64];         //ligne à lire
+       char *code_op;          //code de l'instruction
+
+       int i;
+       int     codop;
+
+       if ((code_op = (char *) malloc(9*sizeof(char)))==NULL)
+               return (0);
+
+       if (fgets(ligne,64, source) == NULL)
+               return (0);
+
+       if(ligne[strlen(ligne) - 1] == '\n')
+               ligne[strlen(ligne) - 1] = '\0';
+
+       //récupération du code de l'opération
+       for (i=0 ; i<8 ; i++)
+               code_op[i] = ligne[i];
+       code_op[8]='\0';
+       codop = str2int(code_op);
+
+       switch(codop)
+       {
+               case OUTS :
+                       fprintf(stdout,"OUTS\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole contenant l'adresse
+                       fprintf(stdout,"\n");
+                       break;          case OUTD :
+                       fprintf(stdout,"OUTD\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole contenant l'adresse
+                       fprintf(stdout,"\n");
+                       break;          case JMP :
+                       fprintf(stdout,"JMP\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole contenant l'adresse
+                       fprintf(stdout,"\n");
+                       break;
+               case JSP :
+                       fprintf(stdout,"JSP\t");
+                       lire_adr(&ligne[8]);    //les 16 bits suivant correspondent à l'adresse de branchement
+                       fprintf(stdout,"\n");
+                       break;
+               case RET :
+                       fprintf(stdout,"RET\n");
+                       break;
+               case STP :
+                       fprintf(stdout,"STP\n");
+                       break;
+               case ADDS :
+                       fprintf(stdout,"ADDS\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case ADDD :
+                       fprintf(stdout,"ADDD\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case SUBS :
+                       fprintf(stdout,"SUBS\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case SUBD :
+                       fprintf(stdout,"SUBD\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case MULS :
+                       fprintf(stdout,"MULS\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case MULD :
+                       fprintf(stdout,"MULD\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case DIVS :
+                       fprintf(stdout,"DIVS\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case DIVD :
+                       fprintf(stdout,"DIVD\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case ABSS :
+                       fprintf(stdout,"ABSS\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument
+                       fprintf(stdout,"\n");
+                       break;
+               case ABSD :
+                       fprintf(stdout,"ABSD\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument
+                       fprintf(stdout,"\n");
+                       break;
+               case NGS :
+                       fprintf(stdout,"NGS\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument
+                       fprintf(stdout,"\n");
+                       break;
+               case NGD :
+                       fprintf(stdout,"NGD\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument
+                       fprintf(stdout,"\n");
+                       break;
+               case EQS :
+                       fprintf(stdout,"EQS\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case EQD :
+                       fprintf(stdout,"EQD\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case LES :
+                       fprintf(stdout,"LES\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case LED :
+                       fprintf(stdout,"LED\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case LLS :
+                       fprintf(stdout,"LLS\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case LLD :
+                       fprintf(stdout,"LLD\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole de premier argument
+                       lire_arg_8(&ligne[24]); //l'octet suivant est le symbole de second argument
+                       fprintf(stdout,"\n");
+                       break;
+               case MVS :
+                       fprintf(stdout,"MVS\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument
+                       fprintf(stdout,"\n");
+                       break;
+               case MVD :
+                       fprintf(stdout,"MVD\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument
+                       fprintf(stdout,"\n");
+                       break;
+               case LDS :
+                       fprintf(stdout,"LDS\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument
+                       fprintf(stdout,"\n");
+                       break;
+               case LDD :
+                       fprintf(stdout,"LDD\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument
+                       fprintf(stdout,"\n");
+                       break;
+               case STS :
+                       fprintf(stdout,"STS\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument
+                       fprintf(stdout,"\n");
+                       break;
+               case STD :
+                       fprintf(stdout,"STD\t");
+                       lire_arg_8(&ligne[8]);  //l'octet après l'instruction est le symbole de destination
+                       lire_arg_8(&ligne[16]); //l'octet suivant est le symbole d'argument
+                       fprintf(stdout,"\n");
+                       break;
+               default :
+                       fprintf(stdout,"Instruction inconnue : %s\n",ligne);
+                       break;
+       }
+
+       free(code_op);
+
+       return(1);
+}
+
+void lire_arg_8(const char *chaine)
+{
+       char indice[8]; //numéro du symbole/registre en binaire
+       int i;
+
+       //recopie du numéro du registre/symbole
+       for (i=1 ; i<8 ; i++)
+               indice[i - 1] = chaine[i];
+       indice[7] = '\0';
+
+       if (chaine[0] == '0')   //c'est un symbole
+               fprintf(stdout,"S%d\t",str2int(indice));        //affiche le nom du symbole
+       else                            //c'est un registre
+               fprintf(stdout,"R%d\t",str2int(indice));        //affiche le nom du registre
+}
+
+void lire_adr(const char *chaine)
+{
+       //chaine contient l'adresse de l'instruction de saut. Les adresses d'instructions commencent à l'adresse 127
+       //donc l'instruction 1 est à l'adresse 127 (0 + 127), la 2e à l'adresse 128 (1 + 127) ...
+       fprintf(stdout,"Instruction %d",str2int(chaine) - 127);
+}
+
+void lire_symbole(const char *ligne, int i)
+{
+       fprintf(stdout,"S%d : %s\n",i, ligne);
+}

diff --git a/dasm/lisezmoi.txt b/dasm/lisezmoi.txt
new file mode 100755 (executable)
index 0000000..dd56a9c
--- /dev/null
+++ b/dasm/lisezmoi.txt
@@ -0,0 +1,8 @@
+pour compiler :\r
+gcc -o dasm dasm.c\r
+\r
+pour lancer :\r
+dasm [nom_fichier]\r
+\r
+remarque :\r
+si vous voulez enregistrer le résultat du désassemblage dans un fichier, redirigez la sortie standard du programme à l'aide de l'opérateur <
\ No newline at end of file

diff --git a/exemples/addd.bin b/exemples/addd.bin
new file mode 100755 (executable)
index 0000000..910100c
--- /dev/null
+++ b/exemples/addd.bin
@@ -0,0 +1,7 @@
+0000000000000010
+00101000100000000000000000000010
+0000001010000000
+01100110011001100110011001100110
+01000000001101110010011001100110
+10001111010111000010100011110110
+01000000001010001111010111000010

diff --git a/exemples/d.bin b/exemples/d.bin
new file mode 100755 (executable)
index 0000000..76474b7
--- /dev/null
+++ b/exemples/d.bin
@@ -0,0 +1,26 @@
+0000000000010001
+001110111000000000000000
+00101000100000001000000000000000
+0000001010000000
+0000001000000000
+0000001000000010
+00110101000001001000000000000010
+001110111000001100000000
+001110011000001000000010
+000111000000000010001010
+00100000
+0000001010000010
+0000001010000011
+0000001000000101
+00110111000001111000001010000011
+00101010100000101000001000000101
+000111000000000010001010
+00011101
+00000000000000000000000000000000
+00111111111110000000000000000000
+01010001111010111000010100011111
+01000000001011010001111010111000
+00000000000000000000000010000001
+00110011001100110011001100110011
+00111111111100110011001100110011
+00000000000000000000000010010000

diff --git a/exemples/divd.bin b/exemples/divd.bin
new file mode 100755 (executable)
index 0000000..6ab7762
--- /dev/null
+++ b/exemples/divd.bin
@@ -0,0 +1,7 @@
+0000000000000010
+00101110100000000000000000000010
+00100000
+00000000000000000000000000000000
+01000000001101100100000000000000
+00000000000000000000000000000000
+00111111111101000000000000000000

diff --git a/exemples/exec.bin b/exemples/exec.bin
new file mode 100755 (executable)
index 0000000..ccd2693
--- /dev/null
+++ b/exemples/exec.bin
@@ -0,0 +1,28 @@
+0000000000010011
+001110101000000000000000
+001110001000000100000001
+001110101000001000000010
+001110001000001100000011
+00100111100000001000000010000010
+00100111100000011000000110000011
+001110001000000010000010
+001110001000000110000011
+000111000000000010001010
+00100000
+001110000000010100000100
+001110001000001100000100
+000111000000000010010001
+00100111000001010000010110000001
+00110110000001101000001110000000
+001110101000001000000101
+00011101
+00100111100000111000001100000111
+00011101
+01000000001000100100110111010011
+01000000010101001110110110010001
+01000000001001001111110111110100
+01000000001000001100010010011100
+00111101110011001100110011001101
+00000000000000000000000000000000
+00000000000000000000000010001100
+00111111100000000000000000000000

diff --git a/exemples/exemple.bin b/exemples/exemple.bin
new file mode 100755 (executable)
index 0000000..d2cfbb8
--- /dev/null
+++ b/exemples/exemple.bin
@@ -0,0 +1,17 @@
+0000000000001011
+001110001000000000000000
+00100111100000001000000000000000
+00110110000000101000000000000001
+001110101000001100000000
+001110001000001000000001
+000111000000000010000111
+00100000
+00110110000001001000001010000011
+00101001100000101000001000000011
+000111000000000010000111
+00011101
+00111111110000000000000000000000
+01000001111101000111101011100001
+00000000000000000000000010000001
+00111111100110011001100110011010
+00000000000000000000000010001010
\ No newline at end of file

diff --git a/exemples/min.bin b/exemples/min.bin
new file mode 100755 (executable)
index 0000000..efb6beb
--- /dev/null
+++ b/exemples/min.bin
@@ -0,0 +1,8 @@
+0000000000000011
+00101110100000000000000000000010
+0000001010000000
+00100000
+00000000000000000000000000000000
+01000000001101100100000000000000
+00000000000000000000000000000000
+00111111111101000000000000000000

diff --git a/exemples/out.bin b/exemples/out.bin
new file mode 100755 (executable)
index 0000000..37b2ea3
--- /dev/null
+++ b/exemples/out.bin
@@ -0,0 +1,7 @@
+0000000000000100
+000111000000000010000010
+00100000
+0000001000000000
+00011101
+10000011011110110100101000100011
+01000000101100011101010000011111

diff --git a/exemples/s.bin b/exemples/s.bin
new file mode 100755 (executable)
index 0000000..6d1abc3
--- /dev/null
+++ b/exemples/s.bin
@@ -0,0 +1,23 @@
+0000000000010001
+001110101000000000000000
+00101101100000000000000110000000
+0000000110000000
+0000000100000000
+0000000100000001
+00110100000000101000000000000001
+001110101000001100000000
+001110001000001000000001
+000111000000000010001010
+00100000
+0000000110000010
+0000000110000011
+0000000100000011
+00110110000001001000001010000011
+00101001100000101000001000000011
+000111000000000010001010
+00011101
+00111111110000000000000000000000
+01000001011010001111010111000011
+00000000000000000000000010000001
+00111111100110011001100110011010
+00000000000000000000000010010000

diff --git a/exemples/test.bin b/exemples/test.bin
new file mode 100755 (executable)
index 0000000..981896c
--- /dev/null
+++ b/exemples/test.bin
@@ -0,0 +1,17 @@
+0000000000001011
+001110001000000000000000
+00100111100000001000000000000000
+00110110000000101000000000000001
+001110101000001100000000
+001110001000001000000001
+000111000000000010000111
+00100000
+00110110000001001000001010000011
+00101001100000101000001000000011
+000111000000000010000111
+00011101
+00111111110000000000000000000000
+01000001111101000111101011100001
+00000000000000000000000010000001
+00111111100110011001100110011010
+00000000000000000000000010001010

diff --git a/vexec/fpu.c b/vexec/fpu.c
new file mode 100755 (executable)
index 0000000..ac3a7f2
--- /dev/null
+++ b/vexec/fpu.c
@@ -0,0 +1,1160 @@
+#include "fpu.h"
+#include "muldiv.h"
+
+
+extern int NbInstr;
+
+void FPU( Machine * PC, int opp) {
+
+       Flag flag_REG_S1, flag_REG_S2;
+       char *string;
+
+       switch( opp) {
+
+       case ADDS: {
+                          TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                          fpu_ADDS( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                               string="!ADDS!";
+                          }break;
+       case ADDD: {
+                          TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                          fpu_ADDD( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                          string="!ADDD!";}break;
+       case SUBS: {
+                          TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                          fpu_SUBS( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                         string="!SUBS!"; }break;
+       case SUBD: {
+                          TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                          fpu_SUBD( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                        string="!SUBD!";  }break;
+       case MULS: {
+                          TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                          fpu_MULS( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                          string="!MULS!";             }break;
+       case MULD: {
+                          TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                          fpu_MULD( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);                        
+                               string="!MULD!";        }break;
+       case DIVS: {
+                                TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                          fpu_DIVS( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                         string="!DIVS!"; }break;
+       case DIVD: {
+                               TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                               fpu_DIVD( PC, PC->BR[ REG_DEST], PC->BR[ REG_S2], PC->BR[ REG_S1], flag_REG_S2, flag_REG_S1);
+                         string="!DIVD!"; }break;
+       case EQS: {
+                         TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                         fpu_EQS( PC->BR[ REG_DEST], flag_REG_S1, flag_REG_S2);
+                         string=" !EQS!";}break;
+       case EQD: {
+                         TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                         fpu_EQD( PC->BR[ REG_DEST], flag_REG_S1, flag_REG_S2);
+                         string=" !EQD!";}break;
+       case LES: {
+                         TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                         fpu_LES( PC->BR[ REG_DEST], flag_REG_S1, flag_REG_S2);
+                         string=" !LES!";}break;
+       case LED: {
+                         TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                         fpu_LED( PC->BR[ REG_DEST], flag_REG_S1, flag_REG_S2);
+                         string=" !LED!";}break;
+       case LLS: {
+                         TesterS( PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                         fpu_LLS( PC->BR[ REG_DEST], flag_REG_S1, flag_REG_S2);
+                         string=" !LLS!";}break;
+       case LLD: {
+                         TesterD( PC, PC->BR[ REG_S1], PC->BR[ REG_S2], flag_REG_S1, flag_REG_S2);
+                         fpu_LLD( PC->BR[ REG_DEST], flag_REG_S1, flag_REG_S2);
+                         string=" !LLD!";}break;
+       case ABSS: {
+                         fpu_ABSS( PC->BR[ REG_DEST], PC->BR[ REG_S1]);
+                         string="!ABSS!";}break;
+       case ABSD: {
+                         fpu_ABSD( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1]);
+                         string="!ABSD!";}break;
+       case NGS: {
+                         fpu_NGS( PC->BR[ REG_DEST], PC->BR[ REG_S1]);
+                         string=" !NGS!";}break;
+       case NGD: {
+                         fpu_NGD( PC, PC->BR[ REG_DEST], PC->BR[ REG_S1]);
+                         string=" !NGD!";}break;
+       default: {}break;
+   }
+}
+
+
+void TesterS( char * A, char * B, Flag fA, Flag fB) {
+
+       int i;
+
+       for( i = 0; i < S_DEBUT_EXPOSANT; i++) {
+               fA[ s] = ( A[ i] == '1');
+               fB[ s] = ( B[ i] == '1');
+       }
+
+
+       fA[ e0] = fB[ e0] = fA[ eM] = fB[ eM] = 1;
+       fA[ eP] = fB[ eP] = 0;
+
+       for( ; i < S_DEBUT_MANTISSE; i++) {
+               if( A[ i] == '0') fA[ eM] = 0;
+               if( B[ i] == '0') fB[ eM] = 0;
+               if( A[ i] == '1') fA[ e0] = 0;
+               if( B[ i] == '1') fB[ e0] = 0;
+               if( fA[ eP] == fB[ eP]) {
+                       fA[ eP] = ( A[ i] > B[ i]);
+                       fB[ eP] = ( B[ i] > A[ i]);
+               }
+       }
+
+
+       fA[ m0] = fB[ m0] = 1;
+       fA[ mP] = fB[ mP] = 0;
+
+       for( ; i < TAILLE_MOT_MEMOIRE; i++) {
+               if( A[ i] == '1') fA[ m0] = 0;
+               if( B[ i] == '1') fB[ m0] = 0;
+               if( fA[ mP] == fB[ mP]) {
+                       fA[ mP] = ( A[ i] > B[ i]);
+                       fB[ mP] = ( B[ i] > A[ i]);
+               }
+       }
+}
+
+
+void TesterD( Machine * Pc, char * A, char * B, Flag fA, Flag fB) {
+
+       int i;
+
+       for( i = 0; i < D_DEBUT_EXPOSANT; i++) {
+               fA[ s] = ( A[ i] == '1');
+               fB[ s] = ( B[ i] == '1');
+       }
+
+
+
+       fA[ e0] = fB[ e0] = fA[ eM] = fB[ eM] = 1;
+       fA[ eP] = fB[ eP] = 0;
+
+       for( ; i < D_DEBUT_MANTISSE; i++) {
+               if( A[ i] == '0') fA[ eM] = 0;
+               if( B[ i] == '0') fB[ eM] = 0;
+               if( A[ i] == '1') fA[ e0] = 0;
+               if( B[ i] == '1') fB[ e0] = 0;
+               if( fA[ eP] == fB[ eP]) {
+                       fA[ eP] = ( A[ i] > B[ i]);
+                       fB[ eP] = ( B[ i] > A[ i]);
+               }
+       }
+
+
+       fA[ m0] = fB[ m0] = 1;
+       fA[ mP] = fB[ mP] = 0;
+
+       for( ; i < TAILLE_MOT_MEMOIRE; i++) {
+               if( A[ i] == '1') fA[ m0] = 0;
+               if( B[ i] == '1') fB[ m0] = 0;
+
+               if( fA[ mP] == fB[ mP]) {
+                       fA[ mP] = ( A[ i] > B[ i]);
+                       fB[ mP] = ( B[ i] > A[ i]);
+               }
+       }
+
+       ChargerRegReg( Pc, REG_S1, REG_DEST);
+       ChargerRegReg( Pc, REG_S1 +1, REG_S1);
+       ChargerRegReg( Pc, REG_DEST, REG_S1 + 1);
+
+       ChargerRegReg( Pc, REG_S2, REG_DEST);
+       ChargerRegReg( Pc, REG_S2 + 1, REG_S2);
+       ChargerRegReg( Pc, REG_DEST, REG_S2 + 1);
+
+       for( i = 0; i < TAILLE_MOT_MEMOIRE; i++) {
+               if( A[ i] == '1') fA[ m0] = 0;
+               if( B[ i] == '1') fB[ m0] = 0;
+               if( fA[ mP] == fB[ mP]) {
+                       fA[ mP] = ( A[ i] > B[ i]);
+                       fB[ mP] = ( B[ i] > A[ i]);
+               }
+       }
+
+       ChargerRegReg( Pc, REG_S1, REG_DEST);
+       ChargerRegReg( Pc, REG_S1 +1, REG_S1);
+       ChargerRegReg( Pc, REG_DEST, REG_S1 + 1);
+
+       ChargerRegReg( Pc, REG_S2, REG_DEST);
+       ChargerRegReg( Pc, REG_S2 + 1, REG_S2);
+       ChargerRegReg( Pc, REG_DEST, REG_S2 + 1);
+}
+
+
+void fpu_ADDS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) {
+
+       if( fA[ eM] == 1 && fA[ m0] == 0)
+               ChargerRegReg( Pc, REG_S1, REG_DEST);
+       else if( fB[ eM] == 1 && fB[ m0] == 0)
+               ChargerRegReg( Pc, REG_S2, REG_DEST);
+       else if( fA[ s] != fB[ s]) {
+
+               if( fA[ eP] == 1) {
+
+                       B[ 0] = ( B[ 0] == '0') + '0';
+                       fB[ s] = ( fB[ s] == 0);
+                       soustractionS( dest, A, B, fA, fB);
+
+               } else {
+
+                       A[ 0] = ( A[ 0] == '0') + '0';
+                       fA[ s] = ( fA[ s] == 0);
+                       soustractionS( dest, B, A, fB, fA);
+
+               }
+
+       } else {
+
+               if( fA[ eM] == 1 && fA[ m0] == 1)
+                       ChargerRegReg( Pc, REG_S1, REG_DEST);
+               else if( fB[ eM] == 1 && fB[ m0] == 1)
+                       ChargerRegReg( Pc, REG_S2, REG_DEST);
+               else if( fA[ e0] == 1 && fA[ m0] == 1)
+                       ChargerRegReg( Pc, REG_S2, REG_DEST);
+               else if( fB[ e0] == 1 && fB[ m0] == 1)
+                       ChargerRegReg( Pc, REG_S1, REG_DEST);
+               else {
+
+                       if( fA[ eP] == 1) {
+                               additionS( dest, A, B, fA, fB);
+                       } else {
+                               additionS( dest, B, A, fB, fA);
+                       }
+
+               }
+
+       }
+
+}
+
+void fpu_ADDD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) {
+
+       if( fA[ eM] == 1 && fA[ m0] == 0) {
+               ChargerRegReg( Pc, REG_S1, REG_DEST);
+               ChargerRegReg( Pc, REG_S1+1, REG_DEST+1);
+       } else if( fB[ eM] == 1 && fB[ m0] == 0) {
+               ChargerRegReg( Pc, REG_S2, REG_DEST);
+               ChargerRegReg( Pc, REG_S2+1, REG_DEST+1);
+       } else if( fA[ s] != fB[ s]) {
+
+               if( fA[ eP] == 1) {
+
+                       B[ 0] = ( B[ 0] == '0') + '0';
+                       fB[ s] = ( fB[ s] == 0);
+                       soustractionD( dest, Pc->BR[ REG_DEST + 1], A, Pc->BR[ REG_S1 + 1], B, Pc->BR[ REG_S2 + 1], fA, fB);
+
+               } else {
+
+                       A[ 0] = ( A[ 0] == '0') + '0';
+                       fA[ s] = ( fA[ s] == 0);
+                       soustractionD( dest, Pc->BR[ REG_DEST + 1], B, Pc->BR[ REG_S2 + 1], A, Pc->BR[ REG_S1 + 1], fB, fA);
+
+               }
+
+       } else {
+
+               if( fA[ eM] == 1 && fA[ m0] == 1) {
+                       ChargerRegReg( Pc, REG_S1, REG_DEST);
+                       ChargerRegReg( Pc, REG_S1+1, REG_DEST+1);
+               } else if( fB[ eM] == 1 && fB[ m0] == 1) {
+                       ChargerRegReg( Pc, REG_S2, REG_DEST);
+                       ChargerRegReg( Pc, REG_S2+1, REG_DEST+1);
+               } else if( fA[ e0] == 1 && fA[ m0] == 1) {
+                       ChargerRegReg( Pc, REG_S2, REG_DEST);
+                       ChargerRegReg( Pc, REG_S2+1, REG_DEST+1);
+               } else if( fB[ e0] == 1 && fB[ m0] == 1) {
+                       ChargerRegReg( Pc, REG_S1, REG_DEST);
+                       ChargerRegReg( Pc, REG_S1+1, REG_DEST+1);
+               } else {
+
+                       if( fA[ eP] == 1) {
+                               additionD( dest, Pc->BR[ REG_DEST + 1], A, Pc->BR[ REG_S1 + 1], B, Pc->BR[ REG_S2 + 1], fA, fB);
+                       } else {
+                               additionD( dest, Pc->BR[ REG_DEST + 1], B, Pc->BR[ REG_S2 + 1], A, Pc->BR[ REG_S1 + 1], fB, fA);
+                       }
+
+               }
+
+       }
+
+}
+
+void fpu_SUBS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) {
+
+       int i;
+
+       if( fA[ eM] == 1 && fA[ m0] == 0)
+               ChargerRegReg( Pc, REG_S1, REG_DEST);
+       else if( fB[ eM] == 1 && fB[ m0] == 0)
+               ChargerRegReg( Pc, REG_S2, REG_DEST);
+       else if( fA[ s] != fB[ s]) {
+
+               if( fA[ eP] == 1) {
+
+                       B[ 0] = ( B[ 0] == '0') + '0';
+                       fB[ s] = ( fB[ s] == 0);
+                       additionS( dest, A, B, fA, fB);
+
+               } else {
+
+                       A[ 0] = ( A[ 0] == '0') + '0';
+                       fA[ s] = ( fA[ s] == 0);
+                       additionS( dest, B, A, fB, fA);
+
+               }
+
+       } else {
+
+               if( fB[ eM] == 1 && fB[ m0 == 1]) {
+
+                       if( fA[ eM] == 1 && fA[ m0] == 1) {
+
+                               for( i = S_DEBUT_EXPOSANT; i <= S_DEBUT_MANTISSE; i++) {
+                                       dest[ i] = '1';
+                               }
+
+                       } else {
+                               ChargerRegReg( Pc, REG_S2, REG_DEST);
+                       }
+
+               } else if( fA[ eM] == 1 && fA[ m0] == 1) {
+                       ChargerRegReg( Pc, REG_S1, REG_DEST);
+                       dest[ 0] = ( A[ 0] == '0');
+               } else if( fB[ e0] == 1 && fB[ m0] == 1) {
+
+                       if( fA[ e0] == 1 && fA[ m0] == 1) {
+
+                               for( i = S_DEBUT_EXPOSANT; i <= S_DEBUT_MANTISSE; i++) {
+                                       dest[ i] = '1';
+                               }
+
+                       } else {
+                               ChargerRegReg( Pc, REG_S1, REG_DEST);
+                               dest[ 0] = ( A[ 0] == '0');
+                       }
+
+               } else if( fA[ e0] == 1 && fA[ m0] == 1) {
+                       ChargerRegReg( Pc, REG_S2, REG_DEST);
+               } else {
+
+                       if( fB[ eP] == 1) {
+                               soustractionS( dest, B, A, fB, fA);
+                       } else {
+                               soustractionS( dest, A, B, fA, fB);
+                               dest[0] = ( dest[0] == '0') + '0';
+                       }
+
+               }
+
+       }
+}
+
+
+void fpu_SUBD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) {
+
+       unsigned int mask;
+
+       int i;
+
+       Double a;
+
+       double doublea;
+       double doubleb;
+
+       doublea = convDouble(Pc->BR[ REG_S2], Pc->BR[ REG_S2 + 1]);
+       doubleb = convDouble(Pc->BR[ REG_S1], Pc->BR[ REG_S1 + 1]);
+
+       doublea -= doubleb;
+
+       a.reels = doublea;
+
+       mask = 1;
+       for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) {
+               if( (a.i[ 0] & mask) == 0) {
+                       dest[ i] = '0';
+               } else {
+                       dest[ i] = '1';
+               }
+               mask = mask << 1;
+
+       }
+       ChargerRegReg( Pc, REG_DEST, REG_DEST + 1);
+       mask = 1;
+       for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) {
+               if( (a.i[ 1] & mask) == 0) {
+                       dest[ i] = '0';
+               } else {
+                       dest[ i] = '1';
+               }
+               mask = mask << 1;
+
+       }
+}
+
+
+void fpu_MULS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB)
+{
+       MulS(Pc->BR[REG_S2],Pc->BR[REG_S1],Pc->BR[REG_DEST]);
+}
+
+
+void fpu_MULD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB)
+{
+       MulD(Pc->BR[REG_S2],Pc->BR[REG_S2+1],Pc->BR[REG_S1],Pc->BR[REG_S1+1],Pc->BR[REG_DEST],Pc->BR[REG_DEST+1]);// a*b
+}
+
+
+void fpu_DIVS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) {
+
+   DivS(Pc->BR[REG_S1],Pc->BR[REG_S2],Pc->BR[REG_DEST]);
+}
+
+
+void fpu_DIVD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB) {
+
+       unsigned int mask;
+
+       int i;
+
+       Double a;
+
+       double doublea;
+       double doubleb;
+
+       doublea = convDouble(Pc->BR[ REG_S2], Pc->BR[ REG_S2 + 1]);
+       doubleb = convDouble(Pc->BR[ REG_S1], Pc->BR[ REG_S1 + 1]);
+
+       doublea /= doubleb;
+
+       a.reels = doublea;
+
+       mask = 1;
+       for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) {
+               if( (a.i[ 0] & mask) == 0) {
+                       dest[ i] = '0';
+               } else {
+                       dest[ i] = '1';
+               }
+               mask = mask << 1;
+
+       }
+       ChargerRegReg( Pc, REG_DEST, REG_DEST + 1);
+       mask = 1;
+       for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) {
+               if( (a.i[ 1] & mask) == 0) {
+                       dest[ i] = '0';
+               } else {
+                       dest[ i] = '1';
+               }
+               mask = mask << 1;
+
+       }
+         doublea = convDouble(Pc->BR[ REG_DEST ], Pc->BR[ REG_DEST + 1]);
+       printf("%f\n", doublea);
+}
+
+
+void fpu_EQS( char * dest, Flag fA, Flag fB) {
+
+       int i;
+
+       for( i = 0; i < TAILLE_MOT_MEMOIRE - 1; i++) {
+               dest[ i] = '0';
+       }
+
+       if(    fA[ s] == fB[ s]
+               && fA[ eM] == 0
+               && fB[ eM] == 0
+               && fA[ eP] == fB[ eP]
+               && fA[ mP] == fB[ mP]
+               && ( fA[ e0] == 0 || ( fA[ e0] == 1 && fA[ m0]))
+               )
+       {
+               dest[ i] = '1';
+       } else {
+               dest[ i] = '0';
+       }
+}
+
+
+void fpu_EQD( char * dest, Flag fA, Flag fB) {
+
+       fpu_EQS( dest, fA, fB);
+
+}
+
+
+void fpu_LES( char * dest, Flag fA, Flag fB) {
+
+       int i;
+
+       for( i = 0; i < TAILLE_MOT_MEMOIRE - 1; i++) {
+               dest[ i] = '0';
+       }
+
+       if( ( fA[ eM] == 1 && fA[ m0] == 0) || ( fB[ eM] == 1 && fB[ m0] == 0)) {
+               dest[ i] = '0';
+       } else {
+
+               if( fA[ s] != fB[ s]) {
+                       if( fA[ s] == 1) dest[ i] = '1';
+                       else dest[ i] = '0';
+               } else {
+
+                       if( fA[ s] == 1) {
+
+                               if( fA[ eP] == 1) dest[ i] = '1';
+                               else if( fB[ eP] == 1) dest[ i] = '0';
+                               else if( fA[ mP] == 1) dest[ i] = '1';
+                               else if( fB[ mP] == 1) dest[ i] = '0';
+                               else dest[ i] = '1';
+
+                       } else {
+
+                               if( fA[ eP] == 1) dest[ i] = '0';
+                               else if( fB[ eP] == 1) dest[ i] = '1';
+                               else if( fA[ mP] == 1) dest[ i] = '0';
+                               else if( fB[ mP] == 1) dest[ i] = '1';
+                               else dest[ i] = '1';
+
+                       }
+               }
+
+       }
+}
+
+
+void fpu_LED( char * dest, Flag fA, Flag fB) {
+
+       fpu_LES(dest,fA,fB);
+
+}
+
+
+void fpu_LLS( char * dest, Flag fA, Flag fB) {
+
+       int i;
+
+       for( i = 0; i < TAILLE_MOT_MEMOIRE - 1; i++) {
+               dest[ i] = '0';
+       }
+
+       if( ( fA[ eM] == 1 && fA[ m0] == 0) || ( fB[ eM] == 1 && fB[ m0] == 0)) {
+               dest[ i] = '0';
+       } else {
+
+               if( fA[ s] != fB[ s]) {
+                       if( fA[ s] == 1) dest[ i] = '1';
+                       else dest[ i] = '0';
+               } else {
+
+                       if( fA[ s] == 1) {
+
+                               if( fA[ eP] == 1) dest[ i] = '1';
+                               else if( fB[ eP] == 1) dest[ i] = '0';
+                               else if( fA[ mP] == 1) dest[ i] = '1';
+                               else if( fB[ mP] == 1) dest[ i] = '0';
+                               else dest[ i] = '0';
+
+                       } else {
+
+                               if( fA[ eP] == 1) dest[ i] = '0';
+                               else if( fB[ eP] == 1) dest[ i] = '1';
+                               else if( fA[ mP] == 1) dest[ i] = '0';
+                               else if( fB[ mP] == 1) dest[ i] = '1';
+                               else dest[ i] = '0';
+
+                       }
+               }
+
+       }
+}
+
+
+void fpu_LLD( char * dest, Flag fA, Flag fB) {
+
+       fpu_LLS( dest, fA, fB);
+
+}
+
+
+void fpu_ABSS( char * dest, char * src1) {
+
+       int i;
+
+       for( i = 1; i < TAILLE_MOT_MEMOIRE; i++) {
+               dest[ i] = src1[ i];
+       }
+
+       dest[ 0] = '0';
+
+}
+
+
+void fpu_ABSD( Machine * Pc, char * dest, char * src1) {
+
+
+       int i;
+
+       for( i = 1; i < TAILLE_MOT_MEMOIRE; i++) {
+               dest[ i] = src1[ i];
+       }
+
+       dest[ 0] = '0';
+
+       ChargerRegReg( Pc, REG_S1 + 1, REG_DEST + 1);
+
+}
+
+
+void fpu_NGS( char * dest, char * src1) {
+
+       int i;
+
+       for( i = 1; i < TAILLE_MOT_MEMOIRE; i++) {
+               dest[ i] = src1[ i];
+       }
+
+       dest[ 0] = ( ( src1[ 0] == '0') + '0');
+
+}
+
+
+void fpu_NGD( Machine * Pc, char * dest, char * src1) {
+
+       int i;
+
+       for( i = 1; i < TAILLE_MOT_MEMOIRE; i++) {
+               dest[ i] = src1[ i];
+       }
+
+       dest[ 0] = ( ( src1[ 0] == '0') + '0');
+
+       ChargerRegReg( Pc, REG_S1 + 1, REG_DEST + 1);
+
+}
+
+
+void additionS( char * dest, char * A, char * B, Flag fA, Flag fB) {
+
+       unsigned short retenue,res,fictifres;
+       int puiss2 = 1;
+       int decale = 0;
+
+       int i;
+       int j;
+
+       dest[ 0] = fA[ s] + '0';
+
+       if( fB[ e0] == 1) {
+               B[ S_DEBUT_MANTISSE - 1] = '1';
+       }
+       if( fA[ e0] == 1) {
+               A[ S_DEBUT_MANTISSE - 1] = '1';
+       }
+
+       retenue = 0;
+       for( i = S_DEBUT_MANTISSE - 1; i >= S_DEBUT_EXPOSANT; i--) {
+               res = sous_bit( (unsigned short)(A[ i] - '0'), (unsigned short)(B[ i] - '0'), &retenue);
+               if( res == 1) {
+
+                       for( j = TAILLE_MOT_MEMOIRE - 1; j >= S_DEBUT_MANTISSE + puiss2; j--) {
+                               B[ j] = B[ j - puiss2];
+                       }
+                       if( fB[ e0] == 0 && decale == 0) {
+                               B[ j--] = '1';
+                               decale = 1;
+                       }
+                       for( ; j >= S_DEBUT_MANTISSE; j--) {
+                               B[ j] = '0';
+                       }
+               }
+
+               puiss2 *=2;
+       }
+
+
+       retenue = 0;
+       for( i = TAILLE_MOT_MEMOIRE - 1; i >= S_DEBUT_MANTISSE; i--) {
+               dest[ i] = add_bit( (unsigned short)(A[ i] - '0'), (unsigned short)(B[ i] - '0'), &retenue) + '0';
+       }
+
+       if( decale == 0) {
+               fictifres = add_bit( (unsigned short)(1 - fA[ e0]), (unsigned short)(1 - fB[ e0]), &retenue);
+       } else {
+               fictifres = add_bit( (unsigned short)(1 - fA[ e0]), 0, &retenue);
+       }
+
+       if( retenue == 1) {
+
+               unsigned short retenue2;
+
+               retenue2 = 0;
+               for( i = S_DEBUT_MANTISSE - 1; i >= S_DEBUT_EXPOSANT; i--) {
+                       dest[ i] = add_bit( (unsigned short)(A[ i] - '0'), (unsigned short)(i == S_DEBUT_MANTISSE - 1), &retenue2) + '0';
+               }
+               for( i = TAILLE_MOT_MEMOIRE - 1; i >= S_DEBUT_MANTISSE + 1; i--) {
+                       dest[ i] = dest[ i - 1];
+               }
+               dest[ i] = fictifres + '0';
+
+       } else if( fA[ e0] == 0 || fictifres == 1) {
+
+               for( i = S_DEBUT_MANTISSE - 1; i >= S_DEBUT_EXPOSANT; i--) {
+                       dest[ i] = A[ i];
+               }
+
+       } else {
+
+               for( i = S_DEBUT_MANTISSE - 1; i >= S_DEBUT_EXPOSANT; i--) {
+                       dest[ i] = '0';
+               }
+
+       }
+
+}
+
+void additionD( char * dest, char * dest1, char * A, char * B, char * A1, char * B1, Flag fA, Flag fB) {
+
+       unsigned short retenue,res,fictifres;
+       int puiss2 = 1;
+       int decale = 0;
+
+       char TabA[64];
+       char TabB[64];
+       char TabDest[64];
+       int i;
+       int j;
+
+       for( i = 0; i < 64; i++) {
+               if( i < 32) {
+                       TabA[ i] = A[ i];
+                       TabB[ i] = B[ i];
+               } else {
+                       TabA[ i] = A1[ i-32];
+                       TabB[ i] = B1[i-32];
+               }
+       }
+
+       TabDest[ 0] = fA[ s] + '0';
+
+       if( fB[ e0] == 1) {
+               TabB[ D_DEBUT_MANTISSE - 1] = '1';
+       }
+       if( fA[ e0] == 1) {
+               TabA[ D_DEBUT_MANTISSE - 1] = '1';
+       }
+
+       retenue = 0;
+       for( i = D_DEBUT_MANTISSE - 1; i >= D_DEBUT_EXPOSANT; i--) {
+               res = sous_bit( (unsigned short)(TabA[ i] - '0'), (unsigned short)(TabB[ i] - '0'), &retenue);
+               if( res == 1) {
+
+                       for( j = 2*TAILLE_MOT_MEMOIRE - 1; j >= D_DEBUT_MANTISSE + puiss2; j--) {
+                               TabB[ j] = TabB[ j - puiss2];
+                       }
+                       if( fB[ e0] == 0 && decale == 0) {
+                               TabB[ j--] = '1';
+                               decale = 1;
+                       }
+                       for( ; j >= D_DEBUT_MANTISSE; j--) {
+                               TabB[ j] = '0';
+                       }
+               }
+
+               puiss2 *=2;
+       }
+
+
+       retenue = 0;
+       for( i = 2*TAILLE_MOT_MEMOIRE - 1; i >= D_DEBUT_MANTISSE; i--) {
+               TabDest[ i] = add_bit( (unsigned short)(TabA[ i] - '0'), (unsigned short)(TabB[ i] - '0'), &retenue) + '0';
+       }
+
+       if( decale == 0) {
+               fictifres = add_bit( (unsigned short)(1 - fA[ e0]), (unsigned short)(1 - fB[ e0]), &retenue);
+       } else {
+               fictifres = add_bit( (unsigned short)(1 - fA[ e0]), 0, &retenue);
+       }
+
+       if( retenue == 1) {
+
+               unsigned short retenue2;
+
+               retenue2 = 0;
+               for( i = D_DEBUT_MANTISSE - 1; i >= D_DEBUT_EXPOSANT; i--) {
+                       TabDest[ i] = add_bit( (unsigned short)(A[ i] - '0'), (unsigned short)(i == D_DEBUT_MANTISSE - 1), &retenue2) + '0';
+               }
+               for( i = 2*TAILLE_MOT_MEMOIRE - 1; i >= D_DEBUT_MANTISSE + 1; i--) {
+                       TabDest[ i] = dest[ i - 1];
+               }
+               TabDest[ i] = fictifres + '0';
+
+       } else if( fA[ e0] == 0 || fictifres == 1) {
+
+               for( i = D_DEBUT_MANTISSE - 1; i >= D_DEBUT_EXPOSANT; i--) {
+                       TabDest[ i] = TabA[ i];
+               }
+
+       } else {
+
+               for( i = D_DEBUT_MANTISSE - 1; i >= D_DEBUT_EXPOSANT; i--) {
+                       TabDest[ i] = '0';
+               }
+
+       }
+
+       for( i = 0; i < 64; i++) {
+               if( i < 32)
+                       dest[ i] = TabDest[ i];
+               else
+                       dest1[ i - 32] = TabDest[ i];
+       }
+}
+
+void soustractionS( char * dest, char * A, char * B, Flag fA, Flag fB) {
+
+       unsigned short retenue,res,fictifres;
+       int puiss2 = 1;
+       int decale = 0;
+
+       int i;
+       int j;
+
+       int egale_a_un,fict,a;
+
+       if( fB[ e0] == 1) {
+               B[ S_DEBUT_MANTISSE - 1] = '1';
+       }
+       if( fA[ e0] == 1) {
+               A[ S_DEBUT_MANTISSE - 1] = '1';
+       }
+
+       retenue = 0;
+       for( i = S_DEBUT_MANTISSE - 1; i >= S_DEBUT_EXPOSANT; i--) {
+               res = sous_bit( (unsigned short)(A[ i] - '0'), (unsigned short)(B[ i] - '0'), &retenue);
+               if( res == 1) {
+
+                       for( j = TAILLE_MOT_MEMOIRE - 1; j >= S_DEBUT_MANTISSE + puiss2; j--) {
+                               B[ j] = B[ j - puiss2];
+                       }
+                       if( fB[ e0] == 0 && decale == 0) {
+                               B[ j--] = '1';
+                               decale = 1;
+                       }
+                       for( ; j >= S_DEBUT_MANTISSE; j--) {
+                               B[ j] = '0';
+                       }
+               }
+
+               puiss2 *=2;
+       }
+
+
+       retenue = 0;
+       for( i = TAILLE_MOT_MEMOIRE - 1; i >= S_DEBUT_MANTISSE; i--) {
+               dest[ i] = sous_bit( (unsigned short)(A[ i] - '0'), (unsigned short)(B[ i] - '0'), &retenue) + '0';
+       }
+
+
+       if (decale)
+               fict = sous_bit( (unsigned short)(1 - fA[e0]), 0, &retenue);
+       else
+               fict = sous_bit( (unsigned short)(1 - fA[e0]), (unsigned short)(1 - fB[e0]), &retenue);
+
+
+      egale_a_un = 0;
+               if (A[S_DEBUT_MANTISSE - 1] == '1') {
+                       egale_a_un = 1;
+                       for(i = S_DEBUT_EXPOSANT;i < S_DEBUT_MANTISSE - 1; i++)
+                               if (A[i] == '1')
+                                       egale_a_un = 0;
+               }
+
+               for(i = S_DEBUT_EXPOSANT; i < S_DEBUT_MANTISSE; i++)
+                       dest[i] = A[i];
+
+               while ( !(egale_a_un) && !(fict) )
+               {
+                       retenue = 0;
+                       fict = dest[S_DEBUT_MANTISSE] - '0';
+
+                       for(i = S_DEBUT_MANTISSE; i < TAILLE_MOT_MEMOIRE - 1; i++)
+                               dest[i] = dest[i+1];
+
+                       dest[TAILLE_MOT_MEMOIRE - 1] = '0';
+
+
+                       a = dest[S_DEBUT_MANTISSE - 1] - '0';
+                       dest[S_DEBUT_MANTISSE - 1] = '0' + sous_bit(a, 1, &retenue);
+
+                       for(i = S_DEBUT_MANTISSE - 2; i >= S_DEBUT_EXPOSANT; i--)
+                       {
+                               a = dest[i] - '0';
+                               dest[i] = '0' + sous_bit(a, 0, &retenue);
+                       }
+
+         egale_a_un = 0;
+                       if( dest[S_DEBUT_MANTISSE - 1] == '1') {
+                egale_a_un = 1;
+                               for(i = S_DEBUT_EXPOSANT;i < S_DEBUT_MANTISSE - 1; i++)
+                                       if ( dest[i] == '1' )
+                                               egale_a_un = 0;
+                       }
+               }
+
+               if( !(fict))
+                       for(i = S_DEBUT_EXPOSANT;i < S_DEBUT_MANTISSE; i++)
+                               dest[i] = '0';
+
+               dest[0] = A[0];
+
+}
+
+
+void soustractionD(char * dest, char * dest1, char * A, char * A1, char * B, char * B1, Flag fA, Flag fB)
+{
+       int i, j;
+       unsigned short retenu = 0, a, b;
+       int fict;
+       int decalage = 0;       // indique s'il y a deja eu decalage
+       int egale_a_un;
+
+       char TabA[ 64];
+       char TabB[ 64];
+       char TabDest[ 64];
+
+       for( i = 0; i < 64; i++) {
+               if( i < 32) {
+                       TabA[ i] = A[ i];
+                       TabB[ i] = B[ i];
+               } else {
+                       TabA[ i] = A1[ i-32];
+                       TabB[ i] = B1[i-32];
+               }
+       }
+
+       i=0;
+       while( (i < 2*TAILLE_MOT_MEMOIRE) && ( TabA[i] == TabB[i]) )
+               i++;
+
+       if (i == 2*TAILLE_MOT_MEMOIRE)
+       {
+               for(i = 0; i < 2*TAILLE_MOT_MEMOIRE; i++)
+                       TabDest[i] = '0';
+       }
+       else
+       {
+               if (fB[e0] - fA[e0])
+                       TabB[ D_DEBUT_MANTISSE - 1] = '1';
+
+//--------------------------decalage des bits de la mantisse de B------------------------//
+               for(i = D_DEBUT_MANTISSE - 1; i >= D_DEBUT_EXPOSANT; i--)
+               {
+                       a = TabA[i] - '0';
+                       b = TabB[i] - '0';
+                       if ( sous_bit(a, b, &retenu) )
+                       {       for(j= 2*TAILLE_MOT_MEMOIRE - (D_DEBUT_MANTISSE - i) - 1; j >= D_DEBUT_MANTISSE; j--)
+                                       TabB[j + D_DEBUT_MANTISSE - i] = TabB[j];
+                               for(j= D_DEBUT_MANTISSE + (D_DEBUT_MANTISSE - i) -1; j >= D_DEBUT_MANTISSE; j--)
+                                       TabB[j] = '0';
+                       }
+                       if( !(decalage))
+                               TabB[ D_DEBUT_MANTISSE + (D_DEBUT_MANTISSE - i) -1] = (fB[e0] == 0) + '0';
+                       decalage = 1;
+               }
+
+
+//---------------soustraction bit a bit des mantisses des mots memoires A et B-------------//
+               retenu =0;
+               for(i = 2*TAILLE_MOT_MEMOIRE - 1; i >= D_DEBUT_MANTISSE; i--)
+               {
+                       a = TabA[i] - '0';
+                       b = TabB[i] - '0';
+                       TabDest[i] = '0' + sous_bit(a, b, &retenu);
+               }
+
+
+//----------------decalage de la mantisse du mot memoire DEST------------------------------//
+       if (decalage)
+               fict = sous_bit( (unsigned short)(1 - fA[e0]), 0, &retenu);
+       else
+               fict = sous_bit( (unsigned short)(1 - fA[e0]), (unsigned short)(1 - fB[e0]), &retenu);
+
+               if ( TabA[ D_DEBUT_MANTISSE - 1])
+                       for(i = D_DEBUT_EXPOSANT;i < D_DEBUT_MANTISSE - 1; i++)
+                               if (1 - ( TabA[i] - '0') )
+                                       egale_a_un = 0;
+
+               for(i = D_DEBUT_EXPOSANT; i < D_DEBUT_MANTISSE; i++)
+                       TabDest[i] = TabA[i];
+
+               while ( !(egale_a_un) && !(fict) )
+               {
+                       retenu = 0;
+                       fict = TabDest[ D_DEBUT_MANTISSE] - '0';
+                       for(i = D_DEBUT_MANTISSE; i < 2*TAILLE_MOT_MEMOIRE - 1; i++)
+                               TabDest[i] = TabDest[i+1];
+
+                       TabDest[ 2*TAILLE_MOT_MEMOIRE - 1] = '0';
+
+                       a = TabDest[ D_DEBUT_MANTISSE - 1] - '0';
+                       TabDest[ D_DEBUT_MANTISSE - 1] = '0' + sous_bit(a, 1, &retenu);
+
+                       for(i = D_DEBUT_MANTISSE - 2; i >= D_DEBUT_EXPOSANT; i--)
+                       {
+                               a = TabDest[i] - '0';
+                               TabDest[i] = '0' + sous_bit(a, 0, &retenu);
+                       }
+
+
+                       if( TabDest[D_DEBUT_MANTISSE - 1])
+                               for(i = D_DEBUT_EXPOSANT;i < D_DEBUT_MANTISSE - 1; i++)
+                                       if (1- ( TabDest[i] - '0') )
+                                               egale_a_un = 0;
+               }
+
+               if( !(fict))
+                       for(i = D_DEBUT_EXPOSANT;i < D_DEBUT_MANTISSE; i++)
+                               TabDest[i] = '0';
+
+//-----------------------------copie du signe du mot memoire--------------------------------//
+               TabDest[0] = TabA[0];
+
+       }
+
+       for( i = 0; i < 64; i++) {
+               if( i < 32)
+                       dest[ i] = TabDest[ i];
+               else
+                       dest1[ i - 32] = TabDest[ i];
+       }
+}
+
+
+unsigned short add_bit( unsigned short a, unsigned short b, unsigned short * r) {
+
+       unsigned short res;
+       unsigned short un = 1;
+
+       res = a^b^(*r);
+       *r = (a&(b|*r))|(((~a)&un)&b&*r);
+
+       return res;
+}
+
+
+unsigned short sous_bit( unsigned short a, unsigned short b, unsigned short * r) {
+
+       unsigned short res;
+       unsigned short un = 1;
+
+       res = a^b^(*r);
+       *r = (((~a)&un)&(b|*r))|(a&b&*r);
+
+       return res;
+}
+
+
+float convFloat( char * f) {
+
+       Float fl;
+       unsigned int mask = 1;
+       int i;
+       fl.i = 0;
+       for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) {
+               if( f[ i] == '1') {
+                       fl.i = fl.i | mask;
+               }
+               mask = mask << 1;
+       }
+
+       return fl.reels;
+}
+
+double convDouble( char * f1, char * f2) {
+
+       Double fl;
+       unsigned int mask = 1;
+       int i;
+       fl.i[0] = 0;
+       fl.i[1] = 0;
+
+       for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) {
+               if( f1[ i] == '1') {
+                       fl.i[1] = fl.i[1] | mask;
+               }
+               if( f2[ i] == '1') {
+                       fl.i[0] = fl.i[0] | mask;
+               }
+
+               mask = mask << 1;
+       }
+
+   printf("\n%f\n",fl.reels);
+
+       return fl.reels;
+}
+
+
+char * FloatToBin( float f) {
+
+       Float fl;
+       int i;
+       unsigned int mask;
+       char * res = ( char *)malloc( TAILLE_MOT_MEMOIRE * sizeof( char) );
+
+       fl.reels = f;
+
+       mask = 1;
+       for( i = TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) {
+               if( (fl.i & mask) == 0) {
+                       res[ i] = '0';
+               } else {
+                       res[ i] = '1';
+               }
+               mask = mask << 1;
+       }
+
+       return res;
+}
+
+char * DoubleToBin( double d) {
+
+       Double fl;
+       int i;
+       unsigned int mask;
+       char * res = ( char *)malloc( 2 * TAILLE_MOT_MEMOIRE * sizeof( char) );
+
+       fl.reels = d;
+
+       mask = 1;
+       for( i = 2 * TAILLE_MOT_MEMOIRE - 1; i >= 0; i--) {
+               if( i < TAILLE_MOT_MEMOIRE) {
+                       if( (fl.i[ 1] & mask) == 0) {
+                               res[ i] = '0';
+                       } else {
+                               res[ i] = '1';
+                       }
+               } else {
+                       if( (fl.i[ 0] & mask) == 0) {
+                               res[ i] = '0';
+                       } else {
+                               res[ i] = '1';
+                       }
+               }
+               mask = mask << 1;
+       }
+
+       return res;
+}
+

diff --git a/vexec/fpu.h b/vexec/fpu.h
new file mode 100755 (executable)
index 0000000..10ac83b
--- /dev/null
+++ b/vexec/fpu.h
@@ -0,0 +1,71 @@
+#ifndef _FPU_
+#define _FPU_
+
+#define NB_FLAG 6
+#define S_DEBUT_EXPOSANT 1
+#define D_DEBUT_EXPOSANT 1
+#define S_DEBUT_MANTISSE 9
+#define D_DEBUT_MANTISSE 12
+#define S_TAILLE_MANTISSE 23
+#define D_TAILLE_MANTISSE 52
+#define TAILLE_FLOAT 32
+#include "machine.h"
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef int Flag[ NB_FLAG];
+
+enum Drapeaux{ s, e0, eM, eP, m0, mP};
+
+typedef union {
+       float reels;
+       unsigned int i;
+} Float;
+
+typedef union {
+       double reels;
+       unsigned int i[2];
+} Double;
+
+void FPU( Machine * PC, int opp);
+
+void TesterS( char * A, char * B, Flag fA, Flag fB);
+void TesterD( Machine * Pc, char * A, char * B, Flag fA, Flag fB);
+
+void fpu_ADDS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB);
+void fpu_ADDD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB);
+void fpu_SUBS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB);
+void fpu_SUBD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB);
+void fpu_MULS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB);
+void fpu_MULD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB);
+void fpu_DIVS( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB);
+void fpu_DIVD( Machine * Pc, char * dest, char * A, char * B, Flag fA, Flag fB);
+void fpu_EQS( char * dest, Flag fA, Flag fB);
+void fpu_EQD( char * dest, Flag fA, Flag fB);
+void fpu_LES( char * dest, Flag fA, Flag fB);
+void fpu_LED( char * dest, Flag fA, Flag fB);
+void fpu_LLS( char * dest, Flag fA, Flag fB);
+void fpu_LLD( char * dest, Flag fA, Flag fB);
+void fpu_ABSS( char * dest, char * src1);
+void fpu_ABSD( Machine * Pc, char * dest, char * src1);
+void fpu_NGS( char * dest, char * src1);
+void fpu_NGD( Machine * Pc, char * dest, char * src1);
+
+void additionS( char * dest, char * A, char * B, Flag fA, Flag fB);
+void additionD( char * dest, char * dest1, char * A, char * A1, char * B, char * B1, Flag fA, Flag fB);
+void soustractionS( char * dest, char * A, char * B, Flag fA, Flag fB);
+void soustractionD( char * dest, char * dest1, char * A, char * A1, char * B, char * B1, Flag fA, Flag fB);
+
+unsigned short add_bit( unsigned short a, unsigned short b, unsigned short * r);
+unsigned short sous_bit( unsigned short a, unsigned short b, unsigned short * r);
+
+float convFloat( char * );
+double convDouble(char *,char *);
+char * FloatToBin( float f);
+char * DoubleToBin( double d);
+#endif
+
+

diff --git a/vexec/lisezmoi.txt b/vexec/lisezmoi.txt
new file mode 100755 (executable)
index 0000000..c73ae94
--- /dev/null
+++ b/vexec/lisezmoi.txt
@@ -0,0 +1,8 @@
+pour compiler :\r
+gcc -o vexec muldiv.c fpu.c machine.c main.c\r
+\r
+pour exécuter :\r
+vexec [nom_fichier]\r
+\r
+remarque :\r
+le fichier logengine.log contiendra une trace de l'exécution après avoir lancé la commande.
\ No newline at end of file

diff --git a/vexec/logengine.log b/vexec/logengine.log
new file mode 100644 (file)
index 0000000..eba8a73
--- /dev/null
+++ b/vexec/logengine.log
@@ -0,0 +1,26 @@
+
+Chargement Instruction :
+Mot 128 : Faute de cache
+Copie Mem[128] vers Cac[1]
+Incrémentation du compteur Ordinal :
+Décodage de l'Instruction :
+Instruction Décodée : Code 46
+Exécution de l'instruction :
+Mot 0 : Faute de cache
+Copie Mem[0] vers Cac[0]
+Mot 1 : Faute de cache
+Copie Mem[1] vers Cac[3]
+Mot 2 : Faute de cache
+Copie Mem[2] vers Cac[5]
+Mot 3 : Faute de cache
+Copie Mem[3] vers Cac[7]
+Rangement des résultats :
+
+Chargement Instruction :
+Mot 129 : Faute de cache
+Copie Mem[129] vers Cac[2]
+Incrémentation du compteur Ordinal :
+Décodage de l'Instruction :
+Instruction Décodée : Code 32
+Exécution de l'instruction :
+Rangement des résultats :

diff --git a/vexec/machine.c b/vexec/machine.c
new file mode 100755 (executable)
index 0000000..5f8f1ae
--- /dev/null
+++ b/vexec/machine.c
@@ -0,0 +1,2020 @@
+/***************************************************************************
+                          machine.c
+       
+       version 2003 !!!
+
+ ***************************************************************************/
+#include  "machine.h"
+#include "fpu.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+FILE *fp;
+
+//***Initialisation de la mémoire
+Memoire InitMemoire(int nbcase)
+{
+       int i;
+       Memoire M= (char**) malloc (nbcase*sizeof(char *)); //***mémoire de nbcases cases
+       for(i=0;i<nbcase;i++)
+               M[i]=(char *) malloc (TAILLE_MOT_MEMOIRE*sizeof(char)); //***allocation des mots mémoire
+       return M;
+}
+
+//***Initialisation des registres
+BancRegistre InitBancRegistre(int nbreg)
+{
+       int i;
+       BancRegistre R= (char**) malloc (nbreg*sizeof(char *)); //***banc de nbreg registres
+       for(i=0;i<nbreg;i++)
+               R[i]=(char *) malloc (TAILLE_REGISTRE+1*sizeof(char));//***allocation des registres
+       return R;
+}
+
+//************************************************************************************************
+//***Initialisation du cache
+Cache InitCache(int nblignes)
+{
+       int i;
+       Cache C = (char**) malloc (nblignes*sizeof(char *)); //***banc de nbreg registres
+       for(i=0;i<nblignes;i++)
+               C[i]=(char *) malloc (TAILLE_LIGNE_CACHE+1*sizeof(char));//***allocation des registres
+       return C;
+}
+//************************************************************************************************
+
+//***Initialisation de la machine
+Machine *InitMachine(int nbcasemem,int nbreg, int nbligcache)
+{
+       char *add,*add2;
+       int i,j;
+       Machine *mac= (Machine *) malloc (sizeof (Machine));//***machine = memoire(MP) + registres(BR)
+       mac->MP=InitMemoire(nbcasemem);//***allocation de la mémoire
+       mac->BR=InitBancRegistre(nbreg);//***allocation des registres
+//************************************************************************************************
+       mac->CA=InitCache(nbligcache);          //***allocation du cache
+//************************************************************************************************
+
+       //***initialisation des registres
+       add=IntToBinString(ADD_INSTR,TAILLE_REGISTRE);
+       add2=IntToBinString(TAILLE_MEMOIRE,TAILLE_REGISTRE);
+
+       for(i=0;i<REG_POINTEUR;i++)
+               for(j=0;j<TAILLE_REGISTRE;j++)
+                       mac->BR[i][j]='0';
+
+       for(i=0;i<TAILLE_REGISTRE;i++)
+       {
+               mac->BR[REG_ADD_INSTR][i]=add[i];//***met ADD_INSTR dans le registre REG_ADD_INSTR
+               mac->BR[REG_POINTEUR][i]=add2[i];//***met TAILLE_MEMOIRE dans le registre REG_POINTEUR
+               mac->BR[REG_INSTR][i]='0';//***initialise le registre d'instruction REG_INSTR
+       }
+       free(add);//***libère la case mémoire pointée par add
+       free(add2);     //***libère la case mémoire pointée par add2
+
+//************************************************************************************************
+       //***initialisation du cache
+       for(i=0;i<LIGNES_CACHE;i++)
+               for(j=0;j<TAILLE_LIGNE_CACHE;j++)
+                       mac->CA[i][j]='0';
+//************************************************************************************************
+       //***initialisation de la MP
+       for(i=0;i<TAILLE_MEMOIRE;i++)
+               for(j=0;j<TAILLE_MOT_MEMOIRE;j++)
+                       mac->MP[i][j]='0';
+//************************************************************************************************
+
+       return mac;
+}
+
+//***Charge un programme
+int ChargerProg(Machine *Pc,char *Nom)
+{
+       FILE *fps;
+       int nbinstr;//nmobre d'instruction du fichier final
+       char *temp=(char *) malloc (TAILLE_ADD*sizeof(char));
+//************************************************************************************************
+       if ((fps=fopen(Nom,"r"))==NULL)//***ouvre le fichier 'Nom'
+       {
+               printf("Erreur fichier invalide");
+               return (-1);
+       }
+//************************************************************************************************
+       else
+       {
+               fscanf(fps,"%s\n",temp);//***lit une ligne du programme
+               nbinstr=BinStringToInt(temp);//***convertit l'instruction machine en code
+               free(temp);//***libère la case mémoire pointée par temp : du travail propre :-)
+               ChargerInstr(Pc,fps,nbinstr);//***charge les instructions
+               ChargerVar(Pc,fps);//***charge les variables
+       }
+       fclose(fps);//***ferme le fichier du programme
+//************************************************************************************************
+       return 1;
+//************************************************************************************************
+}
+
+//***charge les instructions du programme
+void ChargerInstr(Machine *Pc,FILE *fps,int nbinstr)
+{
+       int i;
+       char *instruction=(char *) malloc (MAX_STRING*sizeof(char));
+
+       printf("Chargement des instructions\n");
+
+       for(i=ADD_INSTR;i<ADD_INSTR+nbinstr;i++)
+       {
+               int j;
+               int tailleinstr;
+               fscanf(fps,"%s\n",instruction);//***lit une ligne du fichier
+               tailleinstr=strlen(instruction);//***calcule la taille de la ligne
+
+               for(j=0;j<tailleinstr;j++)
+                       Pc->MP[i][j]=instruction[j];//***charge l'instruction en MP
+
+               for(;j<TAILLE_MOT_MEMOIRE;j++)
+                       Pc->MP[i][j]='0';//***remplit la fin du mot mémoire de '0'
+
+
+               printf("%4d %s\n",i,Pc->MP[i]);//***affiche l'instruction lue
+
+   }
+       free(instruction);//***libère la case mémoire pointée par instruction
+}
+
+//***charge les variables
+void ChargerVar(Machine *Pc,FILE *fps)
+{
+       int AddVar=ADD_SEG;
+
+       printf("Chargement des Variables\n");
+
+       char *variable=(char *) malloc (MAX_STRING*sizeof(char));
+       while (!feof(fps))
+       {
+               int j;
+               int taillevar;
+               fscanf(fps,"%s\n",variable);//***lit une ligne du fichier
+               taillevar=strlen(variable);//***calcule la taille de la ligne
+
+               for(j=0;j<taillevar;j++)
+                       Pc->MP[AddVar][j]=variable[j];//***charge la variable en MP
+
+               for(;j<TAILLE_MOT_MEMOIRE;j++)
+                       Pc->MP[AddVar][j]='0';//***remplit la fin du mot mémoire de '0'
+
+               printf("%4d %s\n",AddVar,Pc->MP[AddVar]);
+
+               AddVar++;//***incrémente le "pointeur" d'adresse d'instruction
+       }
+       free(variable); //***libère ...
+}
+
+//***Comvertit une chaîne binaire en int
+int BinStringToInt(char *Addr)
+{
+       int taille=strlen(Addr);
+       int i,res=0,puiss=1;
+       for(i=taille-1;0<=i;i--)
+       {
+               res+=(Addr[i]-'0')*puiss;
+               puiss*=2;
+       }
+       return res;
+}
+
+//***Convertit un int en Chaîne binaire de taille "taille"
+char *IntToBinString(int n,int taille)
+{
+       int i;
+       char *adresse=(char *) malloc ((taille+1)*sizeof(char));
+       for( i=0;i<taille;i++)
+               adresse[i]='0';
+       i=taille-1;
+       while (n>0)
+       {
+               if ((n%2)==0)
+                       adresse[i]='0';
+               else
+                       adresse[i]='1';
+               n=n/2;
+               i--;
+       }
+       adresse[taille]='\0';
+       return adresse;
+}
+
+
+
+//************************************************************************************************
+//*** Enregistre un mot contenu dans une ligne de cache dans la mémoire principale
+int Anciennete(Machine *Pc, int lignecache)
+{
+       int anciennete = 0, i, exp=1;
+
+       for (i=0 ; i<TAILLE_ANCIENNETE ; i++)
+       {
+               if (Pc->CA[lignecache][DEB_ANCIENNETE] == '1')
+                       anciennete+=exp;
+                       exp*=2;
+       }
+
+       return anciennete;
+}
+//************************************************************************************************
+
+
+
+//************************************************************************************************
+//*** Cherche un mot de la mémoire principale dans le cache
+int ChercherMot(Machine *Pc, int adresse)
+{
+       int i=LIGNES_PAR_BLOC, j, lignecache=-1, bloc, etiquette;
+       char *index = (char *) malloc ((TAILLE_INDEX+1)*sizeof(char));
+
+       bloc = adresse % BLOCS_CACHE;
+       etiquette = adresse / BLOCS_CACHE;
+
+       while ((lignecache == -1) && (i>0))
+       {
+               //*** vérifie si un mot est présent à la ligne du cache
+               if (Pc->CA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_VALID] == '1')
+               {
+                       //recopie de l'étiquette de la ligne de cache
+                       for (j=0 ; j<TAILLE_INDEX ; j++)
+                               index[j] = Pc->CA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_INDEX+j];
+                       index[TAILLE_INDEX]='\0';
+
+                       //*** comparaison de l'étiquette
+                       if (BinStringToInt(index) == etiquette)
+                       {
+                               //*** c'est le bon mot !
+                               lignecache = bloc*LIGNES_PAR_BLOC + i - 1;
+                               break;
+                       }
+               }
+               i--;
+       }
+
+       free(index);
+       return lignecache;
+}
+//************************************************************************************************
+
+
+
+//************************************************************************************************
+//*** Enregistre un mot contenu dans une ligne de cache dans la mémoire principale
+void ChargerCacMem(Machine *Pc, int lignecache,int adresse)
+{
+       int i;
+
+       for(i=0;i<TAILLE_MOT_MEMOIRE;i++)
+               Pc->MP[adresse][i]=Pc->CA[lignecache][DEB_MOT+i];//***copie le contenu de regs dans regd
+
+       fprintf(fp,"Copie Cac%3d vers Mem%3d \n", lignecache,adresse);
+
+}
+//************************************************************************************************
+
+
+
+//************************************************************************************************
+//*** Charge de Mp vers le cache
+//*** Cette fonction n'est appelée QUE si le mot n'est pas déjà en cache !!!!
+//*** On procède donc au remplacement automatiquement !
+int ChargerMemCac(Machine *Pc,int adresse)
+{
+       int i=LIGNES_PAR_BLOC, lignecache=-1, bloc, etiquette=0, etiquette2=0, anciennete = -1, j;
+       char *etiq = NULL;
+
+       bloc = adresse % BLOCS_CACHE;
+       etiquette = adresse / BLOCS_CACHE;
+
+       //*** recherche d'une ligne libre dans le bloc
+       while ((lignecache == -1) && (i>0))
+       {
+               if (Pc->CA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_VALID] == '0')
+                       lignecache = bloc*LIGNES_PAR_BLOC + i - 1;
+
+               //*** augmentation de l'ancienneté
+               for (j=0 ; j<TAILLE_ANCIENNETE - 1 ; j++)
+                       if (Pc->CA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_ANCIENNETE + j] == '0')
+                               Pc->CA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_ANCIENNETE + j] = '1';
+
+               if (Pc->CA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_ANCIENNETE+TAILLE_ANCIENNETE - 1] == '0')
+                               Pc->CA[bloc*LIGNES_PAR_BLOC + i - 1][DEB_ANCIENNETE+TAILLE_ANCIENNETE - 1] = '1';
+
+               i--;
+       }
+
+       //*** teste si il y avait une ligne de vide
+       if (lignecache == -1)
+       {
+               //*** aucune ligne n'était vide : il faut en remplacer une !
+               printf("Remplacement d'une ligne\n");
+               fprintf(fp,"Remplacement d'une ligne\n");
+
+               for (i=0 ; i<LIGNES_PAR_BLOC ; i++)
+               {
+                       //*** on regarde l'ancienneté pour voir si la ligne est la plus vieille du bloc
+                       if (Anciennete(Pc,bloc*LIGNES_PAR_BLOC + i) > anciennete)
+                       {
+                               //*** cette ligne est la plus vieille ==> on mémorise le n° de ligne
+                               lignecache = bloc*LIGNES_PAR_BLOC + i;
+                               anciennete = Anciennete(Pc,bloc*LIGNES_PAR_BLOC + i);
+                       }
+               }
+
+               //*** le mot le plus ancien se trouve à la ligne lignecache
+
+               //*** enregistrement du mot dans la mémoire principale si le bit de modif est 1
+               if (Pc->CA[lignecache][DEB_MODIF] == '1')
+               {
+                       j=1;
+                       etiquette2 = 0;
+                       for (i=0 ; i<TAILLE_INDEX ; i++)
+                       {
+                               if (Pc->CA[lignecache][DEB_INDEX + TAILLE_INDEX - i - 1] == '1')
+                                       etiquette2 += j;
+                               j *= 2;
+                       }
+
+                       ChargerCacMem(Pc, lignecache, etiquette2*BLOCS_CACHE + (lignecache/LIGNES_PAR_BLOC));
+               }
+               //*** remplacement du mot mémoire
+
+       }
+
+       //copie du mot mémoire
+       for(i=0;i<TAILLE_MOT_MEMOIRE;i++)
+               Pc->CA[lignecache][DEB_MOT+i]=Pc->MP[adresse][i];//***copie le mot mémoire dans la ligne de cache lignecache
+
+       //copie de l'index
+       etiq=IntToBinString(etiquette,TAILLE_INDEX);
+
+       for(i=0;i<TAILLE_INDEX;i++)
+               Pc->CA[lignecache][DEB_INDEX+i]=etiq[i];
+
+       //*** initialise les bits d'ancienneté, de validité et de modification
+       for (i=0 ; i<TAILLE_ANCIENNETE ; i++)
+               Pc->CA[lignecache][DEB_ANCIENNETE+i]='0';
+       Pc->CA[lignecache][DEB_MODIF]='0';
+       Pc->CA[lignecache][DEB_VALID]='1';
+
+
+       fprintf(fp,"Copie Mem[%d] vers Cac[%d]\n",adresse,lignecache);
+       printf("Copie Mem[%d] vers Cac[%d]\n",adresse,lignecache);
+
+       if (etiq != NULL)
+               free(etiq);
+
+       return lignecache;
+
+}
+//************************************************************************************************
+
+
+//************************************************************************************************
+//*** Charge de Mp vers Registre en prenant en priorité dans le cache
+void ChargerMemReg(Machine *Pc,int adresse,int numreg)//Charge de Mp vers Registre
+{
+       int i, lignecache;
+
+       //*** teste si le mot est en cache ou pas
+       if ((lignecache = ChercherMot(Pc, adresse)) == -1)
+       {
+               //*** le mot n'était pas dans le cache : FAUTE DE CACHE !!!
+               //*** il faut l'y mettre et charger le mot dans le registre
+               printf("Mot %d : Faute de cache\n", adresse);
+               fprintf(fp,"Mot %d : Faute de cache\n", adresse);
+
+               lignecache = ChargerMemCac(Pc, adresse);
+       }
+       else
+       {
+               printf("Mot %d : En cache\n", adresse);
+               fprintf(fp,"Mot %d : En cache\n", adresse);
+       }
+
+       //*** chargement dans le registre
+       for(i=0;i<TAILLE_REGISTRE;i++)
+               Pc->BR[numreg][i]=Pc->CA[lignecache][DEB_MOT+i];//***copie le mot de la ligne de CA lignecache dans le registre numreg
+
+       //fprintf(fp,"Copie Mem[%d] vers Reg[%d]\n",adresse,numreg);
+       printf("Copie Mem[%d] vers Reg[%d]\n",adresse,numreg);
+}
+//************************************************************************************************
+
+
+
+//************************************************************************************************
+//*** Enregistrement de Registre dans la mémoire principale
+//*** si le mot est en cache on enregistre dans le cache et pas dans la MP
+void ChargerRegMem(Machine *Pc,int numreg,int adresse)
+{
+       int i, lignecache;
+
+       if ((lignecache = ChercherMot(Pc, adresse)) == -1)
+       {
+               //*** faute de cache !
+               //*** chargement du mot en cache
+               printf("Mot %d : Faute de cache à l'enregistrement\n", adresse);
+               fprintf(fp,"Mot %d : Faute de cache à l'enregistrement\n", adresse);
+
+               lignecache = ChargerMemCac(Pc, adresse);
+       }
+       else
+       {
+               //*** le mot est à la ligne lignecache du cache
+               fprintf(fp,"Mot %d : En cache à l'enregistrement\n", adresse);
+               printf("Mot %d : En cache à l'enregistrement\n", adresse);
+       }
+
+       //*** enregistrement du mot
+       for(i=0;i<TAILLE_MOT_MEMOIRE;i++)
+               Pc->CA[lignecache][DEB_MOT+i]=Pc->BR[numreg][i];//***copie le registre numreg dans la ligne de cache lignecache
+       //*** mise à 1 du bit de modification
+       Pc->CA[lignecache][DEB_MODIF]='1';
+
+       //fprintf(fp,"Copie Reg[%d] vers Mem[%d]\n",numreg,adresse);
+       printf("Copie Reg[%d] vers Mem[%d]\n",numreg,adresse);
+}
+//************************************************************************************************
+
+
+
+//***copie un registre dans un autre
+void ChargerRegReg(Machine *Pc,int regs,int regd)
+{
+       int i;
+
+       for(i=0;i<TAILLE_REGISTRE;i++)
+               Pc->BR[regd][i]=Pc->BR[regs][i];//***copie le contenu de regs dans regd
+
+       //fprintf(fp,"Copie Reg[%d] vers Reg[%d] \n",regs,regd);
+       //printf("Copie Reg[%d] vers Reg[%d] \n",regs,regd);
+}
+
+
+//************************************************************************************************
+//************************************************************************************************
+//***lance la machine ...
+
+void StartEngine(Machine *Pc)
+{
+       int Code, typeres=RES_AUCUN;
+       int Erreur = 0;
+       char *string=(char *) malloc (MAX_STRING*sizeof(char));
+       char *s1=(char *) malloc (MAX_STRING*sizeof(char));
+       char *s2=(char *) malloc (MAX_STRING*sizeof(char));
+       fp=fopen("logengine.log","w");                                                                                  //*** ouvre le fichier logengine.log en écriture
+       do
+       {
+               //*** ETAGE 1
+               fprintf(fp,"\nChargement Instruction :\n");
+               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_ADD_INSTR]),REG_INSTR);      //***chargement de l'instruction
+
+               fprintf(fp,"Incrémentation du compteur Ordinal :\n");
+               Incrementer(Pc,REG_ADD_INSTR);                                                  //***Incrémentation du compteur ordinal
+
+               //*** ETAGE 2
+               fprintf(fp,"Décodage de l'Instruction :\n");
+               Code=DecodeInstr(Pc);                                                                                           //***décodage de l'instruction
+               fprintf(fp,"Instruction Décodée : Code %d\n",Code);
+
+               //*** ETAGE 3
+               fprintf(fp,"Exécution de l'instruction :\n");
+               Execution(Pc,Code,&typeres,&Erreur,string,s1,s2,fp);
+
+               //*** ETAGE 4
+               fprintf(fp,"Rangement des résultats :\n");
+               RangerRes(Pc, typeres, s1,s2, string);          //*** Rangement des résultats
+
+       } while ((Code!=32) && (!Erreur));      //***TANT QUE DIFFERENT DE STOP
+
+       fclose(fp);
+}
+
+//***décodage de l'instruction
+int DecodeInstr(Machine *Pc)
+{
+       int code;
+       char *octet=RecupOctet(Pc->BR[REG_INSTR],0); //***récupère l'instruction du registre d'instructions
+       code=BinStringToInt(octet); //***convertit le code en chaîne binaire
+       free(octet); //***libère le pointeur ...
+       return code;
+}
+
+void Execution(Machine *Pc, int Code, int *typeres, int *Erreur, char *string, char *s1, char *s2, FILE *fp)
+{
+       switch (Code)                                                                                                           //***exécute l'instruction
+       {
+               case 1://OUTS
+               {
+                       int add1;
+                       float tmp;
+                       if (Pc->BR[REG_INSTR][8]=='1') // c un reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1 = @reg s1
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_DEST);//DEST contient dest
+                               tmp= convFloat(Pc->BR[REG_DEST]);
+                               sprintf(string,"OUTS REG % 4d = %f",add1,tmp);
+                       }
+                       else    //** c un symbole
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @reg s1
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_DEST);//DEST contient dest
+                               tmp=convFloat(Pc->BR[REG_DEST]);
+                               sprintf(string,"OUTS MEM % 4d = %f",add1,tmp);
+                       }
+                       *typeres = RES_AUCUN;
+               }
+               break;
+               case 2://OUTD
+               {
+                       int add1,add2;
+                       float tmp;
+                       if (Pc->BR[REG_INSTR][8]=='1')//s1=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,8);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_DEST+1);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_DEST);
+                               tmp = convDouble(Pc->BR[REG_DEST],Pc->BR[REG_DEST+1]);
+                               sprintf(string,"OUTD REG % 4d = %f",add1,tmp);
+                       }
+                       else
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,8);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_DEST+1);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_DEST);
+                               tmp = convDouble(Pc->BR[REG_DEST],Pc->BR[REG_DEST+1]);
+                               sprintf(string,"OUTD MEM % 4d = %f",add1,tmp);
+                       }
+                       *typeres = RES_AUCUN;
+               }
+               break;
+               case 27://JUMP
+               {
+                       char *add=RecupAdd(Pc->BR[REG_INSTR],TAILLE_OCTET);
+                       int i;
+                       for(i=0;i<TAILLE_ADD;i++)
+                       {
+                               Pc->BR[REG_ADD_INSTR][i]='0';
+                               Pc->BR[REG_ADD_INSTR][i+TAILLE_ADD]=add[i];
+                       }
+                       free(add);
+                       sprintf(string,"JUMP % 4d",BinStringToInt(Pc->BR[REG_ADD_INSTR]));
+                       *typeres = RES_AUCUN;
+               }
+               break;
+               case 28://CALL
+               {
+                       char *add=RecupAdd(Pc->BR[REG_INSTR],TAILLE_OCTET);//on recupe l'addresse de saut
+                       int i;
+                       Push(Pc,REG_ADD_INSTR);//le pointeur de pile pointe vers @instruction+1
+                       for(i=0;i<TAILLE_ADD;i++)
+                       {
+                               Pc->BR[REG_ADD_INSTR][i]='0';
+                               Pc->BR[REG_ADD_INSTR][i+TAILLE_ADD]=add[i];
+                       }
+                       free(add);
+                       sprintf(string,"CALL % 3d",BinStringToInt(Pc->BR[REG_ADD_INSTR]));
+                       *typeres = RES_AUCUN;
+               };
+               break;
+               case 29://RET
+               {
+                       Pop(Pc);
+                       sprintf(string,"RET %4d",BinStringToInt(Pc->BR[REG_ADD_INSTR]));
+                       *typeres = RES_AUCUN;
+               };
+               break;
+               case 32:
+               {
+                       *typeres = RES_AUCUN;
+               };
+               break;
+               case 39://ADDS
+               {
+                       int add,add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,ADDS);
+                               sprintf(s1,"ADDS REG %4d REG % 4d ",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,ADDS);
+                               sprintf(s1,"ADDS REG %4d MEM % 4d ",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,ADDS);
+                               sprintf(s1,"ADDS MEM %4d REG %4d ",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,ADDS);
+                               sprintf(s1,"ADDS MEM %4d REG %4d ",add1,add2);
+                       }
+                       *typeres = RES_SIMPLE;
+               };
+               break;
+               case 40: //ADDD
+               {
+                       int add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,ADDD);
+                               sprintf(s1,"ADDD REG %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,ADDD);
+                               sprintf(s1,"ADDD REG %4d MEM %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg +1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,ADDD);
+                               sprintf(s1,"ADDD MEM %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,ADDD);
+                               sprintf(s1,"ADDD MEM %4d MEM %4d",add1,add2);
+                       }
+                       *typeres = RES_DOUBLE;
+               };
+               break;
+               case 41://SUBS
+               {
+                       int add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,SUBS);
+                               sprintf(s1,"SUBS REG %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,SUBS);
+                               sprintf(s1,"SUBS REG %4d MEM %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,SUBS);
+                               sprintf(s1,"SUBS MEM %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,SUBS);
+                               sprintf(s1,"SUBS MEM %4d MEM %4d",add1,add2);
+                       }
+                       *typeres = RES_SIMPLE;
+               };
+               break;
+               case 42://SUBD
+               {
+                       int add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,SUBD);
+                               sprintf(s1,"SUBD REG %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,SUBD);
+                               sprintf(s1,"SUBD REG %4d MEM %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg +1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,SUBD);
+                               sprintf(s1,"SUBD MEM %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,SUBD);
+                               sprintf(s1,"SUBD MEM %4d MEM %4d",add1,add2);
+                       }
+                       *typeres = RES_DOUBLE;
+               };
+               break;
+               case 43://MULS
+               {
+                       int add,add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,MULS);
+                               sprintf(s1,"MULS REG %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,MULS);
+                               sprintf(s1,"MULS REG %4d MEM %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,MULS);
+                               sprintf(s1,"MULS MEM %4d REG %4d",add1,add2);
+                       }       
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2   
+                               FPU(Pc,MULS);
+                               sprintf(s1,"MULS MEM %4d MEM %4d",add1,add2);
+                       }
+                       *typeres = RES_SIMPLE;
+               };
+               break;
+               case 44://MULD
+               {
+                       int add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,MULD);
+                               sprintf(s1,"MULD REG %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible 
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,MULD);
+                               sprintf(s1,"MULD REG %4d MEM %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible 
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg +1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,MULD);
+                               sprintf(s1,"MULD MEM %4d REG %4d",add1,add2);
+                       }       
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible 
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,MULD);
+                               sprintf(s1,"MULD MEM %4d MEM %4d",add1,add2);
+                       }
+                       *typeres = RES_DOUBLE;
+               };
+               break;
+               case 45://DIVS
+               {
+                       int add,add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,DIVS);
+                               sprintf(s1,"DIVS REG %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,DIVS);
+                               sprintf(s1,"DIVS REG %4d MEM %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2   
+                               FPU(Pc,DIVS);
+                               sprintf(s1,"DIVS MEM %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2   
+                               FPU(Pc,DIVS);
+                               sprintf(s1,"DIVS MEM %4d MEM %4d",add1,add2);
+                       }
+                       *typeres = RES_SIMPLE;
+               };
+               break;
+               case 46://DIVD
+               {
+                       int add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,DIVD);
+                               sprintf(s1,"DIVD REG %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,DIVD);
+                               sprintf(s1,"DIVD REG %4d MEM %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,DIVD);
+                               sprintf(s1,"DIVD MEM %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+
+                               FPU(Pc,DIVD);
+                               sprintf(s1,"DIVD MEM %4d MEM %4d",add1,add2);
+                       }
+                       *typeres = RES_DOUBLE;
+               };
+               break;
+               case 47://ABSS
+               {
+                       int add;
+                       if (Pc->BR[REG_INSTR][16]=='1')//source=reg
+                       {
+                               AddSymbReg(Pc,BinStringToInt(Pc->BR[REG_ADD_INSTR]),REG_S1,16);//S1= @reg source
+                               ChargerRegReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,ABSS);// calcul valeur ABS S1
+
+                               sprintf(string,"ABSS REG %4d ",add);
+                       }
+                       if (Pc->BR[REG_INSTR][16]=='0')//source=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @mem source
+                               ChargerMemReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 = [@mem]
+                               FPU(Pc,ABSS);//calcul valeur ABS S1
+
+                               sprintf(string,"ABSS MEM %4d ",add);
+                       }
+                       *typeres = RES_SIMPLE;
+               };
+               break;
+               case 48://NGS
+               {
+                       int add;
+                       if (Pc->BR[REG_INSTR][16]=='1')//source=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg source
+                               ChargerRegReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,NGS);// calcul valeur NGS S1
+
+                               sprintf(string,"NGS REG %4d ",add);
+                       }
+                       if (Pc->BR[REG_INSTR][16]=='0')//source=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @mem source
+                               ChargerMemReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 = [@mem]
+                               FPU(Pc,NGS);//calcul valeur NGS S1
+
+                               sprintf(string,"NGS MEM %4d ",add);
+                       }
+                       *typeres = RES_SIMPLE;
+               };
+               break;
+               case 49://NGD
+               {
+                       int add;
+                       if (Pc->BR[REG_INSTR][16]=='1')//source=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg source poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1+1);//S1+1 = [@reg] poids faible
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_DEST]),REG_S1);//S1 = [@reg+1] poids fort
+                               FPU(Pc,NGD);//calcul NGD S1
+
+                               sprintf(s1,"NGD REG %4d ",add);
+                       }
+                       if (Pc->BR[REG_INSTR][16]=='0')//source=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @mem source poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerMemReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1+1);//S1+1= [@mem]
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_DEST]),REG_S1);//S1= [@mem+1]
+                               FPU(Pc,NGD);//valeur NGD S1
+
+                               sprintf(s1,"NGD MEM %4d ",add);
+                       }
+                       *typeres = RES_DOUBLE;
+               };
+               break;
+               case 50://EQS
+               {
+                       int add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,EQS);
+                               sprintf(s1,"EQS REG %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,EQS);
+                               sprintf(s1,"EQS REG %4d MEM %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,EQS);
+                               sprintf(s1,"EQS MEM %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,EQS);
+                               sprintf(s1,"EQS MEM %4d MEM %4d",add1,add2);
+                       }
+                       //ici on a DEST qui contient le booleen s1=s2
+                       if (BinStringToInt(Pc->BR[REG_DEST])==1)//le registre dest=0...01
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 =[@mem]
+                               //S1 contient donc l @de l intruction du saut
+                               ChargerRegReg(Pc,REG_S1,REG_ADD_INSTR);
+                               sprintf(s2," = 1 -> JMP %4d",BinStringToInt(Pc->BR[REG_ADD_INSTR]));
+                               sprintf(string,"%s %s",s1,s2);
+                       }
+                       else
+                       {       
+                               sprintf(s2," =  0");
+                               sprintf(string,"%s %s",s1,s2);  
+                       }
+                       *typeres = RES_AUCUN;
+               };
+               break;
+               case 51://EQD
+               {
+                       int add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,EQD);
+                               sprintf(s1,"EQD REG %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,EQD);
+                               sprintf(s1,"EQD REG %4d MEM %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg +1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,EQD);
+                               sprintf(s1,"EQD MEM %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,EQD);
+                               sprintf(s1,"EQD MEM %4d MEM %4d",add1,add2);
+                       }
+                       //ici on a DEST qui contient le booleen s1=s2
+                       if (BinStringToInt(Pc->BR[REG_DEST])==1)//le registre dest=0...01
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 =[@mem]
+                               //S1 contient donc l @de l intruction du saut
+                               ChargerRegReg(Pc,REG_S1,REG_ADD_INSTR);
+                               sprintf(s2," = 1 -> JMP %4d\n",BinStringToInt(Pc->BR[REG_ADD_INSTR]));
+                               sprintf(string,"%s %s",s1,s2);
+                       }
+                       else
+                       {
+                               sprintf(s1," = 0");
+                               sprintf(string,"%s %s",s1,s2);
+                       }
+                       *typeres = RES_AUCUN;
+               };
+               break;
+               case 52://LES
+               {
+                       int add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,LES);
+                               sprintf(s1,"LES REG %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,LES);
+                               sprintf(s1,"LES REG %4d MEM %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,LES);
+                               sprintf(s1,"LES MEM %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,LES);
+                               sprintf(s1,"LES MEM %4d MEM %4d",add1,add2);
+                       }
+                       //ici on a DEST qui contient le booleen s1=s2
+                       if (BinStringToInt(Pc->BR[REG_DEST])==1)//le registre dest=0...01
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 =[@mem]
+                               //S1 contient donc l @de l intruction du saut
+                               ChargerRegReg(Pc,REG_S1,REG_ADD_INSTR);
+                               sprintf(s2," = 1 -> JMP %4d",BinStringToInt(Pc->BR[REG_ADD_INSTR]));
+                               sprintf(string,"%s %s",s1,s2);
+                       }
+                       else
+                       {
+                               sprintf(s2," = 0");
+                               sprintf(string,"%s %s",s1,s2);
+                       }
+                       *typeres = RES_AUCUN;
+               };
+               break;
+               case 53://LED
+               {
+                       int add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);                                        
+                               FPU(Pc,LED);
+                               sprintf(s1,"LED REG %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible 
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,LED);
+                               sprintf(s1,"LED REG %4d MEM %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible 
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg +1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,LED);
+                               sprintf(s1,"LED MEM %4d REG %4d",add1,add2);
+                       }       
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible 
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,LED);
+                               sprintf(s1,"LED MEM %4d MEM %4d",add1,add2);
+                       }
+                       //ici on a DEST qui contient le booleen s1=s2
+                       if (BinStringToInt(Pc->BR[REG_DEST])==1)//le registre dest=0...01
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1 
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 =[@mem]
+                               //S1 contient donc l @de l intruction du saut
+                               ChargerRegReg(Pc,REG_S1,REG_ADD_INSTR);
+                               sprintf(s2," = 1 -> JMP %4d",BinStringToInt(Pc->BR[REG_ADD_INSTR]));
+                               sprintf(string,"%s %s",s1,s2);
+                       }
+                       else
+                       {       
+                               sprintf(s2," = 0");     
+                               sprintf(string,"%s %s",s1,s2);
+                       }
+                       *typeres = RES_AUCUN;
+               };
+               break;
+               case 54: //LLS
+               {
+                       int add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2
+                               FPU(Pc,LLS);
+                               sprintf(s1,"LLS REG %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2   
+                               FPU(Pc,LLS);
+                               sprintf(s1,"LLS REG %4d MEM %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @reg s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2   
+                               FPU(Pc,LLS);
+                               sprintf(s1,"LLS MEM %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @symb s1
+                               AddSymbReg(Pc,REG_INSTR,REG_S2,24);//S2= @symb s2
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 contient s1
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S2]),REG_S2);//S2 contient s2   
+                               FPU(Pc,LLS);
+                               sprintf(s1,"LLS MEM %4d MEM %4d",add1,add2);
+                       }
+                       //ici on a DEST qui contient le booleen s1=s2
+                       if (BinStringToInt(Pc->BR[REG_DEST])==1)//le registre dest=0...01
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1 
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 =[@mem]
+                               //S1 contient donc l @de l intruction du saut
+                               ChargerRegReg(Pc,REG_S1,REG_ADD_INSTR);
+                               sprintf(s2," = 1 -> JMP %4d",BinStringToInt(Pc->BR[REG_ADD_INSTR]));
+                               sprintf(string,"%s %s",s1,s2);
+                       }
+                       else
+                       {       
+                               sprintf(s2," = 0");
+                               sprintf(string,"%s %s",s1,s2);
+                       }
+                       *typeres = RES_AUCUN;
+               };
+               break;
+               case 55://LLD
+               {
+                       int add1,add2;
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=reg s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);                                        
+                               FPU(Pc,LLD);
+                               sprintf(s1,"LLD REG %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='1')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=reg s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @reg s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @reg s1 poids faible 
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem+1 s2 poids fort
+                               ChargerRegReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,LLD);
+                               sprintf(s1,"LLD REG %4d MEM %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='1'))//s1=symb s2=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @reg s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @reg s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @reg +1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerRegReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,LLD);
+                               sprintf(s1,"LLD MEM %4d REG %4d",add1,add2);
+                       }
+                       if ((Pc->BR[REG_INSTR][16]=='0')&&(Pc->BR[REG_INSTR][24]=='0'))//s1=symb s2=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2 = @mem s1+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1 = @mem s1 poids faible
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,24);//S1 = @mem s2 poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,REG_S1,REG_S1+1);//S1+1 = @mem s2 poids faible
+                               ChargerRegReg(Pc,REG_DEST,REG_S1);//S1 = @mem +1 s2 poids fort
+                               ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2+1]),REG_S2+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_S2);
+                               ChargerMemReg(Pc,add2=BinStringToInt(Pc->BR[REG_S1+1]),REG_S1+1);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);
+                               FPU(Pc,LLD);
+                               sprintf(s1,"LLD MEM %4d MEM %4d",add1,add2);
+                       }
+                       //ici on a DEST qui contient le booleen s1=s2
+                       if (BinStringToInt(Pc->BR[REG_DEST])==1)//le registre dest=0...01
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S1]),REG_S1);//S1 =[@mem]
+                               //S1 contient donc l @de l intruction du saut
+                               ChargerRegReg(Pc,REG_S1,REG_ADD_INSTR);
+                               sprintf(s2," = 1 -> JMP %4d",BinStringToInt(Pc->BR[REG_ADD_INSTR]));
+                               sprintf(string,"%s %s",s1,s2);
+                       }
+                       else
+                       {
+                               sprintf(s2," = 0");
+                               sprintf(string,"%s %s",s1,s2);
+                       }
+                       *typeres = RES_AUCUN;
+               };
+               break;
+               case 56://MVS
+               {
+                       int add;
+                       if (Pc->BR[REG_INSTR][16]=='1')//source=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg source
+                               ChargerRegReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_DEST);
+
+                               sprintf(s1,"MVS REG %4d ",add);
+                       }
+                       if (Pc->BR[REG_INSTR][16]=='0')//source=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @mem source
+                               ChargerMemReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_DEST);//on charge la valeur @mem vers DEST
+                               sprintf(string,"MVS MEM %4d ",add);
+                       }
+                       *typeres = RES_SIMPLE;
+               };
+               break;
+               case 57://MVD
+               {
+                       int add;
+                       if (Pc->BR[REG_INSTR][16]=='1')//source=reg
+                       {
+                               //*** calcul l'adresse de la case 2 de la source
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg source poids faible
+                               ALU(Pc,PLUS1);//calcul de @reg source+1
+
+                               //*** enregistrement des adresses de source
+                               ChargerRegReg(Pc,REG_DEST,REG_S2+1);//S2+1=@reg source+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2);//S2=@reg source poids faible
+
+                               //*** copie le mot dans le registre de destination
+                               ChargerRegReg(Pc,add=BinStringToInt(Pc->BR[REG_S2]),REG_DEST);
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_S2+1]),REG_DEST+1);
+                               sprintf(s1,"MVD REG %4d ",add);
+                       }
+                       if ((Pc->BR[REG_INSTR][8]=='1')&&(Pc->BR[REG_INSTR][16]=='0'))//dest=reg source=symb
+                       {
+                               //*** calcul l'adresse de la case 2 de la source
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1 =@mem source poids faible
+                               ALU(Pc,PLUS1);//calcul @mem source+1
+
+                               //*** enregistrement des adresses de source
+                               ChargerRegReg(Pc,REG_DEST,REG_S2);//S2=@mem+1 poids fort
+                               ChargerRegReg(Pc,REG_S1,REG_S2+1);//S2+1=@mem poids faible
+
+                               ChargerMemReg(Pc,add=BinStringToInt(Pc->BR[REG_S2+1]),REG_DEST);
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),REG_DEST+1);
+                               sprintf(string,"MVD MEM %4d ",add);
+                       }
+                       *typeres = RES_DOUBLE;
+               };
+               break;
+               case 58://LDS
+               {
+                       int add1,add2;
+                       AddSymbReg(Pc,REG_INSTR,REG_S1,16);//on charge @mem de la source
+                       AddSymbReg(Pc,REG_INSTR,REG_S2,8);//on charge @ du reg de la destination
+                       ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),add2=BinStringToInt(Pc->BR[REG_S2]));
+                       //on de la mem @add1 vers le registre @add2
+                       sprintf(string,"LDS CASE MEM %4d VERS REG %4d",add1,add2);
+                       *typeres = RES_AUCUN;
+               };
+               break;
+               case 59://LDD
+               {
+                       int add1,add2;
+                       AddSymbReg(Pc,REG_INSTR,REG_S1,16);//on charge @mem poids faible de la source
+                       ALU(Pc,PLUS1);// on calcul @mem de la source +1
+                       ChargerRegReg(Pc,REG_DEST,REG_S2+1);// S2+1 contient @mem poids fort de la source
+                       ChargerRegReg(Pc,REG_S1,REG_S2);// S2 contient @mem poids faible de la source
+                       AddSymbReg(Pc,REG_INSTR,REG_S1,8);//on charge @reg poids faible du reg de la dest
+                       ALU(Pc,PLUS1);// on calcul @reg de la dest +1
+                       ChargerRegReg(Pc,REG_DEST,REG_S1+1);// S1+1 contient @reg poids fort de la dest
+                       //On a donc:
+                       //S1=@reg (poids faible)
+                       //S1+1=@reg dest+1 (poids fort)
+                       //S2=@mem (poids faible)
+                       //S2+1=@mem source+1 (poids fort)
+                       ChargerMemReg(Pc,add1=BinStringToInt(Pc->BR[REG_S2]),add2=BinStringToInt(Pc->BR[REG_S1]));
+                       ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_S2]),BinStringToInt(Pc->BR[REG_S1]));
+                       sprintf(string,"LDD CASEMEM %4d VERS REG %4d",add1,add2);
+                       *typeres = RES_AUCUN;
+               };
+               break;
+               case 60://STS
+               {
+                       int add1,add2;
+                       AddSymbReg(Pc,REG_INSTR,REG_S1,16);//on charge @reg de la source
+                       AddSymbReg(Pc,REG_INSTR,REG_S2,8);//on charge @mem de la destination
+                       ChargerRegMem(Pc,add1=BinStringToInt(Pc->BR[REG_S1]),add2=BinStringToInt(Pc->BR[REG_S2]));
+                       sprintf(string,"STS REG %4d VERS CASE MEM %4d",add1,add2);
+                       *typeres = RES_AUCUN;
+               };
+               break;
+               case 61://STD
+               {
+                       int add1,add2;
+                       AddSymbReg(Pc,REG_INSTR,REG_S1,16);//on charge @reg poids faible de la source
+                       ALU(Pc,PLUS1);// on calcul @reg de la source +1
+                       ChargerRegReg(Pc,REG_DEST,REG_S2+1);// S2+1 contient @reg poids fort de la source
+                       ChargerRegReg(Pc,REG_S1,REG_S2);// S2 contient @reg poids faible de la source
+                       AddSymbReg(Pc,REG_INSTR,REG_S1,8);//on charge @mem poids faible du reg de la dest
+                       ALU(Pc,PLUS1);// on calcul @mem de la dest +1
+                       ChargerRegReg(Pc,REG_DEST,REG_S1+1);// S1+1 contient @mem poids fort de la dest
+                       //On a donc:
+                       //S1=@mem dest (poids faible)
+                       //S1+1=@mem dest+1 (poids fort)
+                       //S2=@reg source (poids faible)
+                       //S2+1=@reg source+1 (poids fort)
+                       ChargerRegMem(Pc,add1=BinStringToInt(Pc->BR[REG_S2]),add2=BinStringToInt(Pc->BR[REG_S1]));
+                       ChargerRegMem(Pc,BinStringToInt(Pc->BR[REG_S2+1]),BinStringToInt(Pc->BR[REG_S1+1]));
+                       sprintf(string,"STD REG %4d VERS CASEMEM %4d\n",add1,add2);
+                       *typeres = RES_AUCUN;
+               };
+               break;
+               case 62://ABSD
+               {
+                       int add;
+                       if (Pc->BR[REG_INSTR][16]=='1')//source=reg
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @reg source poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerRegReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1+1);//S1+1 = [@reg] poids faible
+                               ChargerRegReg(Pc,BinStringToInt(Pc->BR[REG_DEST]),REG_S1);//S1 = [@reg+1] poids fort
+                               FPU(Pc,ABSD);//clacul ABSD S1
+
+                               sprintf(string,"ABSD REG %4d ",add);
+                       }
+                       if (Pc->BR[REG_INSTR][16]=='0')//source=symb
+                       {
+                               AddSymbReg(Pc,REG_INSTR,REG_S1,16);//S1= @mem source poids faible
+                               ALU(Pc,PLUS1);
+                               ChargerMemReg(Pc,add=BinStringToInt(Pc->BR[REG_S1]),REG_S1+1);//S1+1= [@mem]
+                               ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_DEST]),REG_S1);//S1= [@mem+1]
+                               FPU(Pc,ABSD);//valeur ABSD S1
+
+                               sprintf(string,"ABSD MEM %4d ",add);
+                       }
+                       *typeres = RES_DOUBLE;
+               }
+
+               break;
+               default:
+               {
+                       fprintf(fp,"Erreur Code-Op non valide : %d\n",Code);
+                       printf("Erreur programme\n");
+                       *Erreur = 1;
+                       *typeres = RES_AUCUN;
+                       break;
+               }
+       }
+}
+
+void RangerRes(Machine *Pc, int typeres, char *s1, char *s2, char *string)
+{
+       switch(typeres)
+       {
+               case RES_AUCUN:
+                       break;
+               case RES_SIMPLE:
+                       RangerResS(Pc,s1,s2,string);
+                       break;
+               case RES_DOUBLE:
+                       RangerResD(Pc,s1,s2,string);
+                       break;
+       }
+       printf("%s\n",string);
+}
+//*********************************************************************************************
+void RangerResS(Machine *Pc, char *s1, char *s2, char *string)
+{
+       int add;
+
+       //DEST = s1+s2
+       if (Pc->BR[REG_INSTR][8]=='0')//dest=symb
+       {
+               AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1 =@mem dest
+               ChargerRegMem(Pc,REG_DEST,add=BinStringToInt(Pc->BR[REG_S1]));
+               sprintf(s2," VERS MEM %4d",add);
+               sprintf(string,"%s %s",s1,s2);
+       }
+       else
+       {
+               AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1 =@reg dest
+               ChargerRegReg(Pc,REG_DEST,add=BinStringToInt(Pc->BR[REG_S1]));
+               sprintf(s2," VERS REG %4d",add);
+               sprintf(string,"%s %s",s1,s2);
+       }
+}
+
+
+void RangerResD(Machine *Pc, char *s1, char *s2, char *string)
+{
+       int add;
+
+       if  (Pc->BR[REG_INSTR][8]=='0')//dest=symb
+       {
+               ChargerRegReg(Pc,REG_DEST,REG_S2);//resultat poids fort
+               ChargerRegReg(Pc,REG_DEST+1,REG_S2+1);//resultat poids faible
+
+               //*** calcul de l'adresse de destination (deuxième case)
+               AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1
+               ALU(Pc,PLUS1);//calcul @mem+1
+
+               //*** Enregistrement du résultat
+               ChargerRegMem(Pc,REG_S2+1,add=BinStringToInt(Pc->BR[REG_S1]));
+               ChargerRegMem(Pc,REG_S2,BinStringToInt(Pc->BR[REG_DEST]));
+               sprintf(s2," VERS MEM %4d",add);
+               sprintf(string,"%s %s",s1,s2);
+       }
+       else
+       {
+               ChargerRegReg(Pc,REG_DEST,REG_S2);//resultat poids fort
+               ChargerRegReg(Pc,REG_DEST+1,REG_S2+1);//resultat poids faible
+               
+               //*** calcul de l'adresse de destination (deuxième case)
+               AddSymbReg(Pc,REG_INSTR,REG_S1,8);//S1= @mem s1
+               ALU(Pc,PLUS1);//calcul @mem+1
+
+               //*** Enregistrement du résultat
+               ChargerRegReg(Pc,REG_S2+1,add=BinStringToInt(Pc->BR[REG_S1]));
+               ChargerRegReg(Pc,REG_S2,BinStringToInt(Pc->BR[REG_DEST]));
+               sprintf(s2," VERS REG %4d",add);
+               sprintf(string,"%s %s",s1,s2);
+       }
+}
+//*********************************************************************************************
+
+
+
+//***récupère l'octet db dans le mot mémoire motmemoire
+char *RecupOctet(char *motmemoire,int deb)
+{
+       int i;
+       char *octet=(char *) malloc ((TAILLE_OCTET+1)*sizeof(char));//***alloue la mémoire du pointeur
+       for(i=deb;i<deb+TAILLE_OCTET;i++)
+               octet[i-deb]=motmemoire[i];//***copie la partie du mot mémoire
+       octet[TAILLE_OCTET]='\0';//***marque le dernier octet comme fin
+       return octet;
+}
+
+//***récupère l'adresse db dans le mot mémoire motmemoire
+char *RecupAdd(char *motmemoire,int deb)
+{
+       int i;
+       char *add=(char *) malloc ((TAILLE_ADD+1)*sizeof(char));//***alloue la mémoire du pointeur
+       for(i=deb;i<deb+TAILLE_ADD;i++)
+               add[i-deb]=motmemoire[i];//***copie la partie du mot mémoire
+       add[TAILLE_ADD]='\0';
+       return add;
+}
+
+//***?????????????????????????
+int DecodeAddSymb(char *motmemoire,int deb)
+{
+       char *addsymb=RecupOctet(motmemoire,deb);
+       addsymb[0]='0'; //attention effet de bord
+       return BinStringToInt(addsymb);
+}
+
+//***
+void AddSymbReg(Machine *Pc,int numregs,int numregd,int deb)
+{
+       int i;
+       char *octet=RecupOctet(Pc->BR[numregs],deb);
+       octet[0]='0';
+       for(i=0;i<TAILLE_ADD+TAILLE_OCTET;i++)
+               Pc->BR[numregd][i]='0';
+       for(i=0;i<TAILLE_OCTET;i++)
+               Pc->BR[numregd][i+TAILLE_OCTET+TAILLE_ADD]=octet[i];
+       free(octet);
+}
+
+char *RecupSymb(char *symb)
+{
+       int i;
+       char *add=(char *) malloc ((TAILLE_SYMB+1)*sizeof(char));
+       for(i=0;i<TAILLE_SYMB;i++)
+               add[i]=symb[i];
+       add[TAILLE_SYMB]='\0';
+       return add;
+}
+
+void Push(Machine *Pc,int numreg)
+{
+       //Décrémente le pointeur de pile
+       Decrementer(Pc, REG_POINTEUR);
+
+       //Empile le contenu du registre numreg
+       ChargerRegMem(Pc,numreg,BinStringToInt(Pc->BR[REG_POINTEUR]));
+
+       fprintf(fp,"PUSH INDICE POINTEUR %d\n",BinStringToInt(Pc->BR[REG_POINTEUR]));
+       printf("PUSH INDICE POINTEUR %d\n",BinStringToInt(Pc->BR[REG_POINTEUR]));
+}
+
+void Pop(Machine *Pc)
+{
+       //***Dépile le contenu du sommet de la pile dans le compteur ordinal
+       ChargerMemReg(Pc,BinStringToInt(Pc->BR[REG_POINTEUR]),REG_ADD_INSTR);
+
+       //***Incrémente le pointeur de pile
+       Incrementer(Pc, REG_POINTEUR);
+
+       fprintf(fp,"POP INDICE POINTEUR %d\n",BinStringToInt(Pc->BR[REG_POINTEUR]));
+       printf("POP INDICE POINTEUR %d\n",BinStringToInt(Pc->BR[REG_POINTEUR]));
+}
+
+void Incrementer(Machine *Pc,int numreg)
+{
+       ChargerRegReg(Pc,numreg,REG_S1);
+       ALU(Pc,PLUS1);
+       ChargerRegReg(Pc,REG_DEST,numreg);
+}
+
+void Decrementer(Machine *Pc,int numreg)
+{
+       ChargerRegReg(Pc,numreg,REG_S1);
+       ALU(Pc,MOINS1);
+       ChargerRegReg(Pc,REG_DEST,numreg);
+}
+
+void ALU(Machine *Pc,int opp)
+{
+       switch (opp)
+       {
+               case ADD:
+               {}
+               break;
+               case SUB:
+               {}
+               break;
+               case MUL:
+               {}
+               break;
+               case DIV:
+               {}
+               break;
+               case PLUS1:
+               {
+                       int i;
+                       char *vecteur=(char *) malloc (TAILLE_REGISTRE*sizeof(char));
+                       for(i=0;i<TAILLE_REGISTRE-1;i++)
+                               vecteur[i]='0';
+                       vecteur[TAILLE_REGISTRE-1]='1';
+                       SommeBin(Pc->BR[REG_S1],vecteur,Pc->BR[REG_DEST]);
+                       free(vecteur);
+                       //fprintf(fp,"ALU S1+1->DEST\n");
+               }
+               break;
+               case MOINS1:
+               {
+                       int i;
+                       char *vecteur=(char *) malloc (TAILLE_REGISTRE*sizeof(char));
+                       for(i=0;i<TAILLE_REGISTRE;i++)
+                               vecteur[i]='0';
+                       SousBin(Pc->BR[REG_S1],vecteur,Pc->BR[REG_DEST]);
+                       free(vecteur);
+                       //fprintf(fp,"ALU S1-1->DEST\n");
+               }
+               break;
+               default:
+                       printf("Erreur ALU :  fonction non supportée\n");
+       }
+}
+
+void SommeBin(char *mots1,char *mots2,char *motd)
+{
+       int i;
+       char retenue='0';
+       for(i=TAILLE_REGISTRE-1;i>=0;i--)
+       {
+               if ((mots1[i]=='0')&&(mots2[i]=='0'))
+               {       
+                       motd[i]=retenue;
+                       retenue='0';
+               }
+               if ((mots1[i]=='1')&&(mots2[i]=='1'))
+               {       
+                       motd[i]=retenue;
+                       retenue='1';
+               }
+               if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='0'))
+               {
+                       motd[i]='1';    
+                       retenue='0';
+               }
+               if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='1'))
+               {
+                       motd[i]='0';    
+                       retenue='1';
+               }
+               if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='0'))
+               {
+                       motd[i]='1';    
+                       retenue='0';
+               }
+               if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='1'))
+               {
+                       motd[i]='0';    
+                       retenue='1';
+               }
+       }
+}
+
+void SousBin(char *mots1,char *mots2,char *motd)
+{
+       int i;
+       char retenue='1';
+       for(i=TAILLE_REGISTRE-1;i>=0;i--)
+       {
+               if ((mots1[i]=='0')&&(mots2[i]=='0'))
+               {       
+                       motd[i]=retenue;
+               }
+               if ((mots1[i]=='1')&&(mots2[i]=='1'))
+               {       
+                       motd[i]=retenue;
+               }
+               if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='0'))
+               {
+                       motd[i]='1';    
+                       retenue='1';
+               }
+               if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='1'))
+               {
+                       motd[i]='0';    
+                       retenue='1';
+               }
+               if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='0'))
+               {
+                       motd[i]='1';    
+                       retenue='0';
+               }
+               if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='1'))
+               {
+                       motd[i]='0';    
+                       retenue='0';
+               }
+       }       
+}
+

diff --git a/vexec/machine.h b/vexec/machine.h
new file mode 100755 (executable)
index 0000000..c180fb7
--- /dev/null
+++ b/vexec/machine.h
@@ -0,0 +1,172 @@
+/*             machine.h               */
+
+#ifndef _MACHINE_
+#define _MACHINE_
+#define TAILLE_MEMOIRE 65536                                           //*** Memoire de 64ko
+#define TAILLE_MOT_MEMOIRE 32                                          //*** Mots de 32 bits
+#define TAILLE_BANC_REGISTRE 32                                                //*** 32 registres
+#define TAILLE_REGISTRE 32                                                     //*** registres de 32 bits
+#define TAILLE_ADD 16                                                          //*** 16 bits pour l'adresse
+#define TAILLE_OCTET 8                                                         //*** 8 bits = 1octet
+#define TAILLE_SYMB 7                                                          //*** 7 bits = 1 symbole (le 1er sert à dire que c'est un symbole)
+#define ADD_SEG 0                                                                      //*** adresse du premier mot réservé aux données
+#define ADD_INSTR 128                                                          //*** adresse du premier mot réservé aux instructions
+#define MAX_STRING 128                                                         //*** longueur maximale d'une chaine
+#define REG_INSTR 31                                                           //*** registre d'instruction = R[31]
+#define REG_ADD_INSTR 30                                                       //*** registre de pointeur d'adresse = R[30]
+#define REG_POINTEUR 29                                                                //*** registre pointeur ????? = R[29]
+#define REG_DEST 27                                                                    //*** registre de destination (résultat de l'opération) = R[27] (+R[28] )
+#define REG_S2 25                                                                      //*** registre S2 2e opérande = R[25] (+ R[26])
+#define REG_S1 23                                                                      //*** registre S1 1e operande = R[23] (+R[24])
+
+#define RES_AUCUN 0                                                            //*** il n'y a pas de résultat à ranger
+#define RES_SIMPLE 1                                                           //*** le résultat à ranger est un simple
+#define RES_DOUBLE 2                                                           //***le résultat à ranger est un double
+
+/* TYPE DE CACHE 1
+//************************************************************************************************
+//caractéristiques du cache
+#define BLOCS_CACHE 32                                                         //*** 32 blocs de cache
+#define LIGNES_PAR_BLOC 4                                                      //***  4 lignes de cache par bloc
+#define MOTS_PAR_BLOC (TAILLE_MEMOIRE/BLOCS_CACHE)     //*** nb de mots par bloc de cache = 2048
+
+//taille des différents champs
+#define TAILLE_ADD_BLOC 5                                                      //***taille du champ adresse de la mem (2^5 = 32)
+#define TAILLE_INDEX 11                                                                //***taille du champ index (2^11 = 2048)
+#define TAILLE_ANCIENNETE 2                                                    //***nb de bits utilisés pour le marquage de l'ancienneté d'une ligne de cache
+#define TAILLE_MODIF 1                                                         //***nb de bits pour marquer la modification
+#define TAILLE_VALID 1                                                         //***nb de bits pour marquer la présence d'un mot dans la ligne
+#define TAILLE_LIGNE_CACHE (TAILLE_MOT_MEMOIRE+TAILLE_INDEX+TAILLE_ANCIENNETE+TAILLE_MODIF+TAILLE_VALID)
+                                                                                                       //***taille d'une ligne de cache
+
+//Champs d'une ligne de cache
+#define DEB_MOT 0                                                                      //***emplacement du mot mémoire dans la ligne
+#define DEB_INDEX (DEB_MOT+TAILLE_MOT_MEMOIRE)         //***emplacement de l'index dans la ligne
+#define DEB_ANCIENNETE (DEB_INDEX+TAILLE_INDEX)                //***emplacement des bits d'ancienneté dans la ligne
+#define DEB_MODIF (DEB_ANCIENNETE+TAILLE_ANCIENNETE)//***emplacement du bit de modification dans la ligne
+#define DEB_VALID (DEB_MODIF+TAILLE_MODIF)                     //***emplacement du bit de modification dans la ligne
+
+//nombre de lignes de cache
+#define LIGNES_CACHE (BLOCS_CACHE*LIGNES_PAR_BLOC)     //*** nb de lignes de cache (128)
+//************************************************************************************************
+*/
+
+/*TYPE DE CACHE 2*/
+//************************************************************************************************
+//caractéristiques du cache
+#define BLOCS_CACHE 8                                                          //*** 8 blocs de cache
+#define LIGNES_PAR_BLOC 2                                                      //***  2 lignes de cache par bloc
+#define MOTS_PAR_BLOC (TAILLE_MEMOIRE/BLOCS_CACHE)     //*** nb de mots par bloc de cache = 8192
+
+//taille des différents champs
+//#define TAILLE_ADD_BLOC 3                                                    //***taille du champ adresse de la mem (2^3 = 8)
+#define TAILLE_INDEX 13                                                                //***taille du champ index (2^13 = 8192)
+#define TAILLE_ANCIENNETE 1                                            //***nb de bits utilisés pour le marquage de l'ancienneté d'une ligne de cache log2 de LIGNES_PARE_BLOC
+#define TAILLE_MODIF 1                                                         //***nb de bits pour marquer la modification
+#define TAILLE_VALID 1                                                         //***nb de bits pour marquer la présence d'un mot dans la ligne
+#define TAILLE_LIGNE_CACHE (TAILLE_MOT_MEMOIRE+TAILLE_INDEX+TAILLE_ANCIENNETE+TAILLE_MODIF+TAILLE_VALID)
+                                                                                                       //***taille d'une ligne de cache
+
+//Champs d'une ligne de cache
+#define DEB_MOT 0                                                                      //***emplacement du mot mémoire dans la ligne
+#define DEB_INDEX (DEB_MOT+TAILLE_MOT_MEMOIRE)         //***emplacement de l'index dans la ligne
+#define DEB_ANCIENNETE (DEB_INDEX+TAILLE_INDEX)                //***emplacement des bits d'ancienneté dans la ligne
+#define DEB_MODIF (DEB_ANCIENNETE+TAILLE_ANCIENNETE)//***emplacement du bit de modification dans la ligne
+#define DEB_VALID (DEB_MODIF+TAILLE_MODIF)                     //***emplacement du bit de modification dans la ligne
+
+//nombre de lignes de cache
+#define LIGNES_CACHE (BLOCS_CACHE*LIGNES_PAR_BLOC)     //*** nb de lignes de cache (16)
+//************************************************************************************************
+
+
+#include <malloc.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+typedef char **Memoire;
+typedef char **BancRegistre;
+typedef char **Cache;
+enum CodeFonction
+{      ADD,            //*** addition entiers
+       SUB,            //*** soustraction entiers
+       MUL,            //*** multiplication d'entiers
+       DIV,            //*** division d'entiers
+       PLUS1,          //*** incrémentation
+       MOINS1,         //*** décrémentation
+       ADDS,           //*** addition de flottants simples
+       ADDD,           //*** addition de flottants doubles
+       SUBS,           //*** soustraction de flottants simples
+       SUBD,           //*** soustraction de flottants doubles
+       MULS,           //*** multiplication de flottants simples
+       MULD,           //*** multiplication de flottants doubles
+       DIVS,           //*** division de flottants simples
+       DIVD,           //*** division de flottants doubles
+       ABSS,           //*** valeur absolue de flottants simples
+       ABSD,           //*** valeur absolue de flottants doubles
+       NGS,            //*** opposé d'un flottant simple
+       NGD,            //*** opposé d'un flottant double
+       EQS,            //*** teste l'égalisté de 2 flottants simples
+       EQD,            //*** teste l'égalisté de 2 flottants doubles
+       LES,
+       LED,
+       LLS,
+       LLD,
+       MVS,            //*** copie d'un flottant simple
+       MVD,            //*** copie d'un flottant double
+       LDS,
+       LDD,
+       STS,
+       STD
+} ;
+
+typedef struct
+{
+       Memoire MP;
+       BancRegistre BR;
+       Cache CA;
+}Machine;
+
+Memoire InitMemoire(int nbcase);
+BancRegistre InitBancRegistre(int nbreg);
+Cache InitCache(int nblignes);
+Machine *InitMachine(int nbcasemem,int nbreg, int nbligcache);
+char *RecupOctet(char *motmemoire,int deb);
+char *RecupAdd(char *motmemoire,int deb);
+char *RecupSymb(char *symb);
+int ChargerProg(Machine *Pc,char *Nom);
+void ChargerInstr(Machine *Pc,FILE *fps,int nbinstr);
+void ChargerVar(Machine *Pc,FILE *fps);
+void ChargerMemReg(Machine *Pc,int casemem,int numreg);
+void ChargerRegMem(Machine *Pc,int numregint,int casemem);
+void ChargerRegReg(Machine *Pc,int regs,int regd);
+int DecodeInstr(Machine *Pc);
+int DecodeAdd(char *motmemoire,int deb);
+void StartEngine(Machine *Pc);
+int BinStringToInt(char *Addr);
+char *IntToBinString(int n,int taille);
+void Push(Machine *Pc,int numreg);
+void Pop(Machine *Pc);
+void ALU(Machine *Pc,int opp);
+void SommeBin(char *mots1,char *mots2,char *motd);
+void SousBin(char *mots1,char *mots2,char *motd);
+int DecodeAddSymb(char *motmemoire,int deb);
+void AddSymbReg(Machine *Pc,int numregs,int numregd,int deb);
+
+//************************************************************************************************
+int ChercherMot(Machine *Pc, int adresse);                                             //Cherche un mot dans le cache
+void ChargerCacMem(Machine *Pc, int lignecache,int adresse);   //Enregistre un mot du cache dans la mémoire principale
+int ChargerMemCac(Machine *Pc,int adresse);                                            //Charge un mot de la mémoire principale dans le cache
+int Anciennete(Machine *Pc, int lignecache);                                   //Donne l'ancienneté d'une ligne
+
+void Execution(Machine *Pc, int Code, int *typeres, int *erreur, char *string, char *s1, char *s2, FILE *fp); //exécute l'instruction
+void RangerRes(Machine *Pc, int typeres, char *s1, char *s2, char *string);    //range les résultats d'une opération
+void RangerResS(Machine *Pc, char *s1, char *s2, char *string);        //range les résultats pour une opération sur un flottant simple
+void RangerResD(Machine *Pc, char *s1, char *s2, char *string);        //range les résultats pour une opération sur un flottant double
+
+void Incrementer(Machine *Pc,int numreg);                                              //Incrémente le registre dont le numéro est passé en argument
+void Decrementer(Machine *Pc,int numreg);                                              //Décrémente le registre dont le numéro est passé en argument
+//************************************************************************************************
+
+
+#endif

diff --git a/vexec/main.c b/vexec/main.c
new file mode 100755 (executable)
index 0000000..cee674b
--- /dev/null
+++ b/vexec/main.c
@@ -0,0 +1,45 @@
+/*      main.c  -  description         */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include "machine.h"
+
+int NbInstr;
+
+int main(int argc, char *argv[])
+{
+       char ligne[128];
+
+       printf("Initialisation de la machine\n");
+
+       Machine *Pc = InitMachine(TAILLE_MEMOIRE,TAILLE_BANC_REGISTRE,LIGNES_CACHE);
+       NbInstr=0;
+
+       if (argc>0)
+       {
+               printf("Chargement du programme\n");
+               if (ChargerProg(Pc,argv[1]) == -1)
+                       return 0;
+       }
+       else
+       {
+               printf("Entrez le nom du fichier : ");
+               fgets(ligne,128,stdin);
+               printf("Chargement du programme\n");
+               if (ChargerProg(Pc,ligne) == -1)
+                       return 0;
+       }
+
+       printf("Démarrage de la machine\n");
+       StartEngine(Pc);
+
+
+       printf("Programme terminé !\n");
+       return EXIT_SUCCESS;
+}

diff --git a/vexec/muldiv.c b/vexec/muldiv.c
new file mode 100755 (executable)
index 0000000..46c953f
--- /dev/null
+++ b/vexec/muldiv.c
@@ -0,0 +1,423 @@
+/*             muldiv.c                */
+
+#include "muldiv.h"
+#include "machine.h"
+#include "fpu.h"
+
+
+void ShiftG(char *f,int n,int d)
+{
+        int i;
+        for(i=0;i<n-d;i++)
+                f[i]=f[i+d];
+        for(i=n-d;i<n;i++)
+                f[i]='0';
+}
+
+void ShiftD(char *f,int n,int d)
+{
+        int i;
+        for(i=n-1;d<=i;i--)
+                       f[i]=f[i-d];
+        for(i=d;i<=0;i--)
+            f[i]='0';
+}
+
+void SommeBin2(char *mots1,char *mots2,char *motd,int n)
+{
+       int i;
+       char retenue='0';
+       for(i=n-1;i>=0;i--)
+       {
+               if ((mots1[i]=='0')&&(mots2[i]=='0'))
+               {
+                       motd[i]=retenue;
+                       retenue='0';
+               }
+               else if ((mots1[i]=='1')&&(mots2[i]=='1'))
+               {
+                       motd[i]=retenue;
+                       retenue='1';
+               }
+               else if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='0'))
+               {
+                       motd[i]='1';
+                       retenue='0';
+               }
+               else if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='1'))
+               {
+                       motd[i]='0';
+                       retenue='1';
+               }
+               else if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='0'))
+               {
+                       motd[i]='1';
+                       retenue='0';
+               }
+               else if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='1'))
+               {
+                       motd[i]='0';
+                       retenue='1';
+               }
+       }
+}
+
+void  SousBin2(char *mots1,char *mots2,char *motd,int taille)
+{
+       int i;
+       char retenue='0';
+       for(i=taille-1;i>=0;i--)
+       {
+               if ((mots1[i]=='0')&&(mots2[i]=='0'))
+               {
+                       motd[i]=retenue;
+               }
+               else if ((mots1[i]=='1')&&(mots2[i]=='1'))
+               {
+                       motd[i]=retenue;
+               }
+               else if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='0'))
+               {
+                       motd[i]='1';
+                       retenue='1';
+                }
+               else if ((mots1[i]=='0')&&(mots2[i]=='1')&&(retenue=='1'))
+               {
+                       motd[i]='0';
+                       retenue='1';
+               }
+               else if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='0'))
+               {
+                       motd[i]='1';
+                       retenue='0';
+               }
+               else if ((mots1[i]=='1')&&(mots2[i]=='0')&&(retenue=='1'))
+               {
+                       motd[i]='0';
+                       retenue='0';
+               }
+       }
+}
+
+char Ou(char c1,char c2)
+{
+        if ((c1=='1')||(c2=='1'))
+                return '1';
+        else
+                return '0';
+}
+
+char Et(char c1,char c2)
+{
+        if ((c1=='1')&&(c2=='1'))
+                return '1';
+        else
+                return '0';
+}
+
+char Xor(char c1,char c2)
+{
+        if ((c1=='1')&&(c2=='0'))
+                return 1;
+        if ((c1=='0')&&(c2=='1'))
+                return 1;
+        else
+                return '0';
+}
+
+char *RoundMantisse(char *s,int p,type_round R)
+{
+        int i;
+        char garde;
+        char arrondi;
+        char persistant='0';
+        char round;
+        char *res=(char *) malloc (p*sizeof(char));
+        garde=s[p+1];
+                 arrondi=s[p+2];       
+                 for(i=p+3;i<2*p;i++)
+                               persistant=Ou(persistant,s[i]);
+        if (R==RN)
+        {
+                round=Ou(Et(garde,arrondi),Et(garde,persistant));
+        }
+                 for(i=0;i<p;i++)
+                               res[i]=s[i+2];
+                 res[p-1]=round;
+                 return res;           
+}
+
+
+char *MulMantisse(char *f1,char *f2,type_float T,int *normalise)
+{
+        int i,taille;
+        int decal=0;
+        char *tmp;
+        char *res;
+        char round;
+        if (T==SIMPLE)
+                taille=24;
+        else
+                taille=53;
+        tmp= (char *) malloc (2*taille*sizeof(char));
+        res= (char *) malloc (2*taille*sizeof(char));
+        for(i=0;i<2*taille;i++)
+        {
+                res[i]='0';
+        }
+        for(i=taille-1;0<=i;i--)
+        {
+                if (f2[i]=='1')
+                {
+                        int j;
+                        int z=2*taille-1;
+                        for(j=0;j<taille;j++)
+                                tmp[j]='0';
+                        for(j=taille-1;0<=j;j--)
+                        {
+                                tmp[z]=f1[j];
+                                z--;
+                        }
+                        ShiftG(tmp,2*taille,decal);
+                        SommeBin2(tmp,res,res,2*taille);
+                }
+                decal++;
+        }
+                 if ((res[0]=='1'))
+                 {
+                               *normalise=0;
+                               ShiftD(res,2*taille,1);
+                 }
+                 res=RoundMantisse(res,taille-1,RN);
+        return res;
+}
+
+char *ExtraireExposant(char *s,type_float T)
+{
+        int i,j=0;
+        char *Exposant;
+        if (T==SIMPLE)
+        {
+                Exposant=(char *) malloc (9*sizeof(char));
+                Exposant[0]='0';
+                for(i=1;i<=8;i++)
+                               Exposant[i]=s[i];
+        }
+        else
+        {
+                Exposant=(char *) malloc (11*sizeof(char));
+                                        Exposant[0]='0';       
+                for(i=1;i<=11;i++)
+                       Exposant[j]=s[i];
+        }
+        return Exposant;
+}
+
+char *ExtraireMantisse(char *s1,char *s2,type_float T)
+{
+        int i,j=1;
+        char *Mantisse;
+        if (T==SIMPLE)
+        {
+                Mantisse=(char *) malloc (24*sizeof (char));
+                Mantisse[0]='1';
+                for(i=9;i<32;i++)
+                {
+                        Mantisse[j]=s1[i];
+                        j++;
+                }
+        }
+        else
+        {
+                Mantisse=(char *) malloc (53*sizeof (char));
+                Mantisse[0]='1';
+                for(i=12;i<32;i++)
+                {
+                        Mantisse[j]=s1[i];
+                        j++;
+                }
+                for(i=0;i<32;i++)
+                {
+                        Mantisse[j]=s2[i];
+                        j++;
+                }
+        }
+        return Mantisse;
+}
+
+char ExtraireSigne(char *s)
+{
+        return s[0];
+}
+
+char *MulExposant(char *e1,char *e2,type_float T,int normalise)
+{
+        char *Exposant,*t1,*t2;
+        char *Biais;
+                 if (T==SIMPLE)
+                 {     
+                       Biais=(char *) malloc (9*sizeof(char));
+                       if (!normalise)
+                sscanf("001111110","%s",Biais);
+                       else
+                sscanf("001111111","%s",Biais);
+                       Exposant= (char *) malloc (9*sizeof(char));
+            SommeBin2(e1,e2,Exposant,9);
+            SousBin2(Exposant,Biais,Exposant,9);
+        }
+        else
+        {
+                       Biais=(char *) malloc (12*sizeof(char));
+                       if (!normalise)
+                sscanf("001111111110","%s",Biais);
+                       else
+                sscanf("001111111111","%s",Biais);
+                       Exposant= (char *) malloc (12*sizeof(char));
+            SommeBin2(e1,e2,Exposant,12);
+            SousBin2(Exposant,Biais,Exposant,12);
+        }              
+            return Exposant;
+}
+
+char  *EvalTable(char *c,type_float T,int p)
+{
+       int i;
+       float f;
+       char *res;
+       if (T==SIMPLE)
+       {
+               f=convFloat(c);
+               f=1/f;
+               res=FloatToBin(f);
+               for(i=8+p;i<32;i++)
+                       res[i]='0';
+               return res;
+       }
+       else
+       {
+       f=convFloat(c);
+               f=1/f;
+               res=DoubleToBin(f);
+               for(i=11+p;i<64;i++)
+                       res[i]='0';
+               return res;
+       }
+}
+
+
+void MulS(char *s1,char *s2,char *res)
+{
+        int i;
+        int normalise=1;
+        char *Exposant1;
+        char *Exposant2;
+        char *Mantisse1;
+        char *Mantisse2;
+        char *MantisseRes;
+        char *ExposantRes;
+        char Signe1;
+        char Signe2;
+        char SigneRes;
+        Signe1=ExtraireSigne(s1);
+        Signe2=ExtraireSigne(s2);
+        SigneRes=Xor(Signe1,Signe2);
+        Mantisse1=ExtraireMantisse(s1,NULL,SIMPLE);
+        Mantisse2=ExtraireMantisse(s2,NULL,SIMPLE);
+        MantisseRes=MulMantisse(Mantisse1,Mantisse2,SIMPLE,&normalise);
+        Exposant1=ExtraireExposant(s1,SIMPLE);
+        Exposant2=ExtraireExposant(s2,SIMPLE);
+        ExposantRes=MulExposant(Exposant1,Exposant2,SIMPLE,normalise);
+                 res[0]=SigneRes;
+                 for(i=1;i<=8;i++)             
+                               res[i]=ExposantRes[i];
+                 for(i=9;i<32;i++)
+                               res[i]=MantisseRes[i-9];
+}
+
+void MulD(char *s1,char *s1p1,char *s2,char *s2p1,char *res,char *resp1)
+{
+                 int i;
+        int normalise=1;
+        char *Exposant1;
+        char *Exposant2;
+        char *Mantisse1;
+        char *Mantisse2;
+        char *MantisseRes;
+        char *ExposantRes;
+                 char Signe1;
+        char Signe2;
+        char SigneRes;
+        Signe1=ExtraireSigne(s1);
+        Signe2=ExtraireSigne(s2);
+        SigneRes=Xor(Signe1,Signe2);
+        Mantisse1=ExtraireMantisse(s1,s1p1,DOUBLE);
+        Mantisse2=ExtraireMantisse(s2,s2p1,DOUBLE);
+        MantisseRes=MulMantisse(Mantisse1,Mantisse2,DOUBLE,&normalise);
+        Exposant1=ExtraireExposant(s1,SIMPLE);
+        Exposant2=ExtraireExposant(s2,SIMPLE);
+        ExposantRes=MulExposant(Exposant1,Exposant2,SIMPLE,normalise);
+                 res[0]=SigneRes;
+                 for(i=1;i<=11;i++)            
+                               res[i]=ExposantRes[i];
+                 for(i=11;i<32;i++)
+                               res[i]=MantisseRes[i-11];
+                 for(i=0;i<32;i++)
+                               resp1[i]=MantisseRes[i];        
+}
+
+void soustmpS(char *s1,char *s2,char *dest,Flag f1,Flag f2)
+{
+       if( f1[s] != f1[s])
+        {
+       if( f1[eP] == 1)
+               {
+         s2[0] = ( s2[0] == '0') + '0';
+                       f2[s] = ( f2[s] == 0);
+                       additionS(dest, s1,s2, f1, f2);
+      }
+               else
+               {
+         s1[0] = ( s1[0] == '0') + '0';
+                       f1[s] = ( f1[s] == 0);
+                       additionS(dest,s2, s1, f2, f1);
+      }
+       }
+   else
+       {
+               
+       if( f2[eP] == 1) { printf("fiioghi\n");
+                       soustractionS( dest, s2, s1, f2, f1);}
+               else { printf( "fdhgsoi\n");
+                       soustractionS( dest, s1, s2, f1, f2);
+                       dest[0] = ( dest[0] == '0') + '0';
+               }
+       }
+}
+
+
+void DivS(char *a,char *b,char *res)
+{
+       int i;
+       float f1,f2;
+       Flag Fdeux;
+       Flag Fxo;
+       char *xo;
+       char *tmp=(char *) malloc (32*sizeof(char));
+       char *deux;
+       xo=EvalTable(b,SIMPLE,10);
+       for(i=0;i<2;i++)
+       {
+               deux=FloatToBin(2);
+               MulS(b,xo,tmp);
+               tmp=FloatToBin((2.00)-convFloat(tmp));
+               MulS(tmp,xo,xo);
+               free(deux);
+       }
+       MulS(a,xo,res);
+}
+
+
+
+
+
+

diff --git a/vexec/muldiv.h b/vexec/muldiv.h
new file mode 100755 (executable)
index 0000000..c5f59b4
--- /dev/null
+++ b/vexec/muldiv.h
@@ -0,0 +1,31 @@
+/*             divmul.h                */
+
+#ifndef _MULDIV
+
+#include "machine.h"
+
+typedef enum {RN,RZ,RM,RP} type_round;
+
+typedef enum {SIMPLE,DOUBLE} type_float;
+
+void ShiftG(char *,int ,int );
+void ShiftD(char *,int ,int );
+void SommeBin2(char *,char *,char *,int);
+void SousBin2(char *,char *,char *,int);
+char Ou(char ,char);
+char Et(char ,char);
+char Xor(char ,char);
+char *RoundMantisse(char *,int ,type_round);
+char *MulMantisse(char *,char *,type_float,int *);
+char *ExtraireExposant(char *,type_float);
+char *ExtraireMantisse(char *,char *,type_float);
+char *MulExposant(char *,char *,type_float,int);
+void MulS(char *,char *,char *);
+void MulD(char *,char *,char *,char *,char *,char *);
+char ExtraireSigne(char *);
+char  *EvalTable(char *,type_float ,int);
+void DivS(char *,char *,char *);
+
+
+
+#endif

diff --git a/vexec/vexec b/vexec/vexec
new file mode 100755 (executable)
index 0000000..c20c89d
Binary files /dev/null and b/vexec/vexec differ