--- rpl/src/instructions_c1.c	2010/02/10 10:14:20	1.3
+++ rpl/src/instructions_c1.c	2015/09/18 13:41:12	1.55
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.11
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.23
+  Copyright (C) 1989-2015 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -425,7 +425,7 @@ instruction_ceil(struct_processus *s_eta
 			return;
 		}
 
-		(*((integer8 *) (*s_objet_resultat).objet)) =
+		(*((integer8 *) (*s_objet_resultat).objet)) = (integer8)
 				ceil((*((real8 *) (*s_objet_argument).objet)));
 
 		if (!(((((*((integer8 *) (*s_objet_resultat).objet)) - 1) <
@@ -670,6 +670,8 @@ instruction_ceil(struct_processus *s_eta
 void
 instruction_case(struct_processus *s_etat_processus)
 {
+	struct_liste_pile_systeme	*l_element_courant;
+
 	struct_objet				*s_objet;
 
 	(*s_etat_processus).erreur_execution = d_ex;
@@ -712,9 +714,28 @@ instruction_case(struct_processus *s_eta
 		return;
 	}
 
-	if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'S')
+	l_element_courant = (*s_etat_processus).l_base_pile_systeme;
+
+	while(l_element_courant != NULL)
 	{
+		if (((*l_element_courant).clause == 'S') ||
+			((*l_element_courant).clause == 'C') ||
+			((*l_element_courant).clause == 'K'))
+		{
+			break;
+		}
 
+		l_element_courant = (*l_element_courant).suivant;
+	}
+
+	if (l_element_courant == NULL)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_pile_vide;
+		return;
+	}
+
+	if ((*l_element_courant).clause == 'S')
+	{
 		/*
 		 * Première apparition de l'instruction CASE dans la structure de test.
 		 */
@@ -726,13 +747,12 @@ instruction_case(struct_processus *s_eta
 			return;
 		}
 
-		(*(*s_etat_processus).l_base_pile_systeme).objet_de_test = s_objet;
-		(*(*s_etat_processus).l_base_pile_systeme).clause = 'K';
+		(*l_element_courant).objet_de_test = s_objet;
+		(*l_element_courant).clause = 'K';
 	}
 
 	if ((s_objet = copie_objet(s_etat_processus,
-			(*(*s_etat_processus).l_base_pile_systeme)
-			.objet_de_test, 'P')) == NULL)
+			(*l_element_courant).objet_de_test, 'P')) == NULL)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 		return;
@@ -744,6 +764,21 @@ instruction_case(struct_processus *s_eta
 		return;
 	}
 
+	/*
+	 * Empilement sur la pile système ne servant qu'à la bonne exécution
+	 * des reprises sur erreur
+	 */
+
+	empilement_pile_systeme(s_etat_processus);
+
+	if ((*s_etat_processus).erreur_systeme != d_es)
+	{
+		return;
+	}
+
+	(*(*s_etat_processus).l_base_pile_systeme).clause =
+			(*l_element_courant).clause;
+	(*(*s_etat_processus).l_base_pile_systeme).type_cloture = 'K';
 	return;
 }
 
@@ -767,8 +802,8 @@ instruction_c_vers_r(struct_processus *s
 	struct_objet					*s_objet_resultat_1;
 	struct_objet					*s_objet_resultat_2;
 
-	unsigned long					i;
-	unsigned long					j;
+	integer8						i;
+	integer8						j;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -874,16 +909,16 @@ instruction_c_vers_r(struct_processus *s
 		}
 
 		if (((*((struct_vecteur *) (*s_objet_resultat_1).objet)).tableau =
-				malloc((*(((struct_vecteur *) (*s_objet_argument)
-				.objet))).taille * sizeof(real8))) == NULL)
+				malloc(((size_t) (*(((struct_vecteur *) (*s_objet_argument)
+				.objet))).taille) * sizeof(real8))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
 
 		if (((*((struct_vecteur *) (*s_objet_resultat_2).objet)).tableau =
-				malloc((*(((struct_vecteur *) (*s_objet_argument)
-				.objet))).taille * sizeof(real8))) == NULL)
+				malloc(((size_t) (*(((struct_vecteur *) (*s_objet_argument)
+				.objet))).taille) * sizeof(real8))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -930,16 +965,16 @@ instruction_c_vers_r(struct_processus *s
 		}
 
 		if (((*((struct_matrice *) (*s_objet_resultat_1).objet)).tableau =
-				malloc((*(((struct_matrice *) (*s_objet_argument)
-				.objet))).nombre_lignes * sizeof(real8 *))) == NULL)
+				malloc(((size_t) (*(((struct_matrice *) (*s_objet_argument)
+				.objet))).nombre_lignes) * sizeof(real8 *))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
 
 		if (((*((struct_matrice *) (*s_objet_resultat_2).objet)).tableau =
-				malloc((*(((struct_matrice *) (*s_objet_argument)
-				.objet))).nombre_lignes * sizeof(real8 *))) == NULL)
+				malloc(((size_t) (*(((struct_matrice *) (*s_objet_argument)
+				.objet))).nombre_lignes) * sizeof(real8 *))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -960,18 +995,18 @@ instruction_c_vers_r(struct_processus *s
 				.nombre_lignes; i++)
 		{
 			if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_1)
-					.objet)).tableau)[i] = malloc(
+					.objet)).tableau)[i] = malloc(((size_t)
 					(*(((struct_matrice *) (*s_objet_argument).objet)))
-					.nombre_colonnes * sizeof(real8))) == NULL)
+					.nombre_colonnes) * sizeof(real8))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
 
 			if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat_2)
-					.objet)).tableau)[i] = malloc(
+					.objet)).tableau)[i] = malloc(((size_t)
 					(*(((struct_matrice *) (*s_objet_argument).objet)))
-					.nombre_colonnes * sizeof(real8))) == NULL)
+					.nombre_colonnes) * sizeof(real8))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -1047,8 +1082,8 @@ instruction_conj(struct_processus *s_eta
 	struct_objet				*s_objet_argument;
 	struct_objet				*s_objet_resultat;
 
-	unsigned long				i;
-	unsigned long				j;
+	integer8					i;
+	integer8					j;
 
 	(*s_etat_processus).erreur_execution = d_ex;