diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..5e8f484 --- /dev/null +++ b/Makefile @@ -0,0 +1,46 @@ +but : superviseur + +OFILES= action.o\ + decod_instruction.o\ + graphique.o + +CFLAGS= -Wall -ansi -pedantic -g -lgraph -o + + + + +action.o : action.c + gcc action.c -c -lgraph -o action.o + +decod_instruction.o : decod_instruction.h decod_instruction.c graphique.h + gcc decod_instruction.c -c -o decod_instruction.o + +graphique.o : graphique.h graphique.c + gcc graphique.c -c -lgraph -o graphique.o + + + +superviseur : $(OFILES) + gcc $(OFILES) $(CFLAGS) superviseur + + +clean : + -rm -f $(OFILES) taquin + +run : + ./superviseur +compil : + gcc mon_gcc.c -Wall -ansi -g -lm -o mon_gcc + +execute : + ./mon_gcc Virus1.ass Virus2.ass + +#chapitre 6 : buts factices + +.PHONY : but clean + +.PHONY : but run + +.PHONY : but compil + +.PHONY : but execute diff --git a/README.md b/README.md index 9eb4cce..fbdf992 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,22 @@ # SAE12_2021 -Core War \ No newline at end of file +Core War + +Etat du Projet: +Le projet a été entierrement réaliser normalement avec: un traducteur du language d'assembleur appeler mon_gcc a qui nous fournissons 2 fichier contenant les instructions des virus, ainsi que un superviseur lisant ces fichiers, les placant dans une case memoire d'un tableau a minimun 1000 case de distance, executant les instruction a tour de role des virus et declanrant perdant le virus qui retourne une erreur. Si au bout de 7500 execution d'instruction aucun virus n'a perdu alors l'égalité est declarer. Une interface graphique pour mieux visualiser l'evolution des virus avec en bleu le virus n°1, en vert le virus n°2 et en rouge les case du tableau qui sont modifiée par les virus. + +Participant: +Tom Monin +Clément Martins + +Difficulté: +Nous avons eu des difficultés lors de l'étape pour convertir les instruction en indication et les executer. Nous esperons que toute les actions marche normallement même si normalement, nous avons fait des test et cela est bon. + +Temps: +Nous aurions aimée pouvoir faire des statistique sur un nombre choisit d'execution avec le nombre de victoire de chaque virus ainsi que celui d'egalité pour facilité la création du meilleur virus. + +Makefile: +pour compiler mon_gcc: make compil +pour l'execter avec les 2 fichier.ass des virus: make execute +pour compiler le superviseur: make +pour executer le superviseur avec l'interface graphique: make run \ No newline at end of file diff --git a/ReadMe.md b/ReadMe.md new file mode 100644 index 0000000..a6f39b0 --- /dev/null +++ b/ReadMe.md @@ -0,0 +1,14 @@ +SAE1.2 + +Etat du Projet: +Le projet a été entierrement réaliser normalement avec: un traducteur du language d'assembleur appeler mon_gcc a qui nous fournissons 2 fichier contenant les instructions des virus, ainsi que un superviseur lisant ces fichiers, les placant dans une case memoire d'un tableau a minimun 1000 case de distance, executant les instruction a tour de role des virus et declanrant perdant le virus qui retourne une erreur. Si au bout de 7500 execution d'instruction aucun virus n'a perdu alors l'égalité est declarer. Une interface graphique pour mieux visualiser l'evolution des virus avec en bleu le virus n°1, en vert le virus n°2 et en rouge les case du tableau qui sont modifiée par les virus. + +Participant: +Tom Monin +Clément Martins + +Difficulté: +Nous avons eu des difficultés lors de l'étape pour convertir les instruction en indication et les executer. Nous esperons que toute les actions marche normallement même si normalement, nous avons fait des test et cela est bon. + +Temps: +Nous aurions aimée pouvoir faire des statistique sur un nombre choisit d'execution avec le nombre de victoire de chaque virus ainsi que celui d'egalité pour facilité la création du meilleur virus. \ No newline at end of file diff --git a/Virus1.ass b/Virus1.ass new file mode 100644 index 0000000..beec7df --- /dev/null +++ b/Virus1.ass @@ -0,0 +1 @@ +DAT -1 \ No newline at end of file diff --git a/Virus2.ass b/Virus2.ass new file mode 100644 index 0000000..99fca94 --- /dev/null +++ b/Virus2.ass @@ -0,0 +1,4 @@ +DAT -1 +ADD #5 -1 +MOV #0 @-2 +JMP -2 \ No newline at end of file diff --git a/action.c b/action.c new file mode 100644 index 0000000..6703c3c --- /dev/null +++ b/action.c @@ -0,0 +1,156 @@ +#include +#include +#include +#include +#include +#include +#include "decod_instruction.h" +#include "graphique.h" + + +int main(void){ + InitialiserGraphique(); + FILE* virus; + virus=fopen("./vir1.mars", "r"); + srand(time(NULL)); + CreerFenetre(0, 0, 1600, 900); + PremiereImage(); + /* + Ouverture des fichiers contenant les entiers des instruction. + */ + int adresse_aleatoire; + adresse_aleatoire=rand()%8000; + + unsigned long int tableau[8000]; + + /* + Le tableau de 8000 cases represente la memoire. + */ + + int retenue1=adresse_aleatoire; + int verif=feof(virus); + int tableau_binaire[64]; + + + while(verif!=1){ + + unsigned long int valeur_instruction; + fscanf(virus, "%lu", &valeur_instruction); + tableau[adresse_aleatoire]=valeur_instruction; + adresse_aleatoire++; + if(adresse_aleatoire==8000){ + adresse_aleatoire=0; + } + verif=feof(virus); + } + fclose(virus); + /* + Fonction permettant de savoir si on est sur une fin de fichier. + */ + + virus=fopen("./vir2.mars", "r"); + /* + lecture entier stocker. + */ + for(;adresse_aleatoire!=retenue1; adresse_aleatoire--){ + if(adresse_aleatoire==-1){ + adresse_aleatoire=7999; + } + } + + do{ + adresse_aleatoire=rand()%8000; + }while((((adresse_aleatoire-1000)<=retenue1)&&(retenue1<=adresse_aleatoire))||((adresse_aleatoire<=retenue1)&&(retenue1<=(adresse_aleatoire+1000)))); + int retenue2=adresse_aleatoire; + verif=feof(virus); + while(verif!=1){ + /* + Positionne les virus aléatoirement dans la mémoire de 8000 cases. + */ + unsigned long int valeur_instruction; + fscanf(virus, "%lu", &valeur_instruction); + tableau[adresse_aleatoire]=valeur_instruction; + adresse_aleatoire++; + if(adresse_aleatoire==8000){ + adresse_aleatoire=0; + } + verif=feof(virus); + } + virus=fopen("./vir2.mars", "r"); + for(;adresse_aleatoire!=retenue1; adresse_aleatoire--){ + if(adresse_aleatoire==-1){ + adresse_aleatoire=7999; + } + } + clock_t retenue_temps; + retenue_temps=clock(); + clock_t temps; + temps=clock(); + temps=difftime(temps, retenue_temps)/1000000; + int nb_virus=1; + int nombre_execution=0; + int init_1=retenue1; + int init_2=retenue2; + +while(nombre_execution<7500){ + int perdant=0; + if(temps>5){ + + + /* toute les 0,2 seconde pour pouvoir mieux suivre l'affichage a l'ecran */ + + if(nb_virus==1){ + if(retenue1==8000){ + retenue1=0; + } + DessinerVirus(retenue1, "blue"); + convertion(tableau_binaire, tableau[retenue1]); + /*decodeur_instruction(tableau, retenue1);*/ + nb_virus=2; + nombre_execution++; + perdant=decodeur_instruction(tableau_binaire, tableau, &retenue1); + if(perdant!=0){ + printf("\n\033[34m virus 1 a perdu \033[0m\n"); + ImageFin(nb_virus); + return EXIT_SUCCESS; + } + } + else{ + if(retenue2==8000){ + retenue2=0; + } + DessinerVirus(retenue2, "green"); + convertion(tableau_binaire, tableau[retenue2]); + /*decodeur_instruction(tableau, retenue2);*/ + nb_virus=1; + nombre_execution++; + perdant=decodeur_instruction(tableau_binaire, tableau, &retenue2); + if(perdant!=0){ + printf("\n\033[32m virus 2 a perdu \033[0m\n"); + ImageFin(nb_virus); + return EXIT_SUCCESS; + } + } + + + retenue_temps=clock(); + temps=clock(); + temps=difftime(temps, retenue_temps)/1000; + } + temps=clock(); + temps=difftime(temps, retenue_temps)/1000; + +} +/* + On fais switch exécution pour qu'elle s'exécute à tour de rôle et on a mis un temps entre chaque execution pour pouvoir mieux suivre l'évolution des + virus. si il ne se passe rien avant un nombre maximal d'instruction. + on marque que les virus sont à égalité. +*/ + +printf("\033[32m \n egalité aucun virus n'a gagner \033[0m \n"); + +fclose(virus); + +return EXIT_SUCCESS; + +} diff --git a/decod_instruction.c b/decod_instruction.c new file mode 100644 index 0000000..a539c76 --- /dev/null +++ b/decod_instruction.c @@ -0,0 +1,266 @@ +#ifndef DECOD_C +#define DECOD_C + +#include +#include +#include +#include +#include "graphique.h" + +void convertion(int* binraire, unsigned long int valeur){ + int i=0; + int max=63; + unsigned long int verif; + for(i=0;i<64;i++){ + max=63-i; + verif=1; + for(;max>=1;max--){ + verif=verif*2; + } + if(verif<=valeur){ + valeur-=verif; + binraire[i]=1; + }else{ + binraire[i]=0; + } + } +} + + +unsigned long int transtypage(int tab_binaire[], int nb){ + int i; + + int j; + unsigned long int entier = 0; + unsigned long int pow = 0; +if(nb==1){ + for(i=8;i<36;i++){ + } + for(i = 8; i < 36; i++){ + if(tab_binaire[i] == 1){ + pow =1; + for(j = 0; j < 27+8-i ; j++ ){ + pow = pow * 2; + } + entier += pow; + } + } +} +if(nb==2){ + for(i=36;i<64;i++){ + } +for(i = 36; i < 64; i++){ + if(tab_binaire[i] == 1){ + pow =1; + for(j = 0; j < 27+36-i ; j++ ){ + pow = pow * 2; + } + entier += pow; + } + } +} +return entier; +} + + +int decodeur_instruction( int tab[], unsigned long int memoire[], int* adresse){ + int bin[4]; + int adresse1; + int adresse2=12; + int i; + int resultat = 0; + int allocation1=0; + int allocation2=0; + + for(i = 0; i < 4; i++) + { + bin[i]= tab[i]; + } + + if(tab[4]==0 && tab[5]==1){ + allocation1=1; + } + if(tab[4]==1 && tab[5]==0){ + allocation1=2; + } + if(tab[4]==1 && tab[5]==1){ + allocation1=3; + } + + if(tab[6]==0 && tab[7]==1){ + allocation2=1; + } + if(tab[6]==1 && tab[7]==0){ + allocation2=2; + } + if(tab[6]==1 && tab[7]==1){ + allocation2=3; + } + + + adresse1=transtypage(tab, 1); + adresse2=transtypage(tab, 2); + + if(allocation1==3){ + resultat++; + } + if(allocation1==1){ + adresse1=*adresse+adresse1; + } + if(allocation1==2){ + adresse1=*adresse+adresse1; + if(adresse1>7999){ + adresse1=adresse1%8000; + } + if(adresse2>7999){ + adresse2=adresse2%8000; + } + unsigned long int valeur=memoire[adresse1]; + adresse1=*adresse+valeur; + } + if(allocation2==3){ + resultat++; + } + if(allocation2==1){ + adresse2=*adresse+adresse2; + } + + if(allocation2==2){ + adresse2=*adresse+adresse2; + if(adresse1>7999){ + adresse1=adresse1%8000; + } + if(adresse2>7999){ + adresse2=adresse2%8000; + } + unsigned long int valeur=memoire[adresse2]; + adresse2=*adresse+valeur; + } + + if(adresse1>7999){ + adresse1=adresse1%8000; + } + if(adresse2>7999){ + adresse2=adresse2%8000; + } + + if(bin[0] == 0 && bin[1] == 0 && bin[2] == 0 && bin[3] == 0) /* DAT */ + { + if(adresse2==0){ + return -1; + }else{ + *adresse=*adresse+1; + resultat--; + } + } + + if(bin[0] == 0 && bin[1] == 0 && bin[2] == 0 && bin[3] == 1) /* 1 MOV */ + { + if(allocation1!=0){ + memoire[adresse2]=memoire[adresse1]; + }else{ + memoire[adresse2]=adresse1; + } + *adresse=*adresse+1; + resultat--; + DessinerVirus(adresse2, "red"); + } + + if(bin[0] == 0 && bin[1] == 0 && bin[2] == 1 && bin[3] == 0) /* 2 ADD */ + { + + if(allocation1!=0){ + memoire[adresse2]=memoire[adresse1]+memoire[adresse2]; + }else{ + memoire[adresse2]+=adresse1; + } + *adresse=*adresse+1; + resultat--; + DessinerVirus(adresse2, "red"); + } + + if(bin[0] == 0 && bin[1] == 0 && bin[2] == 1 && bin[3] == 1) /* 3 SUB */ + { + unsigned long int retenue; + if(allocation1!=0){ + retenue=memoire[adresse1]-memoire[adresse2]; + }else{ + retenue=adresse1-memoire[adresse2]; + } + if(retenue<0){ + retenue+=8000; + } + memoire[adresse1]=retenue; + + *adresse=*adresse+1; + resultat--; + DessinerVirus(adresse1, "red"); + } + + if(bin[0] == 0 && bin[1] == 1 && bin[2] == 0 && bin[3] == 0) /* 4 JMP */ + { + *adresse=adresse1; + resultat--; + } + + if(bin[0] == 0 && bin[1] == 1 && bin[2] == 0 && bin[3] == 1) /* 5 JMZ */ + { + if(memoire[adresse2]==0){ + *adresse=adresse1; + }else{ + *adresse=*adresse+1; + } + resultat--; + } + + if(bin[0] == 0 && bin[1] == 1 && bin[2] == 1 && bin[3] == 0) /* 6 JMG */ + { + if(memoire[adresse2]>0){ + *adresse=adresse1; + }else{ + *adresse=*adresse+1; + resultat--; + } + } + + if(bin[0] == 0 && bin[1] == 1 && bin[2] == 1 && bin[3] == 1) /* 7 DJZ */ + { + if(allocation2!=0){ + memoire[adresse2]=memoire[adresse2]-1; + if(memoire[adresse2]==0){ + *adresse=adresse1; + } + }else{ + adresse2=adresse2-1; + if(adresse2==0){ + *adresse=adresse1; + } + } + DessinerVirus(adresse2, "red"); + resultat--; + } + + if(bin[0] == 1 && bin[1] == 0 && bin[2] == 0 && bin[3] == 0) /* 8 CMP */ + { + if(allocation1!=0){ + if(memoire[adresse2]==memoire[adresse1]){ + *adresse=*adresse+1; + }else{ + *adresse=*adresse+2; + } +}else{ + if(memoire[adresse2]==adresse1){ + *adresse=*adresse+1; + }else{ + *adresse=*adresse+2; + } +} + resultat--; + } + resultat++; + return resultat; + + +} + +#endif \ No newline at end of file diff --git a/decod_instruction.h b/decod_instruction.h new file mode 100644 index 0000000..6c1871d --- /dev/null +++ b/decod_instruction.h @@ -0,0 +1,12 @@ +#ifndef DECOD_INSTRUCTION_h +#define DECOD_INSTRUCTION_H + +void convertion(int* binraire, unsigned long int valeur); + +unsigned long int transtypage(int tab_binaire[], int nb); +int decodeur_instruction( int tab[], unsigned long int memoire[], int* adresse); + + + + +#endif \ No newline at end of file diff --git a/graphique.c b/graphique.c new file mode 100644 index 0000000..8b92029 --- /dev/null +++ b/graphique.c @@ -0,0 +1,79 @@ +#ifndef GRAPHIQUE_C +#define GRAPHIQUE_C +#include +#include +#include +#include +#include +#include + +void DessinerVirus(unsigned long int addresse, char* coul){ + couleur t; + + t=CouleurParNom(coul); + ChoisirCouleurDessin(t); + + int i; + int j; + int x; + int y; + + for(i=0;i<16;i++){ + for(j=0;j<501;j++){ + addresse=addresse-1; + if(addresse==0){ + x=35+j*3; + y=20+i*55; + break; + } + } + if(addresse==0){ + break; + + } + } + DessinerRectangle(x, y, 3, 30); +} + +void PremiereImage(void){ + int x=3; + int y=45+10; + int i; + int lx=3; + int ly=30; + int j; + + for(i=0;i<16;i++){ + + for(j=0;j<501;j++){ + + DessinerRectangle(35+j*(x), 20+i*(y), lx, ly); + + + } + } +} + +void ImageFin(int nb_image){ + couleur c; + c=CouleurParNom("red"); + ChoisirCouleurDessin(c); + EcrireTexte(700, 400, "Fin de la Partie", 2); + Touche(); + if(nb_image==1){ + c=CouleurParNom("blue"); + EffacerEcran(c); + c=CouleurParNom("white"); + ChoisirCouleurDessin(c); + EcrireTexte(650, 400, "Le virus numero 1 a gagner", 2); + } + if(nb_image==2){ + c=CouleurParNom("green"); + EffacerEcran(c); + c=CouleurParNom("white"); + ChoisirCouleurDessin(c); + EcrireTexte(650, 400, "Le virus numero 2 a gagner", 2); + } + Touche(); +} +#endif \ No newline at end of file diff --git a/graphique.h b/graphique.h new file mode 100644 index 0000000..bff32a5 --- /dev/null +++ b/graphique.h @@ -0,0 +1,11 @@ +#ifndef GRAPHIQUE_H +#define GRAPHIQUE_H + +void DessinerVirus(unsigned long int addresse, char* coul); + +void PremiereImage(void); + +void ImageFin(int nb_image); + + +#endif \ No newline at end of file diff --git a/mon_gcc b/mon_gcc new file mode 100755 index 0000000..fc87290 Binary files /dev/null and b/mon_gcc differ diff --git a/mon_gcc.c b/mon_gcc.c new file mode 100644 index 0000000..2c6a1d9 --- /dev/null +++ b/mon_gcc.c @@ -0,0 +1,436 @@ +#include +#include +#include +#include + +int entier_ecrit(char* chaine, int taille, int valeur[]){ +int i=0; +int entier=0; +int negatif=0; +if(chaine[0]=='-'){ + negatif=1; + i=1; +} +int puissance=0; +for(;i7999){ + entier=entier%8000; +} +if(negatif==1){ + entier=8000+(entier*-1); +} +return entier; +} + +void convertion_binaire(int valeur[], int nombre, int type){ + + if(type==0){ + int compteur=8; + for(;compteur<36; compteur++){ + int puissance=36-compteur-1; + if((pow(2, puissance))<=nombre){ + valeur[compteur]=1; + nombre=nombre-pow(2, puissance); + }else{ + valeur[compteur]=0; + } + } + } + if(type==2){ + int compteur=36; + for(;compteur<64; compteur++){ + int puissance=64-compteur-1; + if((pow(2, puissance))<=nombre){ + valeur[compteur]=1; + nombre=nombre-pow(2, puissance); + }else{ + valeur[compteur]=0; + } + } + } + if(type==3){ + int compteur=8; + for(;compteur<36;compteur++){ + valeur[compteur]=0; + } + + for(;compteur<64; compteur++){ + int puissance=64-compteur-1; + if((pow(2, puissance))<=nombre){ + valeur[compteur]=1; + nombre=nombre-pow(2, puissance); + }else{ + valeur[compteur]=0; + } + } + } + if(type==1){ + int compteur=36; + for(;compteur<64;compteur++){ + valeur[compteur]=0; + } + compteur=8; + for(;compteur<36; compteur++){ + int puissance=36-compteur-1; + if((pow(2, puissance))<=nombre){ + valeur[compteur]=1; + nombre=nombre-pow(2, puissance); + }else{ + valeur[compteur]=0; + } + } + } +} +/* + Permet la conversion en binaire des entier rentre. +*/ + + + +void code(char* chaine, int valeur[]){ + +/* on recupère les 3 premiers caratères pour les retranscrire en bits */ +char instruction[4]; +int i; +for(i=0; i<3; i++){ +instruction[i]=chaine[i]; +} +instruction[3]='\0'; +int verif; + + + +/* on convertie cette chaine en l'entier correspondant */ +char MOV[4]="MOV\0"; +char ADD[4]="ADD\0"; +char SUB[4]="SUB\0"; +char JMP[4]="JMP\0"; +char JMZ[4]="JMZ\0"; +char JMG[4]="JMG\0"; +char DJZ[4]="DJZ\0"; +char CMP[4]="CMP\0"; +char DAT[4]="DAT\0"; +char indirect[2]="@\0"; +char immediat[2]="#\0"; +int nb_adresse=0; + +verif=strcmp(instruction, MOV); +if(verif==0){ +valeur[0]=0; +valeur[1]=0; +valeur[2]=0; +valeur[3]=1; +nb_adresse=2; +} + +verif=strcmp(instruction, ADD); +if(verif==0){ +valeur[0]=0; +valeur[1]=0; +valeur[2]=1; +valeur[3]=0; +nb_adresse=2; +} + +verif=strcmp(instruction, SUB); +if(verif==0){ +valeur[0]=0; +valeur[1]=0; +valeur[2]=1; +valeur[3]=1; +nb_adresse=2; +} + +verif=strcmp(instruction, JMP); +if(verif==0){ +valeur[0]=0; +valeur[1]=1; +valeur[2]=0; +valeur[3]=0; +nb_adresse=1; +} + +verif=strcmp(instruction, JMZ); +if(verif==0){ +valeur[0]=0; +valeur[1]=1; +valeur[2]=0; +valeur[3]=1; +nb_adresse=2; +} + +verif=strcmp(instruction, JMG); +if(verif==0){ +valeur[0]=0; +valeur[1]=1; +valeur[2]=1; +valeur[3]=0; +nb_adresse=2; +} + +verif=strcmp(instruction, DJZ); +if(verif==0){ +valeur[0]=0; +valeur[1]=1; +valeur[2]=1; +valeur[3]=1; +nb_adresse=2; +} + +verif=strcmp(instruction, CMP); +if(verif==0){ +valeur[0]=1; +valeur[1]=0; +valeur[2]=0; +valeur[3]=0; +nb_adresse=2; +} + +verif=strcmp(instruction, DAT); +if(verif==0){ +valeur[0]=0; +valeur[1]=0; +valeur[2]=0; +valeur[3]=0; +nb_adresse=3; +} + +char adressage[2]; +adressage[0]=chaine[4]; +adressage[1]='\0'; +i=-1; + +verif=strcmp(adressage, immediat); +if(verif==0){ + valeur[4]=0; + valeur[5]=0; + i=0; +} + +verif=strcmp(adressage, indirect); +if(verif==0){ + valeur[4]=1; + valeur[5]=0; + i=0; +} +if(i==-1){ + valeur[4]=0; + valeur[5]=1; + +} + +if(nb_adresse==3){ + valeur[6]=valeur[4]; + valeur[7]=valeur[5]; + valeur[4]=0; + valeur[5]=0; +} +if(nb_adresse==1){ + valeur[6]=0; + valeur[7]=0; +} + +char adresse1[6]; +int compteur=5; +int nombre1; + + +if(nb_adresse==2){ +int a=0; + while(chaine[compteur+i]!=' '){ + adresse1[a]=chaine[compteur+i]; + i++; + a++; +} +compteur+=i+2; +adresse1[a]='\0'; +nombre1=entier_ecrit(adresse1, a, valeur); +convertion_binaire(valeur, nombre1, 0); + + + + +adressage[0]=chaine[compteur-1]; +adressage[1]='\0'; +i=-1; +verif=strcmp(adressage, immediat); +if(verif==0){ + valeur[6]=0; + valeur[7]=0; + i=0; +} + +verif=strcmp(adressage, indirect); +if(verif==0){ + valeur[6]=1; + valeur[7]=0; + i=0; +} +if(i==-1){ + valeur[6]=0; + valeur[7]=1; + +} + + a=0; + while((chaine[compteur+i]!='\000')&&(chaine[compteur+i]!='\n')){ + adresse1[a]=chaine[compteur+i]; + i++; + a++; +} + +adresse1[a]='\0'; +nombre1=entier_ecrit(adresse1, a, valeur); +convertion_binaire(valeur, nombre1, 2); +} + + + +if(nb_adresse!=2){ + int a=0; + while((chaine[compteur+i]!='\000')&&(chaine[compteur+i]!='\n')){ + adresse1[a]=chaine[compteur+i]; + i++; + a++; +} +adresse1[a]='\0'; +nombre1=entier_ecrit(adresse1, a, valeur); +if(nb_adresse==3){ + valeur[6]=0; + valeur[7]=0; + } + convertion_binaire(valeur, nombre1, nb_adresse); + +} +if(nb_adresse==0){ +printf(" \n \033[31m erreur script des Virus éronné \033[0m \n"); +} + +} + +unsigned long int transtypage(int tab_binaire[]) +{ + int i; + int j; + int bin; + unsigned long int entier = 0; + unsigned long int pow = 0; + +/* + Boucle qui sert a changer le nombre binaire donner a l'aide d'un tableau en decimal. +*/ + for(i = 0; i < 64; i++) + { + bin = tab_binaire[i]; + if(bin == 1) + { + /* + cette deuxieme boucle simule une puissance. + */ + pow =1; + for(j = 0; j < 63-i ; j++ ) + { + pow = pow * 2; + } + entier = entier + pow; + } + + } + + return entier; + +} + + +void code_entier(char* instruction, unsigned long int* entier){ +int v[64]; +code(instruction, v); + *entier=transtypage(v); + +} + +int main(int argc, char* argv[]){ + + if(argc<3){ + printf("\033[31m erreur, execution attendue:\" ./mongcc [Virus1.ass] [Virus2.ass] \" \033[0m \n "); + return EXIT_SUCCESS; + } + /* + Permet de tester le nombre d'argument. + */ + char instruction[20]; + FILE* virus1; + FILE* final1; + final1=fopen("./vir1.mars", "w"); + /* + Ouverture et ecriture des entier dans un fichier. + */ + unsigned long int entier=0UL; + virus1=fopen(argv[1], "r"); + int verif=feof(virus1); + do{ + + fgets(instruction, 20, virus1); + code_entier(instruction, &entier); + verif=feof(virus1); + fprintf(final1, "%lu", entier); + if(verif!=1){ + fprintf(final1, "\n"); + + } + +}while(verif!=1); +fclose(virus1); +fclose(final1); +final1=fopen("./vir2.mars", "w"); + /* + Ouverture et ecriture des entier dans un fichier. + */ +virus1=fopen(argv[2], "r"); +do{ + + fgets(instruction, 20, virus1); + code_entier(instruction, &entier); + verif=feof(virus1); + fprintf(final1, "%lu", entier); + if(verif!=1){ + fprintf(final1, "\n"); + + } + +}while(verif!=1); +fclose(virus1); + +return EXIT_SUCCESS; +} \ No newline at end of file diff --git a/superviseur b/superviseur new file mode 100755 index 0000000..66d8ecc Binary files /dev/null and b/superviseur differ diff --git a/vir1.mars b/vir1.mars new file mode 100644 index 0000000..f96a05a --- /dev/null +++ b/vir1.mars @@ -0,0 +1 @@ +7999 \ No newline at end of file diff --git a/vir2.mars b/vir2.mars new file mode 100644 index 0000000..c764497 --- /dev/null +++ b/vir2.mars @@ -0,0 +1,4 @@ +7999 +2377900604593807167 +1297036692682710846 +4899918541525876736 \ No newline at end of file