CoreWar/mars_main.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#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 */

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){
        printf("valeur: %d\n", valeur);
        printf("Pos actuelle: %d\n", posActuelle);
        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;
        printf("Valeur stockée dans la ram: %d", val.instruct.ArgB);

    } else if(modeAddr == IMMEDIAT) {
        /* Retourne l'arguement de la position */
        return valeur;
    }

    return valeur; 
} 

void execute_instruction(union mars_instruction instruction, int player, struct adresse memoire[TAILLE_MEM], int positions[2]){
    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;
                memoire[position_1].instruction = 0;
                /* @APPEL GRAPHIQUE */

            }

        }

        case ADD: {
            /* Addition de deux cases mémoires ? */
        }

        case SUB:
            /* Soustraction */
        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; /* On change la position du joueur */
        }
        case DJZ:
            /* */ 
        case CMP:
            /* Compare deux valeurs dans la mémoire */
        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[]){
    srand(time(NULL)); /* Initialise le pseudo aléatoire pour tout le programme */

    struct adresse memoire[TAILLE_MEM]; // Initialisation de la mémoire 0->7999
    int positions[2] = {0,10}; /* Position des joueurs */

    if (argc < 3){
        printf("Vous n'avez pas rentrez assez d'arguments \n");
        printf("Exemple d'utilisation: %s fichier1.cass fichier2.cass\n", argv[0]);
        return EXIT_FAILURE;
    } else if (argc > 3){
        printf("Vous avez utilisé trop d'arguments \n");
        printf("Exemple d'utilisation: %s fichier1.cass fichier2.cass\n", argv[0]);
        return EXIT_FAILURE;
    }

    FILE* fichier1;
    FILE* fichier2;

    fichier1 = fopen(argv[1], "r");
    fichier2 = fopen(argv[2], "r");

    if(fichier1 == NULL || fichier2 == NULL){
        printf("Erreur d'ouverture du fichier !\n");
        return EXIT_FAILURE;
    }

    printf("Fichier 1: %s\n", argv[1]);
    printf("Fichier 2: %s\n", argv[2]);

   /* To do: faire le programme qui lit le fichier compilé */ 

    fclose(fichier1);
    fclose(fichier2);

    union mars_instruction to_do;
    to_do.instruct.codeOp = JMP;
    to_do.instruct.ArgA = 753;
    to_do.instruct.ArgB = 0;
    to_do.instruct.modeAddrA = DIRECT;
    to_do.instruct.modeAddrB = DIRECT;
    printf("Valeur instruction: %lld\n", to_do.instructLL);
    execute_instruction(to_do, 1, memoire, positions);
    return EXIT_SUCCESS;
}