--- rpl/src/sequenceur.c	2013/03/06 09:00:26	1.68
+++ rpl/src/sequenceur.c	2019/10/31 15:40:25	1.108
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.13
-  Copyright (C) 1989-2013 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.32
+  Copyright (C) 1989-2019 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -44,6 +44,9 @@ sequenceur(struct_processus *s_etat_proc
 	struct_objet				*s_objet_evaluation;
 	struct_objet				*s_sous_objet;
 
+	integer8					niveau;
+	integer8					position_courante;
+
 	logical1					drapeau_appel_definition;
 	logical1					drapeau_fin;
 	logical1					drapeau_then;
@@ -61,12 +64,8 @@ sequenceur(struct_processus *s_etat_proc
 	unsigned char				*message;
 	unsigned char				*registre;
 	unsigned char				*tampon;
-	unsigned char				tampon_retour;
 	unsigned char				*t_ligne;
 
-	unsigned long				niveau;
-	unsigned long				position_courante;
-
 	Keymap						ancien_keymap;
 	Keymap						nouveau_keymap;
 
@@ -80,12 +79,12 @@ sequenceur(struct_processus *s_etat_proc
 		{
 			if ((*s_etat_processus).langue == 'F')
 			{
-				printf("[%d] Exécution récursive de niveau %lu\n",
+				printf("[%d] Exécution récursive de niveau %lld\n",
 						(int) getpid(), (*s_etat_processus).niveau_recursivite);
 			}
 			else
 			{
-				printf("[%d] %lu level recursive execution\n",
+				printf("[%d] %lld level recursive execution\n",
 						(int) getpid(), (*s_etat_processus).niveau_recursivite);
 			}
 		}
@@ -93,7 +92,7 @@ sequenceur(struct_processus *s_etat_proc
 		{
 			if ((*s_etat_processus).langue == 'F')
 			{
-				printf("[%d] Exécution\n", (int) getpid());
+				printf("[%d] Exécution\n", (int) getpid());
 			}
 			else
 			{
@@ -135,7 +134,7 @@ sequenceur(struct_processus *s_etat_proc
 			 */
 
 			action.sa_handler = SIG_IGN;
-			action.sa_flags = SA_NODEFER | SA_ONSTACK;
+			action.sa_flags = 0;
 
 			(*s_etat_processus).execution_pas_suivant = d_faux;
 			(*s_etat_processus).traitement_instruction_halt = d_vrai;
@@ -163,14 +162,22 @@ sequenceur(struct_processus *s_etat_proc
 					fflush(stdout);
 				}
 
+				if (pthread_mutex_lock(&mutex_sigaction) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return(d_erreur);
+				}
+
 				if (sigaction(SIGINT, &action, &action_defaut) != 0)
 				{
+					pthread_mutex_unlock(&mutex_sigaction);
 					(*s_etat_processus).erreur_systeme = d_es_signal;
 					return(d_erreur);
 				}
 
 				if (sigaction(SIGTSTP, &action, &action_defaut2) != 0)
 				{
+					pthread_mutex_unlock(&mutex_sigaction);
 					(*s_etat_processus).erreur_systeme = d_es_signal;
 					return(d_erreur);
 				}
@@ -198,18 +205,13 @@ sequenceur(struct_processus *s_etat_proc
 				funlockfile(stdin);
 				funlockfile(stdout);
 
-				if ((*s_etat_processus).var_volatile_requete_arret != 0)
-				{
-					(*s_etat_processus).requete_arret = 'Y';
-					break;
-				}
-
 				if (ligne != NULL)
 				{
 					if ((t_ligne = transliteration(s_etat_processus, ligne,
 							(*s_etat_processus).localisation, d_locale))
 							== NULL)
 					{
+						pthread_mutex_unlock(&mutex_sigaction);
 						free((*s_etat_processus).instruction_courante);
 						return(d_erreur);
 					}
@@ -217,8 +219,9 @@ sequenceur(struct_processus *s_etat_proc
 					free(ligne);
 					ligne = t_ligne;
 
-					if ((ligne = compactage(ligne)) == NULL)
+					if ((ligne = compactage(s_etat_processus, ligne)) == NULL)
 					{
+						pthread_mutex_unlock(&mutex_sigaction);
 						(*s_etat_processus).erreur_systeme =
 								d_es_allocation_memoire;
 						return(d_erreur);
@@ -227,16 +230,24 @@ sequenceur(struct_processus *s_etat_proc
 
 				if (sigaction(SIGINT, &action_defaut, NULL) != 0)
 				{
+					pthread_mutex_unlock(&mutex_sigaction);
 					(*s_etat_processus).erreur_systeme = d_es_signal;
 					return(d_erreur);
 				}
 
 				if (sigaction(SIGTSTP, &action_defaut2, NULL) != 0)
 				{
+					pthread_mutex_unlock(&mutex_sigaction);
 					(*s_etat_processus).erreur_systeme = d_es_signal;
 					return(d_erreur);
 				}
 
+				if (pthread_mutex_unlock(&mutex_sigaction) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return(d_erreur);
+				}
+
 				if (ligne == NULL)
 				{
 					if ((ligne = (unsigned char *) malloc(6 *
@@ -266,6 +277,13 @@ sequenceur(struct_processus *s_etat_proc
 					sprintf(ligne, "dup");
 				}
 
+				if ((*s_etat_processus).var_volatile_requete_arret != 0)
+				{
+					free(ligne);
+					(*s_etat_processus).requete_arret = 'Y';
+					break;
+				}
+
 				add_history(ligne);
 				stifle_history(ds_longueur_historique);
 
@@ -296,6 +314,7 @@ sequenceur(struct_processus *s_etat_proc
 					tampon = (*s_etat_processus).instruction_courante;
 					(*s_etat_processus).instruction_courante = ligne;
 
+					(*s_etat_processus).type_en_cours = NON;
 					recherche_type(s_etat_processus);
 
 					(*s_etat_processus).instruction_courante = tampon;
@@ -334,8 +353,15 @@ sequenceur(struct_processus *s_etat_proc
 					}
 					else
 					{
-						tampon_retour = (*(*s_etat_processus)
-								.l_base_pile_systeme).retour_definition;
+						position_courante =
+								(*s_etat_processus).position_courante;
+						empilement_pile_systeme(s_etat_processus);
+
+						if ((*s_etat_processus).erreur_systeme != d_es)
+						{
+							return(d_erreur);
+						}
+
 						(*(*s_etat_processus).l_base_pile_systeme)
 								.retour_definition = 'Y';
 
@@ -349,24 +375,25 @@ sequenceur(struct_processus *s_etat_proc
 
 							if ((*s_etat_processus).langue == 'F')
 							{
-								printf("+++Erreur : Défaut d'argument\n");
+								printf("+++Erreur : Défaut d'argument\n");
 							}
 							else
 							{
 								printf("+++Error : Too few arguments\n");
 							}
 
-							(*(*s_etat_processus).l_base_pile_systeme)
-									.retour_definition = tampon_retour;
+							depilement_pile_systeme(s_etat_processus);
+
+							if ((*s_etat_processus).erreur_systeme != d_es)
+							{
+								return(d_erreur);
+							}
 
 							fflush(stdout);
 						}
 						else if (evaluation(s_etat_processus, s_objet, 'I') ==
 								d_erreur)
 						{
-							(*(*s_etat_processus).l_base_pile_systeme)
-									.retour_definition = tampon_retour;
-
 							if ((*s_etat_processus).erreur_systeme != d_es)
 							{
 								if (test_cfsf(s_etat_processus, 51) == d_faux)
@@ -452,8 +479,8 @@ sequenceur(struct_processus *s_etat_proc
 							liberation(s_etat_processus, s_objet);
 						}
 
-						(*(*s_etat_processus).l_base_pile_systeme)
-								.retour_definition = tampon_retour;
+						(*s_etat_processus).position_courante =
+								position_courante;
 					}
 				}
 				else if ((*s_etat_processus).invalidation_message_erreur
@@ -532,6 +559,8 @@ sequenceur(struct_processus *s_etat_proc
 --------------------------------------------------------------------------------
 */
 
+			(*s_etat_processus).instruction_sensible = 'N';
+
 			analyse(s_etat_processus, NULL);
 
 			if ((*s_etat_processus).traitement_cycle_exit != 'N')
@@ -576,42 +605,42 @@ sequenceur(struct_processus *s_etat_proc
 --------------------------------------------------------------------------------
 */
 
-						if ((*s_etat_processus).debug == d_vrai)
-							if (((*s_etat_processus).type_debug &
-									d_debug_variables) != 0)
+						if (recherche_variable_partagee(s_etat_processus,
+								(*(*s_etat_processus)
+								.pointeur_variable_courante).nom,
+								(*(*s_etat_processus)
+								.pointeur_variable_courante).variable_partagee,
+								'P') != NULL)
 						{
-							if ((*s_etat_processus).langue == 'F')
+							// La variable existe.
+
+							if ((*s_etat_processus).debug == d_vrai)
+								if (((*s_etat_processus).type_debug &
+										d_debug_variables) != 0)
 							{
-								printf("[%d] Évaluation de la variable "
+								if ((*s_etat_processus).langue == 'F')
+								{
+									printf("[%d] Évaluation de la variable "
 										"partagée %s de type %d\n",
 										(int) getpid(), (*s_etat_processus)
 										.instruction_courante,
 										(*(*(*s_etat_processus)
-										.pointeur_variable_courante).objet)
-										.type);
-							}
-							else
-							{
-								printf("[%d] Pushing %s as %d type shared "
-										"variable \n", (int) getpid(),
+										.pointeur_variable_partagee_courante)
+										.objet).type);
+								}
+								else
+								{
+									printf("[%d] Pushing %s as %d type shared "
+										"variable\n", (int) getpid(),
 										(*s_etat_processus)
 										.instruction_courante,
 										(*(*(*s_etat_processus)
-										.pointeur_variable_courante).objet)
-										.type);
-							}
-
-							fflush(stdout);
-						}
+										.pointeur_variable_partagee_courante)
+										.objet).type);
+								}
 
-						if (recherche_variable_partagee(s_etat_processus,
-								(*(*s_etat_processus)
-								.pointeur_variable_courante).nom,
-								(*(*s_etat_processus)
-								.pointeur_variable_courante).variable_partagee,
-								'P') != NULL)
-						{
-							// La variable existe.
+								fflush(stdout);
+							}
 
 							if ((s_objet = copie_objet(s_etat_processus,
 									(*(*s_etat_processus)
@@ -644,6 +673,28 @@ sequenceur(struct_processus *s_etat_proc
 						else
 						{
 							// La variable n'existe plus.
+							if ((*s_etat_processus).debug == d_vrai)
+								if (((*s_etat_processus).type_debug &
+										d_debug_variables) != 0)
+							{
+								if ((*s_etat_processus).langue == 'F')
+								{
+									printf("[%d] Tentative d'accès à la "
+										"variable partagée non définie %s\n",
+										(int) getpid(), (*s_etat_processus)
+										.instruction_courante);
+								}
+								else
+								{
+									printf("[%d] Trying to access to undefined "
+										"shared variable %s\n",
+										(int) getpid(),
+										(*s_etat_processus)
+										.instruction_courante);
+								}
+
+								fflush(stdout);
+							}
 						}
 					}
 
@@ -709,6 +760,8 @@ sequenceur(struct_processus *s_etat_proc
 								}
 							}
 
+							(*s_etat_processus).debug_programme = d_faux;
+
 							(*(*s_etat_processus).l_base_pile_systeme)
 									.adresse_retour = (*s_etat_processus)
 									.position_courante;
@@ -721,7 +774,7 @@ sequenceur(struct_processus *s_etat_proc
 									.niveau_courant;
 
 							(*s_etat_processus).position_courante =
-									(*((unsigned long *)
+									(*((integer8 *)
 									((*(*(*s_etat_processus)
 									.pointeur_variable_courante)
 									.objet).objet)));
@@ -790,14 +843,17 @@ sequenceur(struct_processus *s_etat_proc
 */
 
 					(*s_etat_processus).erreur_systeme = d_es;
+					(*s_etat_processus).type_en_cours = NON;
 					recherche_type(s_etat_processus);
 
 					if ((*s_etat_processus).autorisation_nom_implicite == 'N')
 					{
 						if ((*s_etat_processus).l_base_pile == NULL)
 						{
-							if ((*s_etat_processus).erreur_execution !=
-									d_ex_nom_implicite)
+							if (((*s_etat_processus).erreur_execution !=
+									d_ex_nom_implicite) &&
+									((*s_etat_processus).erreur_execution !=
+									d_ex_syntaxe))
 							{
 								(*s_etat_processus).erreur_execution =
 										d_ex_manque_argument;
@@ -877,7 +933,8 @@ sequenceur(struct_processus *s_etat_proc
 */
 
 				if ((instruction_majuscule = conversion_majuscule(
-						(*s_etat_processus).instruction_courante)) == NULL)
+						s_etat_processus, (*s_etat_processus)
+						.instruction_courante)) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -898,12 +955,13 @@ sequenceur(struct_processus *s_etat_proc
 					(*((struct_fonction *) (*s_objet).objet))
 							.nombre_arguments = 0;
 
-					if ((*s_etat_processus).instruction_intrinseque == 'Y')
+					if (((*s_etat_processus).instruction_intrinseque == 'Y') &&
+							((*s_etat_processus).instruction_sensible == 'N'))
 					{
 						if (((*((struct_fonction *) (*s_objet).objet))
 								.nom_fonction = conversion_majuscule(
-								(*s_etat_processus).instruction_courante))
-								== NULL)
+								s_etat_processus, (*s_etat_processus)
+								.instruction_courante)) == NULL)
 						{
 							(*s_etat_processus).erreur_systeme =
 									d_es_allocation_memoire;
@@ -951,8 +1009,8 @@ sequenceur(struct_processus *s_etat_proc
 				free(instruction_majuscule);
 			}
 
-			erreur |= (((*s_etat_processus).erreur_execution != d_ex)
-					? d_erreur : d_absence_erreur);
+			erreur = (logical1) (erreur | (((*s_etat_processus)
+					.erreur_execution != d_ex) ? d_erreur : d_absence_erreur));
 		}
 		else
 		{
@@ -993,7 +1051,7 @@ sequenceur(struct_processus *s_etat_proc
 				{
 					if (strncmp(getenv("LANG"), "fr", 2) == 0)
 					{
-						printf("[%d] Arrêt\n", (int) getpid());
+						printf("[%d] Arrêt\n", (int) getpid());
 					}
 					else
 					{
@@ -1065,7 +1123,7 @@ sequenceur(struct_processus *s_etat_proc
 			(*s_etat_processus).exception = d_ep;
 			erreur = d_absence_erreur;
 
-			(*s_etat_processus).position_courante -=
+			(*s_etat_processus).position_courante -= (integer8)
 					strlen((*s_etat_processus).instruction_courante);
 		}
 
@@ -1175,7 +1233,7 @@ sequenceur(struct_processus *s_etat_proc
 									.niveau_courant;
 
 							(*s_etat_processus).position_courante =
-									(*((unsigned long *)
+									(*((integer8 *)
 									((*(*(*s_etat_processus)
 									.pointeur_variable_courante)
 									.objet).objet)));
@@ -1188,7 +1246,8 @@ sequenceur(struct_processus *s_etat_proc
 					{
 						(*s_etat_processus).erreur_systeme = d_es;
 						instruction_majuscule = conversion_majuscule(
-								(*s_etat_processus).instruction_courante);
+								s_etat_processus, (*s_etat_processus)
+								.instruction_courante);
 
 						if (instruction_majuscule == NULL)
 						{
@@ -1376,6 +1435,7 @@ sequenceur(struct_processus *s_etat_proc
 					}
 					
 					instruction_majuscule = conversion_majuscule(
+							s_etat_processus,
 							(*s_etat_processus).instruction_courante);
 
 					if (instruction_majuscule == NULL)
@@ -1487,7 +1547,7 @@ sequenceur(struct_processus *s_etat_proc
 		if ((*s_etat_processus).var_volatile_processus_pere == 0)
 		{
 			envoi_signal_processus((*s_etat_processus).pid_processus_pere,
-					rpl_sigalrm);
+					rpl_sigalrm, d_faux);
 		}
 		else
 		{