--- rpl/src/instructions_g2.c	2015/06/08 14:11:35	1.55
+++ rpl/src/instructions_g2.c	2018/12/22 10:13:10	1.65
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.22
-  Copyright (C) 1989-2015 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.29
+  Copyright (C) 1989-2018 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -35,6 +35,18 @@
 ================================================================================
 */
 
+static int
+fonction_comparaison(const void *argument_1, const void *argument_2)
+{
+	/*
+	uprintf("%p->%s\n",(unsigned char *) (**((struct_objet **) argument_2)).objet, (unsigned char *) (**((struct_objet **) argument_2)).objet);
+	uprintf("%p->%s\n",(unsigned char *) (**((struct_objet **) argument_1)).objet, (unsigned char *) (**((struct_objet **) argument_1)).objet);
+	*/
+	return(strcmp((unsigned char *) (**((struct_objet **) argument_1)).objet,
+			(unsigned char *) (**((struct_objet **) argument_2)).objet));
+}
+
+
 void
 instruction_get(struct_processus *s_etat_processus)
 {
@@ -46,12 +58,17 @@ instruction_get(struct_processus *s_etat
 	struct_objet						*s_objet_2;
 	struct_objet						*s_objet_3;
 	struct_objet						*s_objet_element;
+	struct_objet						*s_objet_noms;
 	struct_objet						*s_objet_resultat;
 
 	integer8							indice_i;
 	integer8							indice_j;
 	integer8							nombre_dimensions;
 
+	unsigned char						*registre_instruction_courante;
+	unsigned char						registre_instruction_valide;
+	unsigned char						registre_test;
+
 	(*s_etat_processus).erreur_execution = d_ex;
 
 	if ((*s_etat_processus).affichage_arguments == 'Y')
@@ -86,6 +103,17 @@ instruction_get(struct_processus *s_etat
 				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
 				d_SQL, d_SLB, d_PRC, d_MTX);
 
+		printf("    2: %s\n", d_REC);
+		printf("    1: %s\n", d_CHN);
+		printf("->  1: %s, %s, %s, %s, %s, %s,\n"
+				"       %s, %s, %s, %s, %s,\n"
+				"       %s, %s, %s, %s, %s,\n"
+				"       %s, %s, %s, %s,\n"
+				"       %s, %s\n\n",
+				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
+				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
+				d_SQL, d_SLB, d_PRC, d_MTX);
+
 		printf("    2: %s, %s\n", d_LST, d_NOM);
 		printf("    1: %s\n", d_INT);
 		printf("->  1: %s, %s, %s, %s, %s, %s,\n"
@@ -515,6 +543,87 @@ instruction_get(struct_processus *s_etat
 
 /*
 --------------------------------------------------------------------------------
+  Traitement des enregistrements
+--------------------------------------------------------------------------------
+*/
+
+	else if ((*s_objet_2).type == REC)
+	{
+		if ((*s_objet_1).type != CHN)
+		{
+			liberation(s_etat_processus, s_objet_1);
+			liberation(s_etat_processus, s_objet_2);
+
+			(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
+			return;
+		}
+
+		s_objet_noms = (*((struct_record *) (*s_objet_2).objet)).noms;
+
+		int i;
+		for(i = 0; i < (*((struct_tableau *) (*s_objet_noms).objet)).nombre_elements; uprintf("%d->%p (%s)\n", i,
+	(unsigned char *) (*(*((struct_tableau *) (*s_objet_noms).objet)).elements[i]).objet,
+	(unsigned char *) (*(*((struct_tableau *) (*s_objet_noms).objet)).elements[i]).objet), i++);
+
+		s_objet_element = bsearch((unsigned char *) (*s_objet_1).objet,
+				(*((struct_tableau *) (*s_objet_noms).objet)).elements,
+				(size_t) (*((struct_tableau *) (*s_objet_noms).objet))
+				.nombre_elements, sizeof(struct_objet *), fonction_comparaison);
+
+		uprintf("%d\n", s_objet_element - (*((struct_tableau *) (*s_objet_2).objet)).elements[0]);
+
+		/*
+		l_element_courant = (*s_objet_1).objet;
+		s_objet_element = s_objet_2;
+
+
+		while(l_element_courant != NULL)
+		{
+			if ((*(*l_element_courant).donnee).type != INT)
+			{
+				liberation(s_etat_processus, s_objet_1);
+				liberation(s_etat_processus, s_objet_2);
+
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_type_argument;
+				return;
+			}
+
+			if ((*s_objet_element).type != TBL)
+			{
+				liberation(s_etat_processus, s_objet_1);
+				liberation(s_etat_processus, s_objet_2);
+
+				(*s_etat_processus).erreur_execution = d_ex_element_inexistant;
+				return;
+			}
+
+			indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
+
+			if ((indice_i < 1) || (indice_i > (*((struct_tableau *)
+					(*s_objet_element).objet)).nombre_elements))
+			{
+				liberation(s_etat_processus, s_objet_1);
+				liberation(s_etat_processus, s_objet_2);
+
+				(*s_etat_processus).erreur_execution = d_ex_element_inexistant;
+				return;
+			}
+
+			s_objet_element = (*((struct_tableau *) (*s_objet_element)
+					.objet)).elements[indice_i - 1];
+			l_element_courant = (*l_element_courant).suivant;
+		}
+		if ((s_objet_resultat = copie_objet(s_etat_processus,
+				s_objet_element, 'P')) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+		*/
+	}
+/*
+--------------------------------------------------------------------------------
   Traitement des variables
 --------------------------------------------------------------------------------
 */
@@ -1236,14 +1345,76 @@ instruction_get(struct_processus *s_etat
 		return;
 	}
 
-	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			s_objet_resultat) == d_erreur)
+	liberation(s_etat_processus, s_objet_1);
+	liberation(s_etat_processus, s_objet_2);
+
+	if ((*s_objet_resultat).type == NOM)
 	{
-		return;
+		if ((*((struct_nom *) (*s_objet_resultat).objet)).symbole == d_faux)
+		{
+			if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
+			{
+				return;
+			}
+		}
+		else
+		{
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_resultat) == d_erreur)
+			{
+				return;
+			}
+		}
 	}
+	else if ((*s_objet_resultat).type == FCT)
+	{
+		registre_test = (*s_etat_processus).test_instruction;
+		registre_instruction_courante = (*s_etat_processus)
+				.instruction_courante;
+		registre_instruction_valide = (*s_etat_processus)
+				.instruction_valide;
 
-	liberation(s_etat_processus, s_objet_1);
-	liberation(s_etat_processus, s_objet_2);
+		(*s_etat_processus).test_instruction = 'Y';
+		(*s_etat_processus).instruction_courante =
+				(*((struct_fonction *) (*s_objet_resultat).objet)).nom_fonction;
+
+		analyse(s_etat_processus, NULL);
+
+		(*s_etat_processus).test_instruction = registre_test;
+		(*s_etat_processus).instruction_courante =
+				registre_instruction_courante;
+
+		if (((*s_etat_processus).instruction_valide == 'Y') &&
+				(*s_etat_processus).constante_symbolique == 'Y')
+		{
+			if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
+			{
+				(*s_etat_processus).instruction_valide =
+						registre_instruction_valide;
+				return;
+			}
+		}
+		else
+		{
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_resultat) == d_erreur)
+			{
+				(*s_etat_processus).instruction_valide =
+						registre_instruction_valide;
+				return;
+			}
+		}
+
+		(*s_etat_processus).instruction_valide = registre_instruction_valide;
+	}
+	else
+	{
+		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				s_objet_resultat) == d_erreur)
+		{
+			return;
+		}
+	}
 
 	return;
 }
@@ -1279,6 +1450,10 @@ instruction_geti(struct_processus *s_eta
 	integer8							nombre_dimensions;
 	integer8							nombre_elements;
 
+	unsigned char						*registre_instruction_courante;
+	unsigned char						registre_instruction_valide;
+	unsigned char						registre_test;
+
 	(*s_etat_processus).erreur_execution = d_ex;
 
 	if ((*s_etat_processus).affichage_arguments == 'Y')
@@ -2364,10 +2539,72 @@ instruction_geti(struct_processus *s_eta
 		return;
 	}
 
-	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			s_objet_resultat) == d_erreur)
+	if ((*s_objet_resultat).type == NOM)
 	{
-		return;
+		if ((*((struct_nom *) (*s_objet_resultat).objet)).symbole == d_faux)
+		{
+			if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
+			{
+				return;
+			}
+		}
+		else
+		{
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_resultat) == d_erreur)
+			{
+				return;
+			}
+		}
+	}
+	else if ((*s_objet_resultat).type == FCT)
+	{
+		registre_test = (*s_etat_processus).test_instruction;
+		registre_instruction_courante = (*s_etat_processus)
+				.instruction_courante;
+		registre_instruction_valide = (*s_etat_processus)
+				.instruction_valide;
+
+		(*s_etat_processus).test_instruction = 'Y';
+		(*s_etat_processus).instruction_courante =
+				(*((struct_fonction *) (*s_objet_resultat).objet)).nom_fonction;
+
+		analyse(s_etat_processus, NULL);
+
+		(*s_etat_processus).test_instruction = registre_test;
+		(*s_etat_processus).instruction_courante =
+				registre_instruction_courante;
+
+		if (((*s_etat_processus).instruction_valide == 'Y') &&
+				(*s_etat_processus).constante_symbolique == 'Y')
+		{
+			if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
+			{
+				(*s_etat_processus).instruction_valide =
+						registre_instruction_valide;
+				return;
+			}
+		}
+		else
+		{
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_resultat) == d_erreur)
+			{
+				(*s_etat_processus).instruction_valide =
+						registre_instruction_valide;
+				return;
+			}
+		}
+
+		(*s_etat_processus).instruction_valide = registre_instruction_valide;
+	}
+	else
+	{
+		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				s_objet_resultat) == d_erreur)
+		{
+			return;
+		}
 	}
 
 	return;