#include "registre.h"
#include "interne.h"
#include "simulator.h"
#include "exceptions.h"
#ifdef HAVE_CONFIG_H
#include "config.h"
#else
#define _(x) x
#endif

Uint32 registre[64];

/*****************************************/
/**                                     **/
/**         GESTION DES REGISTRES       **/
/**                                     **/
/*****************************************/

Uint32 LireRegistreRG(void)
{
    return (registre[REG_RG]);
}

Uint32 LireRegistreRD(void)
{
    return (registre[REG_RD]);
}

Uint32 LireRegistrePC(void)
{
    return (registre[REG_PC]);
}

Uint32 LireRegistreFLAG(void)
{
    return (registre[REG_FLAG]);
}

Uint32 LireRegistreSP(void)
{
    return (registre[REG_STACKPTR]);
}

void EcrireRegistreRG(Uint32 val)
{
    registre[REG_RG] = val;
}

void EcrireRegistreRD(Uint32 val)
{
    registre[REG_RD] = val;
}

void EcrireRegistrePC(Uint32 val)
{
    registre[REG_PC] = val;
}

void EcrireRegistreFLAG(Uint32 val)
{
    registre[REG_FLAG] = val;
}

void EcrireRegistreSP(Uint32 val)
{
    registre[REG_STACKPTR] = val;
}

/* Lit le mot qui se trouve dans le registre 'numero_registre' */
Uint32 LireRegistre(Uint32 champ_registre)
{
    Uint32 i;

    if (ValeurBit(champ_registre, 5) == 0) {	/* Test du bit S */
	Reset(&i);
	if (champ_registre < 0 || champ_registre >= NB_REGISTRES_UTILISABLES) {	/* Si on voudrait diminuer le nombre de registres */
	    exception(1, _("Invalid Register Descriptor"));	/* Il n'y a que 32 registres */
	    return (i);
	}
	i = registre[champ_registre];	/* Registre classique */
	return (i);
    } else			/* Registre spécial */
	switch (champ(champ_registre, 4)) {
	case 0:
	    return (LireRegistreRG());
	case 1:
	    return (LireRegistreRD());
	case 2:
	    return (LireRegistrePC());
	case 3:
	    return (LireRegistreFLAG());
	default:{
		exception(1, _("Invalid Register Descriptor"));
		return (0);
	    }
	}
}

/* Ecrit le mot 'valeur' dans le registre 'numero_registre' */
void EcrireRegistre(Uint32 champ_registre, Uint32 valeur)
{
    Uint32 i;

    if (ValeurBit(champ_registre, 5) == 0) {	/* Test du bit S */
	Reset(&i);
	if (champ_registre < 0 || champ_registre >= NB_REGISTRES_UTILISABLES)
	    exception(1, _("Invalid Register Descriptor"));	/* Il n'y a que 32 registres */
	else
	    registre[champ_registre] = valeur;	/* Registre classique */
    } else			/* Registre spécial */
	switch (champ(champ_registre, 4)) {
	case 0:
	    EcrireRegistreRG(valeur);
	case 1:
	    EcrireRegistreRD(valeur);
	case 2:
	    EcrireRegistrePC(valeur);
	case 3:
	    EcrireRegistreFLAG(valeur);
	default:
	    exception(1, _("Invalid Register Descriptor"));
	}
}

int Overflow(void)
{
    return (ValeurBit(LireRegistreFLAG(), 0));
}
int Zero(void)
{
    return (ValeurBit(LireRegistreFLAG(), 1));
}
int Sign(void)
{
    return (ValeurBit(LireRegistreFLAG(), 2));
}
int Parity(void)
{
    return (ValeurBit(LireRegistreFLAG(), 3));
}

void SetOverflow(void)
{
    registre[REG_FLAG] |= 1;
}
void SetZero(void)
{
    registre[REG_FLAG] |= 2;
}
void SetSign(void)
{
    registre[REG_FLAG] |= 4;
}
void SetParity(void)
{
    registre[REG_FLAG] |= 8;
}

void ResetOverflow(void)
{
    registre[REG_FLAG] &= (VAL_MAX - 1);
}
void ResetZero(void)
{
    registre[REG_FLAG] &= (VAL_MAX - 2);
}
void ResetSign(void)
{
    registre[REG_FLAG] &= (VAL_MAX - 4);
}
void ResetParity(void)
{
    registre[REG_FLAG] &= (VAL_MAX - 8);
}


void ResetRegistres(void)
{
    int i;

    for (i = 0; i < NB_REGISTRES_PHYSIQUES; i++)
	registre[i] = 0;
}