CoreWar/mars_execution.c

#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]);
}