From 4ae27c567d2377974ccbc0c7ed27907926d76778 Mon Sep 17 00:00:00 2001 From: Thomas Pietrzak Date: Sun, 23 Sep 2018 16:10:46 +0200 Subject: [PATCH 1/1] init --- ...ort Pietrzak Emery Fran%E7ois Bertrand.doc | Bin 0 -> 65536 bytes dasm/dasm | Bin 0 -> 16727 bytes dasm/dasm.c | 374 +++ dasm/lisezmoi.txt | 8 + exemples/addd.bin | 7 + exemples/d.bin | 26 + exemples/divd.bin | 7 + exemples/exec.bin | 28 + exemples/exemple.bin | 17 + exemples/min.bin | 8 + exemples/out.bin | 7 + exemples/s.bin | 23 + exemples/test.bin | 17 + vexec/fpu.c | 1160 ++++++++++ vexec/fpu.h | 71 + vexec/lisezmoi.txt | 8 + vexec/logengine.log | 26 + vexec/machine.c | 2020 +++++++++++++++++ vexec/machine.h | 172 ++ vexec/main.c | 45 + vexec/muldiv.c | 423 ++++ vexec/muldiv.h | 31 + vexec/vexec | Bin 0 -> 69505 bytes 23 files changed, 4478 insertions(+) create mode 100755 Rapport Pietrzak Emery Fran%E7ois Bertrand.doc create mode 100755 dasm/dasm create mode 100755 dasm/dasm.c create mode 100755 dasm/lisezmoi.txt create mode 100755 exemples/addd.bin create mode 100755 exemples/d.bin create mode 100755 exemples/divd.bin create mode 100755 exemples/exec.bin create mode 100755 exemples/exemple.bin create mode 100755 exemples/min.bin create mode 100755 exemples/out.bin create mode 100755 exemples/s.bin create mode 100755 exemples/test.bin create mode 100755 vexec/fpu.c create mode 100755 vexec/fpu.h create mode 100755 vexec/lisezmoi.txt create mode 100644 vexec/logengine.log create mode 100755 vexec/machine.c create mode 100755 vexec/machine.h create mode 100755 vexec/main.c create mode 100755 vexec/muldiv.c create mode 100755 vexec/muldiv.h create mode 100755 vexec/vexec diff --git a/Rapport Pietrzak Emery Fran%E7ois Bertrand.doc b/Rapport Pietrzak Emery Fran%E7ois Bertrand.doc new file mode 100755 index 0000000000000000000000000000000000000000..f5b5c5e3eba7b3ee9d266bb138bef4de8a6a1602 GIT binary patch literal 65536 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 E3Lj ziD=q-m)ut!b8qTf#;}igqxlGpS2S-HZcojJg^x9N7CzRzUiesZa^Yjm7lx1DlXa|l z&v3ZrNW;gPPYoYyjxl_!xytad<~75|ngb0VYrZsmtog<8vF0Mf$3*`dY?+Z`Sa$aB zef#po8}IzO^=C&O#y2mIfU%J4x8&)&%$0ncAhD1AGswcq5TlA`sSIl zO`hc?Ba4g6ic9n6*+3cfG2R4n^m$=hYaStvFg5jZ33h{OdY;L5EuY|3{%g%6lw)b= zODnFM?CjQu-kGIm`;RBn?=9Vx{eNZSV@^HvEWL=EAdU0_@YW4JXJcQU^M8zDi{MePD-q)zBm2$GCs6))Zj6;EMwO- zx9xdxS!eZ~H&!?&O}+bxTFz}EK>gd ztof=5>}4P>d(G9J#$HNa$X@eAE7)s5(#Br1JDLoUJLzSA2>T7}mA_1pWi6&$3z}M1 zw9IdAbej|H$*vfWhC56cQCVQnvf^Okh0|y@tT~zLj&;>^B>S9p$x&TbB)g4#m18#U zT<0gi(nNbInNF_hbI(hrI^4S2np&rx^Ug0$KU_L6zt@b|aM#{%6`9|?FP-oeeoK$a zS9`fy?d5K@AKr#FFsy-L4Ge2wSOdcv7}mhB28J~-tbt(-3~OLm14Gq7q5J>hM}PF_ zEj33}fAAyR|4)DM3%dXRAJ9Fz?om5I_vO8y`~7!=?)SHV<_P{7v~cu8p!?@rK=<#T z1l_-X9wve24RpW%b&%{QAbekM?!#I6t$X0jp#2nYuW2wH&mT3)2Rg4rhM^90^B(Zn2LB7mk5r;W*Ge{qb-DOoeH1BJfFv$d`Uw2S)~N8>KmV>d|H3Ss0cS!z%!dWg0FBTDX93d+&O%rO zi{Txx1eQWGEQ96nPH2HvSOMq2xo{q=g!AEDZ~HA{ccRQ_jkv8`rPP(HZvwz+N!l}#4yf8zia&He3)$SsbAK`X?S}>YvBI_ DLl+!< literal 0 HcmV?d00001 diff --git a/dasm/dasm b/dasm/dasm new file mode 100755 index 0000000000000000000000000000000000000000..2cd4e9c888ee3d461c7a141074b7f272a168d61e GIT binary patch literal 16727 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 dA7R@? +#include +#include + +#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 index 0000000..dd56a9c --- /dev/null +++ b/dasm/lisezmoi.txt @@ -0,0 +1,8 @@ +pour compiler : +gcc -o dasm dasm.c + +pour lancer : +dasm [nom_fichier] + +remarque : +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 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 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 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 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 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 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 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 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 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 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 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 +#include +#include + +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 index 0000000..c73ae94 --- /dev/null +++ b/vexec/lisezmoi.txt @@ -0,0 +1,8 @@ +pour compiler : +gcc -o vexec muldiv.c fpu.c machine.c main.c + +pour exécuter : +vexec [nom_fichier] + +remarque : +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 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 index 0000000..5f8f1ae --- /dev/null +++ b/vexec/machine.c @@ -0,0 +1,2020 @@ +/*************************************************************************** + machine.c + + version 2003 !!! + + ***************************************************************************/ +#include "machine.h" +#include "fpu.h" +#include +#include +#include + +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;iMP=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;iBR[i][j]='0'; + + for(i=0;iBR[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;iCA[i][j]='0'; +//************************************************************************************************ + //***initialisation de la MP + for(i=0;iMP[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;iMP[i][j]=instruction[j];//***charge l'instruction en MP + + for(;jMP[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;jMP[AddVar][j]=variable[j];//***charge la variable en MP + + for(;jMP[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;i0) + { + 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 ; iCA[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 ; jCA[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;iMP[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 ; jCA[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 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 ; iCA[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;iCA[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;iCA[lignecache][DEB_INDEX+i]=etiq[i]; + + //*** initialise les bits d'ancienneté, de validité et de modification + for (i=0 ; iCA[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;iBR[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;iCA[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;iBR[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;iBR[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;iBR[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;iBR[numregs],deb); + octet[0]='0'; + for(i=0;iBR[numregd][i]='0'; + for(i=0;iBR[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;iBR[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;iBR[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;iBR[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 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 +#include +#include + + +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 index 0000000..cee674b --- /dev/null +++ b/vexec/main.c @@ -0,0 +1,45 @@ +/* main.c - description */ + + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#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 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=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;iKL2`|%sOjYHg zF;%6bsw!)uOGY=;jvlM}LbT{UbylJDr5=3q)gSKxa-=@8@I`vjS=aZ`-~7tf$9?hL z4{wg0Jd(YP91KhFN-`Ihw1VJU48;W*gjg9P5a@x ze4=i@Mwj=+H|dw_@;ACXO_z_-Wdr(h-Cv=oe2M*kuIV4q^t183q&g$SvG#ZNcFxi5 zN9gu*@jYdZY47Kpq1)-3InF799c8X3suV`-B;>w0dS^eay;)aH@2B)ZK zadmA?QA4D-K2lWVz!gg90!KLI4JE}j+tcQ*fru|Il*+;;?rEvmEO=}{7U7K1K z?tE$eYWJluU4Gn!kmy85-8l#Gu_dSJuaSLQpCpUMHNm@Cx9hKNQ?z442FcT2THpMo z>VIcG%HTirckF|Mfg6LvS=aXGrQd#~IJG{{w&v{%*Gr$^#_w1jh73bPJc*SzVd z@XiYZ9s9L}ceWIU($=9NJ-jnL9Lj#uSrupv@7(2d{MDmw23dILG2txq$-xl_H#qr< z>|ZZw87<+gX+oHDOnB!-fsXyjd}b(ZZA&5h9JHw!Vjv(GSe3@Ep^n!f0X-U*?Q}pN z%Q)20rWuDegul&i3FneINtb4{_k%+!HI|Rhk5W*2IE#lrqRhgav~}4}hQD1EV9)k9 zW#H6#`S=2lxWI?Fp#6S}I6sFT*~DmmGPqIHEz${5dH!aAgehzyzRH& z?Ap~F-hmSQc>-r^_$yUtToaJumnb%_NpB8!;UI0zQQBF%T8$$suFRDY?vN;Q2h`?)pEXABRL>TcoG z3D__&!lq&c;!9Uc;SRgF$#zU7|rM%sZcc@mOPDPjPZrIue7FI-gOqi-LQjpzry^#Tu ztsBGJP=w5F#|W5UwJkloLs)IYK>npzZEIY%%~=}g7}65nss{}+6H&MB3blr}A?RV) zoj@|Ah5)27ZjNLgENkkrTEg2E4ZjSj!;aHby_ zPUyRx+)qPawvk5E6}HlJC|!u1BY(3jdyi{rx61K}dJ^wG^_v03|>FLjp2!J{_A;WGG~ zqaA%DJv_VVZU{9{zxbs%b>p&JCyFVwgRTJM1*ajO2F*$MYRiSv9s4FW7P9dxFfh!1 zCd_uCe-`0^iIit$DbEVgJFbIm69_04?z58ww_{qhGereg!qYY)wTea5;#|=9saVCv z`AS7$_SP31uc*kfuZo{xyi_rUz*cc5#(A9minuxoSMThT6j!!KC- zENaE0a~ju#RB|!I%|qzr%1_!jVZ%E*PSVU?z$uKyY;(Bl-9f|K{$erftC$_1oEhw< z6-AuuQWI7*eGijyRrq~`Mryc8O79`~zDHx=`+Zh3=&cIB3pivx4NN_G*RS%TkL4DUP2uO(*rul?a2N zn1e|F?y5j+^uYXAc?iDK!&_sbhc%^5wu)x{S6_|>}#VL8`zYI1{vfn!uK@nBU{1)8`oqtj!%moju^3& zQ~c!ra7Gd?te6AoZuC$%ExlV}i;VfB1F^8rN2g2JX^?axH9D~`I*}Tk*cSmwIz5U` z>g)lZ%)c`w%MLOv&wjG-Te!%o9Ie|D@Xo`)+v+}}2j4-b$C)qJNA?{V{v z&NR&5B|OQRK;O9%nPGGImX`1xN}GF>Hqv!0{E7`AyBB%myBVu7l=nW^yzr)$@J*~e zSvud*5@s(9MR%4SUqEh4_!g4QhJv!fcP!`NY*LxpoNPFulykZzz@@P*vpM{5a%*e&cVLj!8h%Uh3AIcJHm)gckqi)EO7RR7A$KP>3KV^= zq6hXiJq_p5D_cmh%H>8bA0swz3_pGo#@>FP%P~iBbXh13XikeG%qj!C83FBwE3yTf zc2MMYDl)`Xq-RikhP{&?uEAJraY2K7sllx-$L|HjRj}s|SLD@PQRKH&B-d4>XHfhL zv*U+rFl{f<;Bjhjjmz}2XHaZ%>2X3sML2ieXn-(K zq71%?%(*pHxu!YLQkaWWS9TlSI<=kgQp>`e#`VFLnYoQ?gXr404w7?m zX0cJOb!-g45Y9%qnzu2X$3lZ;5j0sFQAR5~llfU!2q&=5;ZQ`$_9EzbmZIp42KiCd z-L95RPDLGzr7qCaZZ#NYVLXlNvRa&D0?`v>0O;DKc5Qi9p2eNiw4(#rx6AO;TNdUv zu2&>k*w`frc8_C71daA1xj8`)n8h`&$+1C@dccT!vuj}nZk@R++^IA4M1Q`_z|BzH zYLMj0P;#xI&{EwDMUkW)N*RXI_(D)^OmRCd!A%lf0vWjIiqtgGO#mU>WT3bS(1)8K zbxz?XVj)SdFL(e($oHT5OrpmwY2pBRtjCJ8-(R-DDW<<24-fe4gS?lUp%vFC)(WT(RH2%+O0cOeT8QrY7`l{NBI8qNNk05I*mdqjp| zz+ey{F3BJqgA?g?-oxMnVO%c@!mn{s-u{AtEEr?1Tg&L9WfH#U%4nLzFj9v=ExP{0vO8X(`^+*qvlrC>c`AUNRSKM9273Z#1 zxRZqAj|uwS2D)dPjVq}3AEk~JX znHJsOyAshGx%BPQl^20=gNM5K^PwG2Ed+mcFhtdw$sp79D39-GyO%Xx&qXhsRHiBqiIdFuQ~CN>Hl&& zc4O0<;mh6HG%7@5)98QQrgtCk!)Y;GG``o17NvFyHf6or2kyRgc5zvL@)kAoST1?tX)KEpu-(inQoH zawzrvT=DH05?T!ak>Tu&Qwx`(p#7gFd=j$uze`DIszgvc`Qt*sZL=6Y`R%{ZJ=f&M zG!(R7VtPn}i&B0E1Q@`IJy{mPNirl6id(n-e?u^! z|JMzXdPc+<0?unL)vL?za+@xfdi(M_;s;bW2KLe!-pHc5VdG7FEhn}cQk;Byt+LYS zKMi%0(JViX$rMqy9O{)jAzj=Z9fhOWbx7ctMExwIKK5$IZ4B=qkQ>9>@rm3E>sT&; z2*p{FD)Ed-bkwaaURfkwU0C`Y322_rmA}t!lO@&M_a3fITn%+l+w=I(!rnj}s z291+E~ou$$_%p)P-+?}rQv!C_S(?YfC@~?JY9ob$HzDyzchoA`907)mPxLqcHAn1!aV2w;RvrBZ0v-VxkVGkRs-}VFazlS;XIe_-aPlEFVyrh zfwG&pqg%eQX)uQ4=MaI8xp89_QknVUGkvYeZ~WeJ7AUx_cid?2R+GttHVe=msKvz1 zArlb{Qm@96AvF9)Lc=oS;3_oyhoRvZCCB#fK*#)82CgUT87EUJ)bSU;u5cqxF6H^+ zMw)s{Vsr>}%u;SM^7T{^E5c6#~40x0X%;*Moz4r5|SbG@V>mfFh}_|Qwo)t1zYhmpnF z^qHNlO>QT-4F$2Ym%4@aO{g^?I>PFOyytn|*VHtSp->)VQKbJ+%T`NaUgNqTcS|D3 zJ@|kp9xCaS7`&{L2?oO$1f#27CJ;!l{!)XOx{q7K|K>6S$M_iESoqXaIQ@{smg9*{ zTpsLfTyq#Q@y2C4xHu2TWmF{RO!*DF9mHzo!KL8c8r}g{c>Q_U53-*s#50wh1)F%0cy0Dmfr1x7 z@Sm0_!Y3|*b!I>1^v3yY;g`*S8@e6AYj8e02_W`we}u`R(4D%9}Gm^q2@7jebcRxu#+;J_cp$#m^N6C~wC0uIh92VZ`UTWbJocbyb z4zYtGBIPO$G}8P>z8em`yRZv;?-Kw_+bEH;jVke4kz_JB+g5RLI|n!i`yN9s&ci}H zEUYi@OU-a^%W)4j(sTIjueQ)-;UwmhbScTSZ4KUld z>p2;)o(}NPW5OZzsBdTMxF#s;v_M6TPL#yK!<66u4Z~}EA;;EU#Fh>d7eeypcj$+kR8f}uI|d^hHBSyog*-OI z)wFrCJWQDf4q&t#Uu~CSUB=cNqg)=!sOCQ?X{(iLJk`7dl?XUH1|i@aq4yGLW(Mk( zLP*=unxzn*i@m??>A^m-9&bnde~V7+bgc83u-7b@zhzFaaorO1Z5hBVTFi}KgFPpRGkZhHI+u(HeUv7qslG<2~GV-|X8hr#u1C$?rE zL_^j9!#mLn5*Z$Ww}}VFXNHOD3=FqXy;33Gxm<{I8rzohvGa`fKS)_5d&-J$e*QF- z6}yFm6~c)uY%-H~U?v|V+toXbYXREMmfSw{6+~s_D{4N!f*hlhZUtj-fOZe#i_Aqf z<8Ej+=PF-KYYFNLa{>uQ@(f3EGZd4XAKDKC)>_3UQ0XF|*NWiq^`t)=O$L;HI2PDt zh+BWZYZtQJR49A`5-lPiegAJk;W{X$P#EK(@DM7^x}!a42CCG8150E5)b6qq|2Uva z-#u^u28bn3p8&4Qey9)|@SSOhxn?(>YtCO`R*!eq1bX1}zY{q1LJHH_|AM7U=0E>a z%fB#hAP*BJ#GGzCRBPOtrq(%JFe0J8EQ`Ye_(=1nwOvEjwhd_w=DgO`9LD)9{~Ze^ zX_ipK-OcjK3qWdMlA!68odbirjTL{&GX69%1cz!|Gm2-QY9ZgrL3VPNlB+s2-GDJz zZiGq7l!J2`9)wMNr|r*Aama0q1mSHhh1;47xAK%=X|OT8wHN-g!rHF%wOiBC!2e<+ z>pckN?3N^3K(YlSI4#4J*p=P%bMVB)ah|+gi9?wmKpp?=2CHcLq)=lU&i5MEjG@j* z_qsp>`mQXDE*~hg%xvT37|a^GQ|p|aG-;r5jcj(~zu9nXFEYlh*<%BvMH{X6`v2_O zbxe3WFF32-uu*469|604p?HK1#&rSaZ6oWl*2A^-`T>s^>z* zF3feVAjrz8&+|wN5$duCrH+;FV!qzF9RDha>dk$U&o$_OxBXI399AbjY zRbnM|8YI?vtEKR*=EBz-m%T35c^%NdZmjc`ZJkYx%QgwgCXm4MJnQ^Lp-t<&fI|=H zu6XOnqb`CX|7!=9B-ld>~zQjUg$XE!nKds|0D(9?k~f4GdX(>T>6 zX8kR}&_SD)FF91^^j0LMoYPx5r%|Av;Q~inYt|ph4cU84XlV`V=e@aFn?dc3Y2k_W zT-+5azU<@USODW)oVel=9cJ8iy7Y735D0AZ8DKf6Lt+PIW=iXvJn{=~(Pz~h$}3(^ z#gUmdfDUe{%E7!w_yz9ujDTFv>Y(k@{DI5m1w{zt7b0m`yoYJ+GBLDElvbC zglyq(^H2e9jW0}b_ttZDAH6#1|1vYJP;<=8j)nOU5rr6T7UjyQF(vAc0M7b5P}Z z6g^#yKX#lxo-Vk=kDs|)!n78D5`{dw{EM<*e>fHx++<}Yg{Md|LwL&y4HTzHqj?st zaXbHc3Fp1eT!}17Z6V0U(rk)fKg8m8Q~X$pZ3HkdPyV4z5MOO2=yW&NCN>N}jcbfw zqXYa|o-tmcZtz^n{~m)G!i@zhv~(d5vik(P``PHu%E6%3)8hFEbVgOVO*cu2;lz5C zZ23G56Jt^64x4hI=J>o_nT|@OvfLQnhMw4!+Kw;yN1rPsZ*RIVAJ2!_r zu}OreD&SH~7ocpxefpsJ5eCtIdH3qH0tmxitCO8domB`5hF+_4@Af3>^qudjv+B3( zrk_e|KkXb(C=6oI`w>%!)aboes{o}9!_#F16_W?{s~(BMEGSJ=jiu09G8( zJuDk*5@4x;*q~vA0zknjo{l#NrSbU16-jlx41t9@qPrEZ+n~8V5y7?F zc(vQ&)kcM=jSI_0ZC+6}YPbJ7LG6PqwP$&1zb}+V?S~h;6Xs(mWYE;yk zqKyu5hf?z}|3Q`T#D23ib)Wmn155k#&VQ4BE9of!X9E`fm7qsU5SPM<5Zz>^oZpfN z;hDU}JI)e}29aRNeVz=7fXQ*l&u;1g4u3qmTO95JiLs!@VYrMd2@X#p<1q9Zhfb_K zNpYygx)Fy%7$@8cEE|XOJsj$O<;gHOV8FZY4}Va>AeBGd3=%Ugjl&=rR}vhq$GTwX zH4fXcmg~K%6*U1#o z;&y}|s$``PQ`E%qTPL4@;X&<}KHRLDTzGvV(_x9S-crsP(!t99hY8cQEW^mkVn$p3 zr`O~vERq^`<~FhM=(|Ka9SeGngu%;-T(4V{dsdJq^gh=97gl`3SzCL! za86?FTd_D8dTs5_k9@7&07?i9TGl=Z=eCK~{=H}I^X~Mx8*9U?yFa(rBUn%gYi?JR zOO>CsHzNZ`V(sTtQz~npnkZ|hasWSTS8G{5)}D(dgR!>uYCIp9bZ+;?LS^W+wa)^* zkG0=NC^wYa+D8cIB-Va0(b}1sbKKm%Ez#NwAEdDOx&5kV?NzsX+H_;>p3UvQ7bjTz zg3_ec?f`5_ti4G!rLuNqqO5*emQN(VSj+OUcBy4OZSA{oks+zI_r>yRY^beW4|*SK ze}=GaD7Cex3Fjo%UTe|oxjj&Gj9nytvYS&gpT> zb@E&ni+c}p-OWW}XxC&uIscO&F?i_ljsK^MG=~_wX1<(=bV%q0Kb7;_=Lk209%jG~ z28kT5oTvT950x$tm6f-6HZpSn1NO^xdzRz9c4oIYJP49F9P0*7^$UuchWggyxl zOVv_i<8bo*emLw=$h{yr_qp&Fi8x@uemL~ZA6{D6Ee`jBBo2p>AEdzHPAqhWUgOZU zmGnt)xLl<{HV)I}G&nvc?(g9cx!IFp{2>VrJ@bdPXLO6hZ6Gn@((@uu#wF*riSy#; zSON^a#$m_%DR8J%ONNcZ#QVr19)}}69IAd!0+aI}cdDnMLFEVK{J%l?;Z(Kqf;np9 z_~iv_b%w*Vn!OYxlEB`pn%uC%CX!fN4aXR*UQ7(%>u38J zp6%;y^!%$EYhw=dAm{(XX$jU|q^5R*tUbu0*Vg_i=zXmHA1vyIv$l4=a86?FUnAHXdTnh-bB?q2#h|3q zTGl@G9(InO>BXM4FS*|1ZmbQn?taeyms1n09r>wL`C0oztmwqZ$J#Herc~B0Nt6}R zvV5|@rCOGcwa-M8!B|`SmbX(_doL_hhF)8{3iLkK?m#Fvl-k;pgmV&Wzn*CA0h)81 zweL@~cI90Z7H{qIJZoQft*1>l*6!Kd{-7|y+Lta!YVEH8TM}z;QBA3=9Zi(=V=c?a z+AUg^kG1P8>uGC0_*M#QABg4E*ic*hBGCI-`+pF&4W+jBeBqqL+OJsjdTtNboa3y0 zw^};vx&5;{{H)#LS^M6rNnmpR^Jn|6;=7;YeK=1H?V8Ld=U)dBgNGj9lsAdA;K3m( zcQu#j-bh3`SLk^yM&gIM5^d=31wC4VeZ2Lp>~;>C*Zu7M?K?bFRg8GXphSh`Xo3ssRhBtVc~6lI6UFuuRgU6-3 z{xzpt9PS5691e%Ro&twoVhJ$x8i$>KBYhGaqH4*oahQ1vS;XV;zK6q-RuY(;fBH$D zh6a@%l=DA@@WZKU<@{%;iQ|_SyaK~>%KPL6kE$j&?3e&=<@_fl%G#lv(=Q7w*0KyE zD+@fq@;|*&to$o+-)fYL-Lu%+qStns4|)YM+BYhO?oBCHB)`zIp0@VWe@8)|D`4tgJJ_qHgt zwa*gHNvypYVcu}ob30#ij8NqY5&9%J+@;bW8;4>!@s0O~dJl&yF7ad-e@KD@ zs(X<0Z=TXE4o`w44u|nCroiD5ECGgI;}8=1Bsi>4ONNcZX{*U19*4_399FI%fywy` zkM}e*sQjRue?7tvr>d0~RH%vLmlte?;Td0j@`C47lN)x-a&G1PrzXnUshra<=daeX z3?pl$m}~i;UMW^@pq-NB{QFz<+D>PI-e;xgvMj1siX((`l9l2`i(ao3nVNIlN^zUE z{T^OSTzDl-8=n{4;@N)H#h!n4W9^>h1%IEIVC@UkwD7Zb$16##y-78tvUX*ntbSUS zPhN1bmgQsZQZ$)armcO~3n{EU&Z5`Wt_Qu3wfk6<+S=2Ea}sN>MX)!TXloDDoa3y0 zBPcnoENjFN;!JyGl4GvG#`u+s2Rd+&)%w zjMej`Ur{uTo2c{ruYRpI5fXK@$fVr%J}L9wV*v zW$2+7LK4Sre(i(o1Z;x+lqBAO^Ol@@x_6fD5S`^=s6L{z`v90cbpTgfu2f02y;^fj zf?7MCOQBZf9~0D?7^~KIo>~n{G?Zyjq zA0Q)?+oTH5^Vpg(!D)Lirr(cG7}J@FempYOnC`^#5I3f-XMD$WzFJ6v)|h6mj2Y8m z-k4TI*Mm>5n@J|acn{okd);oP+e{*W){!SOg$csQJ1@5wO!kOYUG`NMtVy2YUhBxYP1 zhh8$SBseU`Dro364sSk{0*5)EkDC`Gmy<<24i|bj%sbbUp#y6JWHff+zm-3sqXBQg z1z$HKvrf_peE&N(Ke4u z=r8N2ZJxRpfIs~t1a}C5tfVVJ&@qm^?)7@rcGqi`5Fljo)jnjjXC~tsKWNvab*vh) zb!IhI%^JTmtGksI{c`P9s>zML#E@gP3^FuP)&}L7e!C_|YFUPnwQDj6O~(0juKm*| z=zQX=KZfMk6?!}DYv{GJ9t?V@Cxf&+VVy;(b8SaBC&{(1vFNprZF=0-$10SM1@{!~ z#J3JyMz!K6zysa{m|NrN-Ho*o2zqdL<5|13%HwXV4YTh4uE`?^7F5ET+ou#Hwf06V z|HR10+7GCvRMrkB%KBJ2fSn_Nj@ob}9$(vv#$XD9+4mHC&2ola$jgNeyhc8a!=%Dlap+NMZleh&hb%IvYgz0>2K?s_!}fk|cN zkMPE1CcqCm`&)OAc)RPjK4*WogTy$6#&PIxU3Vjtv5CWDmQ!eV`|JVIixVZD{WWUW z$n_TaNl`!77~sKHUGBL?H#qbx+kbjww>aDgk~kdpk#R`^m59S{;8liRVq{5;HFC5B+6aNpQFv>xH4$IDBw_ z3LF|#-eKb~wt+0-aX8w;VPUB!qZ=H0<`4HD&@B#^fy9hU~=Nunrn}jl$do{PZg;)r2!RQiL-RZ{8Q1thXMa}>7uT>e#BplY z_?`XzQfEIt8RF%t$&I}XA%NOG`x}-h>qX_6emTQYT9#pCot6wnlW{(sGo0}&I-fXe z;@RK7VP8Y9o%K-A`{WESSd=c)l#ka39!hU z0Q1lC^zO#mJuGCWb7u-`_r=<4=(V*Mf!@d3A0TWSN^R}&!a0exAF=55+zx5Z)Z2<0 zm#L-0p4&y06c#_XZ}Y5u`A1n(K0c{Tn}wZD zWexxnpHybcY1B4FD)S5o5>lCayX(~?1SXX^1)3WJnF;WN&i-D&(gj3Zzx6r$yAvcv zrp9sD?XJ5K%Gk5NCoHGX?)Ld@q!%YjJo{_XuCcdpk}cjTi~U^VQO`AM7kIAG4Gula z_Mb%r?*@mTgCq`zePvu*jZ4Mi@LPD5q1QNc+?oQ1Qne}uEgX)Olic_zvcbb)@u{8+ zg98S<`)7ZT!#>^Ma5YHGxU@g)DdS3l!xdOB486wTpSPsIA*%8Y8;5aaWD$?U+a3-@ zr+6~D!J%jV@BnUD=mv*okeG349Qw+*lHjls>!6|6IK1!yvvp>mQNkHfz` z98N9tWayB2K4kRt?C(h{yyzi~M|b1jRy==7hk2in`GjR}9Wp<^8RJYm`}_5LYMUZt zt^z?q$ZY7Y*IXemA#>OO&rHTOe$d(9)tI0_#Lf_pP_xGG?C)1P`|-&TuTV{H>}4n= zW9!=Ah(uX0E6?=H8IIAi3?u8bBo9r-`E<^3=FjPT;;d9IHhArTeGR>K*3qD+CoqCr zp0L59)Hy>?I48*&Zm{UJkG+1Aua8wJAG0r@9a2oS;wM1hG5_>e%3D1 zvV5#P1x*HHZEgO`n55SJ79rixYirL1y&0rs?bj?yZS9f5If=EOPPBH{b-vbKooMaZ z3;nEpuxITHW_fydW9^>J?Txr+k|wpRU4=`}1_(A;)_xa@JDYs0y-qcyvi9kTvK%c7 z0bSIvJpWuR%g5TMpvhQITbutfCaJaez}jo*wY5t@Zw6^u`=1EghEiMmXyKg1+K*ZE zdT#g8oT<0Pxmhh8_S`N$ox}%z!(VfGNQ*OIn zeSA`xk1gzUDl-yHFtYgDnBF^y+NMZl{s4l6ROY_!dR-<2CY4#x+Z&Ua00q%%j49R4 z*dO2-6k}G6M9I~z!zc&eY8mSbF)M3ikaInge0`#45+gsqTlvL_^8dLyh5R$Ho~UF* z=GbOV+Wqq0WtWzbV_ z92(Pw(nVvb=Mv@9$OA4Bz(CuN%oM#-jrMQ&KSYq={??4Ks+Dv<43ap##>zOhnc6ed zfBhb$MyJ9U?);~M=HDLOfORi1zFq2R{=ihNITUx=mt}OT`94Z>+iRawj_fW;me-Ea zS(X`}Wv5)#{EC%l4Cn8~8LSVMuJLQhJs#E*PO!1=k5SPDup;wY)`R%*BeswP zUqWI~v>>|N3O`!4EE%3VXbr`eEy)L6=d1ZzPxDK|w&tg%cdPm5y@bTJ+)c`H{Jf;M z&d$vEEHC-DTFPAre7xkcL|KPwSw3EJYodYQxt!3rfN2>2D79OCz2tZ-zs4bSj&cLZ zT`$prhmYUIc}Y;Z#(T;89@ameVq@KbMaD=n0Ts(j4<00`Q&Gq^!CuzNt=;1NW^oHT zAi;`_9_L!a)XC37pf}!X`TkT;(s{9dQC*%kWzOX|+-Uhf-U!D}_Ruq9!XnXwG2No# zlRc)1)&$UF>YHjzE3wiUK=qj3S>-#XpQ<&{9@E&9W5(1MKP9H0v?`s%7QF)SCvDvy zD$En2;e_O>i4cTeW=BoiKXKd=&Q)22^aONH;|t@=k51#)*zi-a{8j0+NDe>oQ@JPN zI}jP(F^N(U7{CBu&>_dN#gX8H-}z2KQ7BGD4*YdR{vvhTe5hl7cFn*ew!yj%+guBt zb|mtdh7RJH>8TBI$z^md`*-QAaQ!WoE$bKS=A2F}9EF7|Q>Sa+;HQVutAJpS-u?H}P3*l@#o7W!n8h_U|jGx91 z@yB0-{pE+gJN||rIs@?rn#cV9^+0g#Pp;z)igAT&at};j`H(sJL#%7 zHhLpdQ7IVrYuiEod^;$=`%aISzw@nst{Y+PNBD6!jF>UN{GKm=R&*zR%@cHL#BX`z zy+E#hDK~+OFzIS1drBDEoO6WuXLEl`uwBmVVwPkRq{~5zRpPC6+2P_cY;5O-Pni zh(PWyW1f6W0_{*m%P3CLwkttmh8M^7%N1&o_FLidT_Bd4-7_jh2_g)d zz@?&zA3OesJI!vSOu-$E%XS1KdHlRM8=p@0st>@Zy$v5IW<=`SU&A3rmxr&mKOYt6 zJcHpp_z6P&JNC+D+Qems$dBJDr(m2FXD~mEDroCv^I|a8{`v{nchnhSMIsEpCf)@K z{_Z<}8dv?^VW&(I{=_qc#mO+gW^KzjQarSibE26tvLNFQn(HK#G$5f3;cq!ZdAfmV z;VjK)|4vlnjNtE-?Mny zK4vWW(SA6zu#pCCmqcBff@CxaLyg149clt${0Ka$E_go-6N$;8_FaO>>cZv^S8TtJ zjv=|$GAQY~`y z(t2Wa>L~?Z;%AAo+U|fZE7tQzL)#`E4&m44Lao+Dejc=L?Kgp=-e?%q{ATOp2Y}9L zeHQoiI?k@^9%K6nM}1e1A5qUb{mi0;>sy}`g6H`O{*Bv1&4Y%wO+snK`g^e=HAjXA z6vlzR+D->q%b?*cplRN|aJ}Z=ykl0=n&^KzwxVhMYU>65&^`D} z9x%O=A3#5{ck6jZzs8Q>u1ziJv`Oaz{S)sDo6hMg*6#~l=C<9Bp|&i=j$ znpZf9C48|ovv3AW_+n|w^ix>E7fN|U!zZJ}FDcCkOKC<}mDn$D=nUyMand~Y!w}?}@t$`>F!Xo4&%7}h+KTrBHwQy+)>lN0cs9y}*HmKF-YANZyFj zyrc6@D2_(Tpi^E+aY+R_xeehOQ>BE*@R?h-Sn=_|a686w%-fn*bzoUdec9ql3|X}F zhtTbB1pD?>x@hq(5=xizovPZ!Wi^W{YsyCB$mwH&KHUR6?`U5Irq`6zx6?qyv`SuS zG_Rz#x-LSC&aN-5tSPQy$0_Y4wWY<21+l6FyXWfRW77(k_ATnt>4iMwYi>-FKscI=2YJ9U+YvI+#R_ZRQ zGOmAYrJ-a%iPa0r##F{o#`6?PQ)y8q>dBDh3W}jL-31jTT_cNO8cK#bx4WT?sf?kF z=P8t?(xUWKvUqxxF_flz45g_wlnlZNdd5`7P@3+Br%;+oi_%lcqVy_bC{6bmN>gbl z8T4H}9Vrx^918Fn_EsWWt#iUoP2ev)@0rxcuG zL<3^HgW9}&$nv!CczAV&2k8u7o6gi3x;R;VC??;*ikUDXyUz4xo#AMt*mWMAr=dsZ z)!B53{JfF4bUqVehE-?NCGZ2Csq^SOU0nTUcy%_N>1)%OIzuY-C(aAIw5NpUx>j&zApEh_kjFI6GjSY2LmF&8&b;}aNViq<=|lJTnpMfjFe{MG zPPpKVnq8MygEda&Cs>7K0aDpZU48B1`r_(pqymo9cXCGPfj5GokKYW2c>LddkAFKD z+Jg7B?|8D_u#V$pZ$sOFt-;V+9|c31+k>G$e;y2d^HngkW>+xu@AQn&<9#ziyRtGu z$MnkxeU_aO8opOX=+pf&Li-QP2z_!$Mkuc!Bh+zJM(FFKGeTL%WrQ~1J@)vF(005R zOhmh&tWk7S$#~10!g7H~ zz$`(}?*W?u(E#*-KV-MO*sw3if9Wm<2L{|Sd67>v(9%-J0mBU>{`VzcGK9|ED z`^%B~I22z2XDD|0RXcr_K1Ls=Z{8C}Pah9BFT3;yfS$g6HRzQb6!79XWx#2|=Pj`R zO1z7v&n{|+;1r=K+E7+X8fOLGS~>cxL*?$md-Uir4NDtJ%jz1&R30||h%seVXKGH&g!&ozHK5MSRN1#{W4)jVN&R&68Y#c!W>H8}Nhk<$e$VS%O zgO9Y#zyw5x^n=JU@Bj}FzJrY)pl2W>Fd4nl4jm zg(1_&zRjMWqc)Tgc%51tww*Qmfk~)WAWZUONE3*X?XheObg*`n9FAjcv+&zYVVBF{ zE;4H27y`U>m41cLF6LpY5Zp!DE9G!c(q2`}&o1zVj(f6kwFo_glCI_eGOhGRfixaoCwiShHrI<@@1rUG22qBd zoPMLwKFq_Lq;_9+`?=I!Ox=D#fq@5jc#G8DLut24?FX#ALk?H6_HH?Rjw0?A+S7RW z8#z3Qd>@d3HnZD9qS*r0J}jCYPTI$$_Cy{&F17pe@JZo&H?9A41u6n{?DovBA+vYz zbL!X1wr8J~iZxW_H>id4HaAX*Kv$}4#Qy}oJPI+%z{w^i_%!%Hy6jj;JmCp zXb+y;4nA4OvT80HoLt7W3&1{O&?y`U=*NRTV?Xi|`h!59F?c@de~pivjA4p?s0`fD@2}`X zPT&Ht$r!d0q(LVZTR`*57uj|*w9 zev9!L>h~mQdOLgcBhfeK zX@0EX$DjD|CO?FPALvM1_b25O(BRn2<1^RcJ2QGO?gAnXZ$kUb^FE@$VZluH$y~zE zz_3u}DU^Q!%^Mh&mH9Gt|CuV~WNswoGO8UImYcaB_-9`9ED&=Qh$zaM(L24)_EOQ`#Gl_6}y_GkZ8b6bByV zkO)m;_T{84J6vdw!RMY+Nt?qqr$4Qd27=toNts`e@N8m4cmIH;b1suoFmp96Qgtw> z>F(lG)xsU_-XAoXHOjs@kV^i0m7+sh@8BIc?j58j^l!)EC6F1){B7nt_|ANA1U@Nh z5}7~5iOQKJ%pWE-L^-{>a6qTsn`?>_xRkVyq+|K-9efl`8KZG{XvVnAZ_to2mQ`d) zCK-pZADQ%>DMW{73DFo5W!(>*GRE~rgA+Iz9~p;}Q(zkpkGzAmcsm*6#ouovyQ5?o zzX3cmj%GOi(Q0U%w$BadmX?t|1v%9K5<9=dJKzk2KEX6D8oQDFFo7B+84^;TF(vhp z%Kt_Zr4$`0ioW~5q-f25L(#PUPEKb3v;k@9p?yOmLd;2=wEk&1nFH{d-f!Q2Bl_)$ zY$32W7LlX-9@BR^PO#F4qtLhSPf(9bg6Sc3n6YPC+Ma#;k_djZhf6;mr*^&4(8jKz zq0aO@$AF-Bw$oRb_0gO&*xdI=7LP2C2UfVC)zWVyxDUc9W%gdEJur)1b27jgbAeh= zJEg~f1Eh9OMTf~qv6w@9g2Ay_aDD0ne;enjdwf=a=c0m33?{(ID$f&797D>qZ~OJZ zCnKwq=98*Bj>*+Y;ba7u)~An7%O6~D^!`KA_u221QwI+@Z9yOnOz_Me96X1dV%Q@4 zkd~(tTE;{h>c_yJ$1E->pMKjeEUJt& zu>Sm#hU!IfWX>}d*F@P+SyEebp5s(ve_?b9WMe3$rDf%#E0BXak)?HI4LHPfKEDK4 zs&I&zUo^D{oysd0qlj6&m>h6O$GQjafWs@8v7`H;)7WwJJk|j7q%D1H+TcS6pE|fy za0Ti-gG=8Zl}86MARjgN&<=ey+2GPc4;^*%V4-F#{jcfCX{`0+$zu9|G%Xbx@vJeu zcbd`yK;mrXu(3rEr>H1WSzRUvQzy@!bxP6nS(9haoHHXlKa9gUh4Vq78fKq_L-<>y z4Bvu1m{dlJ%1gin3~3GFQ(skCeZ)AM<%}8OsS{@uO$pDNJa_t>`LpL*9Lj5*h6-#p z=2<^WEWxE5Xbn8QZ-yy!|AN3R1+yU zLV8peFDa@iD=RH4Eh?|Ctp=4Ez@kX)`6Zf5ZF#xSHZ)XTpa7A<))^Otw1)D^s*;+B zB2!Y_N(dHRTO4l20g{F{23A1C<+DMu^mcn2uMkv4mHZ zM`=Y4LObR;WlNm3rnHKK$9AEyFqkWkQV^Dw(JiT9o_wfU z4ZXl#S{x|`i`r;pQMBBmbe&LjiR!T-A}!LIihG@pW=P;($K(_{ZZxWkm@VG3dU;jx zVtB6B1ob$^Mc+l(YvrNc$(wrCEG(+7E!EBtk&$7}M9P-vIa;LZl!I}S3c45#SYrrv z5p9f^xdu-WpOP>v9kff%E1EHJ-h6ab9$9MQz{hazo48=-TfW%Wz-bZS7CsX4uD7DX)FMt-({DTuc4I}cHq2yKtO)8FI1FGEG1d0|nyShgHOz+dfvKpVp~v?A z+*ydH;kk1qlwyHpSQe7S+DQc^eT)(7DP`jm>l-z26Bp^}Q)kVd8&>@1q1LsNav{`k zni37;l**|XTTL{wCS**=wVhB~t;C?A0MIeJ$^>MHk}79(!_w+V@gjUj>eY9JIRZ^t zeVsG9rZ!SGdg7$%qawwNozWG=4HeGl(xo-%sJ6rruYtcvvN zpsp(7jOIjhMspT9qsvi16K=Rbz!FaWb(adl;hGrA;FTaT2dRDGRYLYcMb zzNi7Un9sba1I=ZNqKk`)F;5qlky?s%(M6oVZn?4s>!TrEw5Y!9JX3;uP^R<(3dk#Z z_}UkA%o2F2l#A;lxhNn}bzhP}pfn6`oO21?NYL?=BM)WsLIx(U0(>$BBR^h$nFhM+ zaBSN7%{L!JL4quFye_ka{P33Z0!_p8^mx3H>8u*OttSbbQs}ZRoB8zw6Mjl@0nuI=+8~x1nR6zZ?Tt z{jw&)7j@-p1>S~^>1xg<$Dz&5%gDV96{I6B6F@fsbiHumVqSUrfE(7 z>e`!bcJaAh(+TFFn-4l8i?rtWb{rEE^5gZc1)zHo$Fv7uq$AGv;cevd_QJe(RXwWZ zW%xaWlA#+3x{*ofcx$Ag%LiRP=nM}sG{?_abi6(|4s=sUpkJipdkx;yljGohrAt6( zY=A14-yd;Ix#mT>^Q;PU_$mm@F==k-nKoXI;BmgL{{<9zk_Oi=w(;E`Z(?U& zCwDr|U^eKNIpnt`#<}SmU;{tRLwzCMv;}eJoV59^g2G=jfa#avXUg_B;~>lFdW4L3 zs;ne4uBoz;!1$%gl&-EftFrQ9b3Hg+JYB^d)vgp`d{JfjlIzW?%u%R#p~}i&j0>vF z2;<1*J5^Q_mh)Vdv2}qL=d&u~p?SPGZ&f*4%Jbc_@>p}-IbEy*Y~jy}o>#vehx1C6 z)k?wnqsqDblI!TItgfzeKBzLc9lTe1Oavs}1HDEZr8|7S%zLFfKlTbZN{@+TEDwrn z-!HDr2VA^Yx--Np;3yqlWcx+X`D|D09R7?~;@lV8PjO51z0Y%E=d;$V{{kJp=X zE=?}~FK8dG{h9Kaw|MuW?CG?lZ01uMBGFeU+xny+-Kq9Nx*xO?oT`I^&6bG=<;t+ z{u}&#s4hQ-^25OMC|!OQXJ&+k>Gmp=-^cu#qs!-_%oox; z(f3M}ZF#q&JP^;%oQzb8{O?A2$FJ}_4E%~^-c|BC=F@2DpXKl(u<4(N_27>v^QG{2 z9A2|E`O^Sr4~Liehx{=ZItw)9$1B?Zgn#q=i{;OB|K*}DatP$MpZ_TsYSHZjP|n1B z|BEgULwTe%zj?#JA(p@L{{xM=Iv6@%kN;SdUwb+jdPI+hw@F+KeXh{_c-umM%YTYc zJ_r6`{ADr9t8c}9k+3`Utwp)w)nMq4n%^>%CtZtYjx@hZP`(lRpP|cFqs-Shyy-7@ zqioynev~)q^=v>O%UO#u&y(1vKklx4Q}=&F_vdBpRl1$_-;VOYdvKqu*5?b9|8!DD zXpkQNcPLXH-Inp3m&*Atpeg?d2K| zf&ZxWFU$D=<$JFQhHlaAAERtuc|16lTTa*~$75JEWk1=S4NU9Gwz>XxEbsb@jH;~p ziBr6&a+K`5?ba=W7H?cNCogQ>;i?|@-Ed)WH?~`2Iqv>-_*g!;HpwfJREyhyP_3l6 zs;X#lb!`o=iq%JWrLZ9qEiXq?QPE^vvW^)MZp4Qx)SNe^HcH)aF%52p{o(rJrQCoQr1)H_f(#G8QCbnMv(srBYQ0Ng zyalBQx1b0E89B75D084J@gZ0fYf381YHHwg&Xh7weWE^7-PmzT_NY^eSPuL@Zu4VN=vmTF!f*f1=T9fMH${J^8w2IeDq=$4bVzsRWuWjL?xo6fB<`l}{ z_}rgHMH|ZD1qRJM(Or~v1)TY{@L`8gi#wF#+D}87C$s=Q5D}Vr5qRBV*OzC)k1HE+ zg-v{Uc1fg6;mn73IFu>E)0hw1iDxQl1fGuoYMae-=9l5ZY`tq^cs;z%nNoS)JO|n- z$@6QWiPMnaB}HZWN>Jqy