foucher/CoreWar
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Séparations des instructions

Browse Source
This commit is contained in:
Yvan Foucher
2021-12-17 23:06:57 +01:00
parent d24c7eeedf
commit 7fe766df11
4 changed files with 162 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@@ -1,8 +1,10 @@
OFILES = mars_main.o
OFILES = mars_main.o mars_execution.o
main.out: $(OFILES)
gcc ${OFILES} -o main.out -lgraph
mars_main.o: mars_main.c mars_types.h options.h
gcc -c mars_main.c
mars_execution.o: mars_execution.h mars_types.h
gcc -c mars_execution.c
clean:
rm *.o *.out
clear:

151
mars_execution.c Normal file
View File

@@ -0,0 +1,151 @@
#include"mars_types.h"
#include"options.h"
#include"mars_execution.h"
#include<stdio.h>
#include<stdlib.h>
int calculer_position(int posActuelle, short int modeAddr, short int valeur, struct adresse memoire[TAILLE_MEM]){
/* Permet de calculer l'adresse en fonction de la position actuelle et le mode d'adressage */
if(modeAddr == DIRECT){
return (posActuelle + (TAILLE_MEM + valeur)) % TAILLE_MEM;
} else if (modeAddr == INDIRECT){
/* Va voir à la position + valeur, */
int posToCheck = (posActuelle + (TAILLE_MEM + valeur)) % TAILLE_MEM;
union mars_instruction val;
val.instructLL = memoire[posToCheck].instruction;
if(val.instruct.codeOp == DAT){
return (posActuelle + (TAILLE_MEM + val.instruct.ArgB) % TAILLE_MEM);
}
} else if(modeAddr == IMMEDIAT) {
/* Retourne l'arguement de la position */
return valeur;
}
return valeur; /* retour par defaut */
}
void execute_instruction(union mars_instruction instruction, int player, struct adresse memoire[TAILLE_MEM], int positions[2]){
/* Permet d'executer les instructions des virus */
short int operation = instruction.instruct.codeOp; /* Pour rendre le code un peu plus lisible */
int position = positions[player];
printf("Position dans le exec: %d\n", position);
switch (operation){
case MOV:{
short int modeaddrA = instruction.instruct.modeAddrA;
if(modeaddrA == IMMEDIAT){
/* On écrit l'argument A dans la mémoire à l'aggr B */
union mars_instruction to_write;
to_write.instruct.codeOp = 0;
to_write.instruct.ArgB = to_write.instruct.ArgA;
int position = calculer_position(position, instruction.instruct.modeAddrB, instruction.instruct.ArgB, memoire);
memoire[position].instruction = to_write.instructLL;
memoire[position].player = player;
/* Ecrit un DAT avec la valeur demandée par le VIRUS */
} else {
/* Gérer les autres opérations de mov ici */
int position_1 = calculer_position(position, instruction.instruct.modeAddrA, instruction.instruct.ArgA, memoire);
int position_2 = calculer_position(position, instruction.instruct.modeAddrB, instruction.instruct.ArgB, memoire);
memoire[position_2].instruction = memoire[position_1].instruction;
memoire[position_2].player = player;
/* @APPEL GRAPHIQUE */
}
}
case ADD: {
int premiere_valeur = 0;
/* Addition de deux cases mémoires ? */
if (instruction.instruct.modeAddrA == IMMEDIAT){
/* Si le mode d'adressage pour le arg A est immediat alors valeur = a*/
premiere_valeur = instruction.instruct.ArgA;
} else {
int pos_to_check = calculer_position(position, instruction.instruct.modeAddrA, instruction.instruct.ArgA, memoire);
union mars_instruction to_read;
to_read.instructLL = memoire[pos_to_check].instruction;
if (to_read.instruct.codeOp == DAT){
premiere_valeur = to_read.instruct.ArgB;
} else {
/* Je ne sais pas si on peut continuer le programme mais ça doit être une errreur */
}
}
int deuxieme_valeur = 0;
int next_pos_to_check = calculer_position(position, instruction.instruct.modeAddrB, instruction.instruct.ArgB, memoire);
union mars_instruction next_instruction;
next_instruction.instructLL = memoire[next_pos_to_check].instruction;
if (next_instruction.instruct.codeOp == DAT){
next_instruction.instruct.ArgB += premiere_valeur;
memoire[next_pos_to_check].instruction = next_instruction.instructLL;
memoire[next_pos_to_check].player = player;
} else {
/* Peut-on dire que ça fail ici ? */
}
}
case SUB:{
int premiere_valeur;
int first_pos, next_pos;
union mars_instruction first_instruction, next_instruction;
if (instruction.instruct.modeAddrA == IMMEDIAT){
premiere_valeur = instruction.instruct.ArgA;
} else {
first_pos = calculer_position(position, instruction.instruct.modeAddrA, instruction.instruct.ArgA, memoire);
first_instruction.instructLL = memoire[first_pos].instruction;
if(first_instruction.instruct.codeOp == DAT){
premiere_valeur = first_instruction.instruct.ArgB;
} else {
/* Instruction a raté, peut on dire que c'est un fail ? */
}
}
next_pos = calculer_position(position, instruction.instruct.modeAddrB, instruction.instruct.ArgB, memoire);
next_instruction.instructLL = memoire[next_pos].instruction;
if (next_instruction.instruct.codeOp == DAT){
next_instruction.instruct.ArgB += premiere_valeur;
memoire[next_pos].instruction = next_instruction.instructLL;
memoire[next_pos].player = player;
} else {
/* L'instruction a raté, peut-on dire que c'est pas bien ?*/
}
}
case JMP: {
short int modeadresse = instruction.instruct.modeAddrA;
int position_calc = calculer_position(position, modeadresse, instruction.instruct.ArgA, memoire);
printf("Positon calculée: %d\n", position_calc);
positions[player] = position_calc; /* On change la position du joueur */
}
case DJZ:{
}
case CMP: {
/* Compare deux valeurs dans la mémoire */
int pos_1, pos_2;
pos_1 = calculer_position(position, instruction.instruct.modeAddrA, instruction.instruct.ArgA, memoire);
pos_2 = calculer_position(position, instruction.instruct.modeAddrB, instruction.instruct.ArgB, memoire);
if (memoire[pos_1].instruction != memoire[pos_2].instruction){
positions[player] += 1;
}
}
case DAT:
/* Instruction qui rapporte des données */
default:
break;
}
printf("Position après exécution: %d\n", positions[player]);
}

7
mars_execution.h Normal file
View File

@@ -0,0 +1,7 @@
#ifndef MARS_EXECUTION_H
#define MARS_EXECUTION_H
#include"options.h"
int calculer_position(int posActuelle, short int modeAddr, short int valeur, struct adresse memoire[TAILLE_MEM]);
void execute_instruction(union mars_instruction instruction, int player, struct adresse memoire[TAILLE_MEM], int positions[2]);
#endif

146
mars_main.c
View File

@@ -4,156 +4,12 @@
#include<time.h> /* Utilisé pour obtenir une adresse de démarrage aléatoire */
#include"mars_types.h" /* importe les types utilisés dans le programme */
#include"options.h" /* Inclus les options du programme */
#include"mars_execution.h"
void initialiser_memoire(char* fichier, int player, int positions[2]){
/* Boucle qui vient placer le programme dans la mémoire */
} /* Va initialiser la mémoire en plaçant les deux programmes dans des adresses aléatoires */
int calculer_position(int posActuelle, short int modeAddr, short int valeur, struct adresse memoire[TAILLE_MEM]){
/* Permet de calculer l'adresse en fonction de la position actuelle et le mode d'adressage */
if(modeAddr == DIRECT){
return (posActuelle + (TAILLE_MEM + valeur)) % TAILLE_MEM;
} else if (modeAddr == INDIRECT){
/* Va voir à la position + valeur, */
int posToCheck = (posActuelle + (TAILLE_MEM + valeur)) % TAILLE_MEM;
union mars_instruction val;
val.instructLL = memoire[posToCheck].instruction;
if(val.instruct.codeOp == DAT){
return (posActuelle + (TAILLE_MEM + val.instruct.ArgB) % TAILLE_MEM);
}
} else if(modeAddr == IMMEDIAT) {
/* Retourne l'arguement de la position */
return valeur;
}
return valeur; /* retour par defaut */
}
void execute_instruction(union mars_instruction instruction, int player, struct adresse memoire[TAILLE_MEM], int positions[2]){
/* Permet d'executer les instructions des virus */
short int operation = instruction.instruct.codeOp; /* Pour rendre le code un peu plus lisible */
int position = positions[player];
printf("Position dans le exec: %d\n", position);
switch (operation){
case MOV:{
short int modeaddrA = instruction.instruct.modeAddrA;
if(modeaddrA == IMMEDIAT){
/* On écrit l'argument A dans la mémoire à l'aggr B */
union mars_instruction to_write;
to_write.instruct.codeOp = 0;
to_write.instruct.ArgB = to_write.instruct.ArgA;
int position = calculer_position(position, instruction.instruct.modeAddrB, instruction.instruct.ArgB, memoire);
memoire[position].instruction = to_write.instructLL;
memoire[position].player = player;
/* Ecrit un DAT avec la valeur demandée par le VIRUS */
} else {
/* Gérer les autres opérations de mov ici */
int position_1 = calculer_position(position, instruction.instruct.modeAddrA, instruction.instruct.ArgA, memoire);
int position_2 = calculer_position(position, instruction.instruct.modeAddrB, instruction.instruct.ArgB, memoire);
memoire[position_2].instruction = memoire[position_1].instruction;
memoire[position_2].player = player;
/* @APPEL GRAPHIQUE */
}
}
case ADD: {
int premiere_valeur = 0;
/* Addition de deux cases mémoires ? */
if (instruction.instruct.modeAddrA == IMMEDIAT){
/* Si le mode d'adressage pour le arg A est immediat alors valeur = a*/
premiere_valeur = instruction.instruct.ArgA;
} else {
int pos_to_check = calculer_position(position, instruction.instruct.modeAddrA, instruction.instruct.ArgA, memoire);
union mars_instruction to_read;
to_read.instructLL = memoire[pos_to_check].instruction;
if (to_read.instruct.codeOp == DAT){
premiere_valeur = to_read.instruct.ArgB;
} else {
/* Je ne sais pas si on peut continuer le programme mais ça doit être une errreur */
}
}
int deuxieme_valeur = 0;
int next_pos_to_check = calculer_position(position, instruction.instruct.modeAddrB, instruction.instruct.ArgB, memoire);
union mars_instruction next_instruction;
next_instruction.instructLL = memoire[next_pos_to_check].instruction;
if (next_instruction.instruct.codeOp == DAT){
next_instruction.instruct.ArgB += premiere_valeur;
memoire[next_pos_to_check].instruction = next_instruction.instructLL;
memoire[next_pos_to_check].player = player;
} else {
/* Peut-on dire que ça fail ici ? */
}
}
case SUB:{
int premiere_valeur;
int first_pos, next_pos;
union mars_instruction first_instruction, next_instruction;
if (instruction.instruct.modeAddrA == IMMEDIAT){
premiere_valeur = instruction.instruct.ArgA;
} else {
first_pos = calculer_position(position, instruction.instruct.modeAddrA, instruction.instruct.ArgA, memoire);
first_instruction.instructLL = memoire[first_pos].instruction;
if(first_instruction.instruct.codeOp == DAT){
premiere_valeur = first_instruction.instruct.ArgB;
} else {
/* Instruction a raté, peut on dire que c'est un fail ? */
}
}
next_pos = calculer_position(position, instruction.instruct.modeAddrB, instruction.instruct.ArgB, memoire);
next_instruction.instructLL = memoire[next_pos].instruction;
if (next_instruction.instruct.codeOp == DAT){
next_instruction.instruct.ArgB += premiere_valeur;
memoire[next_pos].instruction = next_instruction.instructLL;
memoire[next_pos].player = player;
} else {
/* L'instruction a raté, peut-on dire que c'est pas bien ?*/
}
}
case JMP: {
short int modeadresse = instruction.instruct.modeAddrA;
int position_calc = calculer_position(position, modeadresse, instruction.instruct.ArgA, memoire);
printf("Positon calculée: %d\n", position_calc);
positions[player] = position_calc; /* On change la position du joueur */
}
case DJZ:{
}
case CMP: {
/* Compare deux valeurs dans la mémoire */
int pos_1, pos_2;
pos_1 = calculer_position(position, instruction.instruct.modeAddrA, instruction.instruct.ArgA, memoire);
pos_2 = calculer_position(position, instruction.instruct.modeAddrB, instruction.instruct.ArgB, memoire);
if (memoire[pos_1].instruction != memoire[pos_2].instruction){
positions[player] += 1;
}
}
case DAT:
/* Instruction qui rapporte des données */
default:
break;
}
printf("Position après exécution: %d\n", positions[player]);
}
int main(int argc, char* argv[]){