Indentation plus faible

1 files changed, 71 insertions, 71 deletions

diff --git a/lib/registre.c b/lib/registre.c
index a11a88c..82ecfdd 100644
--- a/lib/registre.c
+++ b/lib/registre.c
@@ -18,166 +18,166 @@ Uint32 registre[64];
 
 Uint32 LireRegistreRG(void)
 {
-	return (registre[REG_RG]);
+    return (registre[REG_RG]);
 }
 
 Uint32 LireRegistreRD(void)
 {
-	return (registre[REG_RD]);
+    return (registre[REG_RD]);
 }
 
 Uint32 LireRegistrePC(void)
 {
-	return (registre[REG_PC]);
+    return (registre[REG_PC]);
 }
 
 Uint32 LireRegistreFLAG(void)
 {
-	return (registre[REG_FLAG]);
+    return (registre[REG_FLAG]);
 }
 
 Uint32 LireRegistreSP(void)
 {
-	return (registre[REG_STACKPTR]);
+    return (registre[REG_STACKPTR]);
 }
 
 void EcrireRegistreRG(Uint32 val)
 {
-	registre[REG_RG] = val;
+    registre[REG_RG] = val;
 }
 
 void EcrireRegistreRD(Uint32 val)
 {
-	registre[REG_RD] = val;
+    registre[REG_RD] = val;
 }
 
 void EcrireRegistrePC(Uint32 val)
 {
-	registre[REG_PC] = val;
+    registre[REG_PC] = val;
 }
 
 void EcrireRegistreFLAG(Uint32 val)
 {
-	registre[REG_FLAG] = val;
+    registre[REG_FLAG] = val;
 }
 
 void EcrireRegistreSP(Uint32 val)
 {
-	registre[REG_STACKPTR] = 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);
-			}
-		}
+    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"));
-		}
+    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));
+    return (ValeurBit(LireRegistreFLAG(), 0));
 }
 int Zero(void)
 {
-	return (ValeurBit(LireRegistreFLAG(), 1));
+    return (ValeurBit(LireRegistreFLAG(), 1));
 }
 int Sign(void)
 {
-	return (ValeurBit(LireRegistreFLAG(), 2));
+    return (ValeurBit(LireRegistreFLAG(), 2));
 }
 int Parity(void)
 {
-	return (ValeurBit(LireRegistreFLAG(), 3));
+    return (ValeurBit(LireRegistreFLAG(), 3));
 }
 
 void SetOverflow(void)
 {
-	registre[REG_FLAG] |= 1;
+    registre[REG_FLAG] |= 1;
 }
 void SetZero(void)
 {
-	registre[REG_FLAG] |= 2;
+    registre[REG_FLAG] |= 2;
 }
 void SetSign(void)
 {
-	registre[REG_FLAG] |= 4;
+    registre[REG_FLAG] |= 4;
 }
 void SetParity(void)
 {
-	registre[REG_FLAG] |= 8;
+    registre[REG_FLAG] |= 8;
 }
 
 void ResetOverflow(void)
 {
-	registre[REG_FLAG] &= (VAL_MAX - 1);
+    registre[REG_FLAG] &= (VAL_MAX - 1);
 }
 void ResetZero(void)
 {
-	registre[REG_FLAG] &= (VAL_MAX - 2);
+    registre[REG_FLAG] &= (VAL_MAX - 2);
 }
 void ResetSign(void)
 {
-	registre[REG_FLAG] &= (VAL_MAX - 4);
+    registre[REG_FLAG] &= (VAL_MAX - 4);
 }
 void ResetParity(void)
 {
-	registre[REG_FLAG] &= (VAL_MAX - 8);
+    registre[REG_FLAG] &= (VAL_MAX - 8);
 }
 
 
 void ResetRegistres(void)
 {
-	int i;
+    int i;
 
-	for (i = 0; i < NB_REGISTRES_PHYSIQUES; i++)
-		registre[i] = 0;
+    for (i = 0; i < NB_REGISTRES_PHYSIQUES; i++)
+	registre[i] = 0;
 }