--- rpl/src/instructions_c3.c	2010/03/04 10:17:50	1.5
+++ rpl/src/instructions_c3.c	2016/09/27 15:29:34	1.63
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.12
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.26
+  Copyright (C) 1989-2016 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -143,8 +143,8 @@ instruction_cnrm(struct_processus *s_eta
 	struct_objet				*s_objet_argument;
 	struct_objet				*s_objet_resultat;
 
-	unsigned long				i;
-	unsigned long				j;
+	integer8					i;
+	integer8					j;
 
 	void						*accumulateur;
 
@@ -206,6 +206,13 @@ instruction_cnrm(struct_processus *s_eta
 		for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
 				i++)
 		{
+			if (((integer8 *) (*((struct_vecteur *) (*s_objet_argument).objet))
+					.tableau)[i] == INT64_MIN)
+			{
+				depassement = d_vrai;
+				break;
+			}
+
 			entier_courant = abs(((integer8 *) (*((struct_vecteur *)
 					(*s_objet_argument).objet)).tableau)[i]);
 
@@ -237,7 +244,7 @@ instruction_cnrm(struct_processus *s_eta
 			for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
 					.taille; i++)
 			{
-				cumul_reel += (real8) abs(((integer8 *) (*((struct_vecteur *)
+				cumul_reel += abs((real8) ((integer8 *) (*((struct_vecteur *)
 						(*s_objet_argument).objet)).tableau)[i]);
 			}
 
@@ -260,8 +267,8 @@ instruction_cnrm(struct_processus *s_eta
 			return;
 		}
 
-		if ((accumulateur = malloc((*((struct_vecteur *)
-				(*s_objet_argument).objet)).taille * sizeof(real8))) == NULL)
+		if ((accumulateur = malloc(((size_t) (*((struct_vecteur *)
+				(*s_objet_argument).objet)).taille) * sizeof(real8))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -296,8 +303,8 @@ instruction_cnrm(struct_processus *s_eta
 			return;
 		}
 
-		if ((accumulateur = malloc((*((struct_vecteur *)
-				(*s_objet_argument).objet)).taille * sizeof(real8))) == NULL)
+		if ((accumulateur = malloc(((size_t) (*((struct_vecteur *)
+				(*s_objet_argument).objet)).taille) * sizeof(real8))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -345,6 +352,13 @@ instruction_cnrm(struct_processus *s_eta
 		for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
 				.nombre_lignes; i++)
 		{
+			if (((integer8 **) (*((struct_matrice *) (*s_objet_argument).objet))
+					.tableau)[i][0] == INT64_MIN)
+			{
+				depassement = d_vrai;
+				break;
+			}
+
 			entier_courant = abs(((integer8 **)
 					(*((struct_matrice *) (*s_objet_argument).objet))
 					.tableau)[i][0]);
@@ -371,6 +385,14 @@ instruction_cnrm(struct_processus *s_eta
 				for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
 						.nombre_lignes; i++)
 				{
+					if ((((integer8 **) (*((struct_matrice *)
+							(*s_objet_argument).objet)).tableau)[i][j])
+							== INT64_MIN)
+					{
+						depassement = d_vrai;
+						break;
+					}
+
 					entier_courant = abs(((integer8 **) (*((struct_matrice *)
 							(*s_objet_argument).objet)).tableau)[i][j]);
 
@@ -411,8 +433,8 @@ instruction_cnrm(struct_processus *s_eta
 				return;
 			}
 
-			if ((accumulateur = malloc((*((struct_matrice *)
-					(*s_objet_argument).objet)).nombre_lignes * sizeof(real8)))
+			if ((accumulateur = malloc(((size_t) (*((struct_matrice *)
+					(*s_objet_argument).objet)).nombre_lignes) * sizeof(real8)))
 					== NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -427,7 +449,7 @@ instruction_cnrm(struct_processus *s_eta
 				for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
 						.nombre_lignes; i++)
 				{
-					((real8 *) accumulateur)[i] = fabs((real8) ((integer8 **)
+					((real8 *) accumulateur)[i] = abs((real8) ((integer8 **)
 							(*((struct_matrice *)
 							(*s_objet_argument).objet)).tableau)[i][j]);
 				}
@@ -461,8 +483,8 @@ instruction_cnrm(struct_processus *s_eta
 			return;
 		}
 
-		if ((accumulateur = malloc((*((struct_matrice *)
-				(*s_objet_argument).objet)).nombre_lignes * sizeof(real8)))
+		if ((accumulateur = malloc(((size_t) (*((struct_matrice *)
+				(*s_objet_argument).objet)).nombre_lignes) * sizeof(real8)))
 				== NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -477,7 +499,7 @@ instruction_cnrm(struct_processus *s_eta
 			for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
 					.nombre_lignes; i++)
 			{
-				((real8 *) accumulateur)[i] = fabs(((real8 **)
+				((real8 *) accumulateur)[i] = abs(((real8 **)
 						(*((struct_matrice *)
 						(*s_objet_argument).objet)).tableau)[i][j]);
 			}
@@ -509,8 +531,8 @@ instruction_cnrm(struct_processus *s_eta
 			return;
 		}
 
-		if ((accumulateur = malloc((*((struct_matrice *)
-				(*s_objet_argument).objet)).nombre_lignes * sizeof(real8)))
+		if ((accumulateur = malloc(((size_t) (*((struct_matrice *)
+				(*s_objet_argument).objet)).nombre_lignes) * sizeof(real8)))
 				== NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -608,7 +630,7 @@ instruction_chr(struct_processus *s_etat
 			printf("(integer to character conversion)\n\n");
 		}
 
-		printf("    1: 0 <= %s <= 255\n", d_INT);
+		printf("    1: %s\n", d_INT);
 		printf("->  1: %s\n", d_CHN);
 
 		return;
@@ -642,8 +664,8 @@ instruction_chr(struct_processus *s_etat
 
 	if ((*s_objet_argument).type == INT)
 	{
-		if (((*((integer8 *) (*s_objet_argument).objet)) < 0) ||
-				((*((integer8 *) (*s_objet_argument).objet)) > 255))
+		if ((*((integer8 *) (*s_objet_argument).objet)) !=
+				(unsigned char) (*((integer8 *) (*s_objet_argument).objet)))
 		{
 			liberation(s_etat_processus, s_objet_argument);
 
@@ -651,22 +673,81 @@ instruction_chr(struct_processus *s_etat
 			return;
 		}
 
-		if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
+		if (isprint((unsigned char) (*((integer8 *) (*s_objet_argument).objet)))
+				!= 0)
 		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
-		}
+			if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
 
-		if (((*s_objet_resultat).objet = malloc(2 * sizeof(unsigned char)))
-				== NULL)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
+			if ((*((integer8 *) (*s_objet_argument).objet)) == '\\')
+			{
+				if (((*s_objet_resultat).objet = malloc(3 *
+						sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				((unsigned char *) (*s_objet_resultat).objet)[0] = '\\';
+				((unsigned char *) (*s_objet_resultat).objet)[1] = '\\';
+				((unsigned char *) (*s_objet_resultat).objet)[2] =
+						d_code_fin_chaine;
+			}
+			else if ((*((integer8 *) (*s_objet_argument).objet)) == '"')
+			{
+				if (((*s_objet_resultat).objet = malloc(3 *
+						sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				((unsigned char *) (*s_objet_resultat).objet)[0] = '\\';
+				((unsigned char *) (*s_objet_resultat).objet)[1] = '"';
+				((unsigned char *) (*s_objet_resultat).objet)[2] =
+						d_code_fin_chaine;
+			}
+			else
+			{
+				if (((*s_objet_resultat).objet = malloc(2 *
+						sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				((unsigned char *) (*s_objet_resultat).objet)[0] =
+						(unsigned char) (*((integer8 *)
+						(*s_objet_argument).objet));
+				((unsigned char *) (*s_objet_resultat).objet)[1] =
+						d_code_fin_chaine;
+			}
 		}
+		else
+		{
+			if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
 
-		((unsigned char *) (*s_objet_resultat).objet)[0] = (*((integer8 *)
-				(*s_objet_argument).objet));
-		((unsigned char *) (*s_objet_resultat).objet)[1] = d_code_fin_chaine;
+			if (((*s_objet_resultat).objet = malloc(5 * sizeof(unsigned char)))
+					== NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			sprintf((unsigned char *) (*s_objet_resultat).objet, "\\x%02X",
+					(unsigned char) (*((integer8 *)
+					(*s_objet_argument).objet)));
+		}
 	}
 
 /*