ajout des fichier dans le bon git
This commit is contained in:
martins
parent
ef5101f3ad
commit
87415d6475
46
Makefile
Normal file
46
Makefile
Normal file
@ -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
|
||||
19
README.md
19
README.md
@ -1,3 +1,22 @@
|
||||
# SAE12_2021
|
||||
|
||||
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
|
||||
14
ReadMe.md
Normal file
14
ReadMe.md
Normal file
@ -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.
|
||||
1
Virus1.ass
Normal file
1
Virus1.ass
Normal file
@ -0,0 +1 @@
|
||||
DAT -1
|
||||
4
Virus2.ass
Normal file
4
Virus2.ass
Normal file
@ -0,0 +1,4 @@
|
||||
DAT -1
|
||||
ADD #5 -1
|
||||
MOV #0 @-2
|
||||
JMP -2
|
||||
156
action.c
Normal file
156
action.c
Normal file
@ -0,0 +1,156 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <math.h>
|
||||
#include <graph.h>
|
||||
#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;
|
||||
|
||||
}
|
||||
266
decod_instruction.c
Normal file
266
decod_instruction.c
Normal file
@ -0,0 +1,266 @@
|
||||
#ifndef DECOD_C
|
||||
#define DECOD_C
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <graph.h>
|
||||
#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
|
||||
12
decod_instruction.h
Normal file
12
decod_instruction.h
Normal file
@ -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
|
||||
79
graphique.c
Normal file
79
graphique.c
Normal file
@ -0,0 +1,79 @@
|
||||
#ifndef GRAPHIQUE_C
|
||||
#define GRAPHIQUE_C
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <math.h>
|
||||
#include <graph.h>
|
||||
|
||||
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
|
||||
11
graphique.h
Normal file
11
graphique.h
Normal file
@ -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
|
||||
436
mon_gcc.c
Normal file
436
mon_gcc.c
Normal file
@ -0,0 +1,436 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
|
||||
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(;i<taille;i++){
|
||||
puissance=pow(10, (taille-(i+1)));
|
||||
|
||||
|
||||
if(chaine[i]=='1'){
|
||||
entier+=1*puissance;
|
||||
}
|
||||
if(chaine[i]=='2'){
|
||||
entier+=2*puissance;
|
||||
}
|
||||
if(chaine[i]=='3'){
|
||||
entier+=3*puissance;
|
||||
}
|
||||
if(chaine[i]=='4'){
|
||||
entier+=4*puissance;
|
||||
}
|
||||
if(chaine[i]=='5'){
|
||||
entier+=5*puissance;
|
||||
}
|
||||
if(chaine[i]=='6'){
|
||||
entier+=6*puissance;
|
||||
}
|
||||
if(chaine[i]=='7'){
|
||||
entier+=7*puissance;
|
||||
}
|
||||
if(chaine[i]=='8'){
|
||||
entier+=8*puissance;
|
||||
}
|
||||
if(chaine[i]=='9'){
|
||||
entier+=9*puissance;
|
||||
}
|
||||
}
|
||||
if(entier>7999){
|
||||
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;
|
||||
}
|
||||
BIN
superviseur
Executable file
BIN
superviseur
Executable file
Binary file not shown.
Loading…
Reference in New Issue
Block a user