--- rpl/src/analyse.c	2011/04/14 13:18:54	1.39
+++ rpl/src/analyse.c	2012/12/18 13:19:33	1.76
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.0.prerelease.0
-  Copyright (C) 1989-2011 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.12
+  Copyright (C) 1989-2012 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -60,7 +60,7 @@ creation_instruction(struct_processus *s
 
 		(*(*s_etat_processus).arbre_instructions).feuille = NULL;
 
-		if (((*(*s_etat_processus).arbre_instructions).noeud =
+		if (((*(*s_etat_processus).arbre_instructions).noeuds =
 				malloc((*s_etat_processus).nombre_caracteres
 				* sizeof(struct_instruction))) == NULL)
 		{
@@ -70,7 +70,7 @@ creation_instruction(struct_processus *s
 
 		for(i = 0; i < (*s_etat_processus).nombre_caracteres; i++)
 		{
-			(*(*s_etat_processus).arbre_instructions).noeud[i] = NULL;
+			(*(*s_etat_processus).arbre_instructions).noeuds[i] = NULL;
 		}
 	}
 
@@ -83,12 +83,12 @@ creation_instruction(struct_processus *s
 				printf("Instruction=\"%s\", (*ptr)='%c'\n",
 				instruction, *ptr));
 
-		if ((*l_instruction_courante).noeud[(*s_etat_processus)
+		if ((*l_instruction_courante).noeuds[(*s_etat_processus)
 				.pointeurs_caracteres[*ptr]] == NULL)
 		{
 			// Le noeud suivant n'existe pas, on le crée.
 
-			if (((*l_instruction_courante).noeud[(*s_etat_processus)
+			if (((*l_instruction_courante).noeuds[(*s_etat_processus)
 					.pointeurs_caracteres[*ptr]] =
 					malloc(sizeof(struct_instruction))) == NULL)
 			{
@@ -96,11 +96,11 @@ creation_instruction(struct_processus *s
 				return;
 			}
 
-			(*(*l_instruction_courante).noeud[(*s_etat_processus)
+			(*(*l_instruction_courante).noeuds[(*s_etat_processus)
 					.pointeurs_caracteres[*ptr]]).feuille = NULL;
 
-			if (((*(*l_instruction_courante).noeud[(*s_etat_processus)
-					.pointeurs_caracteres[*ptr]]).noeud =
+			if (((*(*l_instruction_courante).noeuds[(*s_etat_processus)
+					.pointeurs_caracteres[*ptr]]).noeuds =
 					malloc((*s_etat_processus).nombre_caracteres
 					* sizeof(struct_instruction))) == NULL)
 			{
@@ -110,12 +110,12 @@ creation_instruction(struct_processus *s
 
 			for(i = 0; i < (*s_etat_processus).nombre_caracteres; i++)
 			{
-				(*(*l_instruction_courante).noeud[(*s_etat_processus)
-						.pointeurs_caracteres[*ptr]]).noeud[i] = NULL;
+				(*(*l_instruction_courante).noeuds[(*s_etat_processus)
+						.pointeurs_caracteres[*ptr]]).noeuds[i] = NULL;
 			}
 		}
 
-		l_instruction_courante = (*l_instruction_courante).noeud
+		l_instruction_courante = (*l_instruction_courante).noeuds
 				[(*s_etat_processus).pointeurs_caracteres[*ptr]];
 		ptr++;
 	}
@@ -137,13 +137,13 @@ liberation_arbre_instructions(struct_pro
 
 	for(i = 0; i < (*s_etat_processus).nombre_caracteres; i++)
 	{
-		if ((*arbre).noeud[i] != NULL)
+		if ((*arbre).noeuds[i] != NULL)
 		{
-			liberation_arbre_instructions(s_etat_processus, (*arbre).noeud[i]);
+			liberation_arbre_instructions(s_etat_processus, (*arbre).noeuds[i]);
 		}
 	}
 
-	free((*arbre).noeud);
+	free((*arbre).noeuds);
 	free(arbre);
 
 	return;
@@ -458,9 +458,7 @@ initialisation_instructions(struct_proce
 	INSTRUCTION("INCR", instruction_incr);
 	//INSTRUCTION("ISOL");
 	INSTRUCTION("ISWI", instruction_iswi);
-#	ifndef OS2
 	INSTRUCTION("KILL", instruction_kill);
-#	endif
 	INSTRUCTION("KIND", instruction_kind);
 	INSTRUCTION("LAST", instruction_last);
 	INSTRUCTION("LEGV", instruction_legv);
@@ -488,9 +486,8 @@ initialisation_instructions(struct_proce
 	INSTRUCTION("PLOT", instruction_plot);
 	INSTRUCTION("PMAX", instruction_pmax);
 	INSTRUCTION("PMIN", instruction_pmin);
-#	ifndef OS2
 	INSTRUCTION("POKE", instruction_poke);
-#	endif
+	INSTRUCTION("POLL", instruction_poll);
 	INSTRUCTION("PPAR", instruction_ppar);
 	INSTRUCTION("PRMD", instruction_prmd);
 	INSTRUCTION("PRST", instruction_prst);
@@ -544,6 +541,7 @@ initialisation_instructions(struct_proce
 	INSTRUCTION("SPAR", instruction_spar);
 	INSTRUCTION("SQRT", instruction_sqrt);
 	//INSTRUCTION("SRAD");
+	INSTRUCTION("SREV", instruction_srev);
 	//INSTRUCTION("SRNM")
 	//Instruction HP48 (renvoie la norme spectrale d'un tableau. Pour une
 	//matrice,
@@ -556,9 +554,7 @@ initialisation_instructions(struct_proce
 	INSTRUCTION("STO-", instruction_sto_moins);
 	INSTRUCTION("STO/", instruction_sto_division);
 	INSTRUCTION("STOF", instruction_stof);
-#	ifndef OS2
 	INSTRUCTION("STOP", instruction_stop);
-#	endif
 	INSTRUCTION("STOS", instruction_stos);
 	INSTRUCTION("STWS", instruction_stws);
 	INSTRUCTION("SWAP", instruction_swap);
@@ -652,6 +648,7 @@ initialisation_instructions(struct_proce
 	INSTRUCTION("LCASE", instruction_lcase);
 	INSTRUCTION("LCHOL", instruction_lchol);
 	INSTRUCTION("LCD->", instruction_lcd_fleche);
+	INSTRUCTION("LIMIT", instruction_limit);
 	//INSTRUCTION("NDIST")
 	//Instruction HP48 (distribution normale, prend la moyenne au niveau 3,
 	//la variance au niveau 2, un réel x au niveau 1 et renvoie la probabilité
@@ -680,6 +677,7 @@ initialisation_instructions(struct_proce
 	INSTRUCTION("PSDEV", instruction_psdev);
 	INSTRUCTION("PURGE", instruction_purge);
 	INSTRUCTION("RDATE", instruction_rdate);
+	INSTRUCTION("REGEX", instruction_regex);
 	INSTRUCTION("RELAX", instruction_relax);
 	INSTRUCTION("RFUSE", instruction_rfuse);
 	INSTRUCTION("RSTOP", instruction_rstop);
@@ -692,9 +690,7 @@ initialisation_instructions(struct_proce
 	INSTRUCTION("SLICE", instruction_slice);
 	//INSTRUCTION("SLIST")
 	//Instruction HP48 (somme des termes d'une liste)
-#	ifndef OS2
 	INSTRUCTION("SPAWN", instruction_spawn);
-#	endif
 	INSTRUCTION("START", instruction_start);
 	INSTRUCTION("STORE", instruction_store);
 	INSTRUCTION("STR->", instruction_str_fleche);
@@ -731,8 +727,23 @@ initialisation_instructions(struct_proce
 	INSTRUCTION("CLRSWI", instruction_clrswi);
 	INSTRUCTION("CREATE", instruction_create);
 	INSTRUCTION("DELETE", instruction_delete);
-#	ifndef OS2
-	INSTRUCTION("DETACH", instruction_detach);
+#	ifdef SHARED_MEMORY
+		INSTRUCTION("DETACH", instruction_detach);
+#	else
+		if ((*s_etat_processus).langue == 'F')
+		{
+			printf("+++Attention : DETACH est émulé par SPAWN car le système"
+					" hôte ne supporte\n"
+					"               pas de mémoire partagée !\n");
+		}
+		else
+		{
+			printf("+++Warning : DETACH is replaced by SPAWN as host system"
+					" does not support\n"
+					"             shared memory !\n");
+		}
+
+		INSTRUCTION("DETACH", instruction_spawn);
 #	endif
 	INSTRUCTION("DIAG->", instruction_diag_fleche);
 	//INSTRUCTION("DOLIST")
@@ -746,6 +757,7 @@ initialisation_instructions(struct_proce
 	//DOLIST
 	//=> { 29 42 57 }
 	INSTRUCTION("ELSEIF", instruction_elseif);
+	INSTRUCTION("FORALL", instruction_forall);
 	INSTRUCTION("FORMAT", instruction_format);
 	//INSTRUCTION("HEIGHT")
 	INSTRUCTION("ITRACE", instruction_itrace);
@@ -814,6 +826,7 @@ initialisation_instructions(struct_proce
 	INSTRUCTION("PROTECT", instruction_protect);
 	INSTRUCTION("PSHPRFL", instruction_pshprfl);
 	INSTRUCTION("PULPRFL", instruction_pulprfl);
+	INSTRUCTION("RESTART", instruction_restart);
 	INSTRUCTION("REVLIST", instruction_revlist);
 	INSTRUCTION("SCATTER", instruction_scatter);
 	INSTRUCTION("SUSPEND", instruction_suspend);
@@ -827,12 +840,12 @@ initialisation_instructions(struct_proce
 
 	INSTRUCTION("CLRCNTXT", instruction_clrcntxt);
 	INSTRUCTION("CLRSMPHR", instruction_clrsmphr);
-#	ifndef OS2
 	INSTRUCTION("CONTINUE", instruction_continue);
-#	endif
+	INSTRUCTION("CRITICAL", instruction_critical);
 	INSTRUCTION("DUPCNTXT", instruction_dupcntxt);
 	INSTRUCTION("FUNCTION", instruction_function);
 	INSTRUCTION("IMPLICIT", instruction_implicit);
+	INSTRUCTION("INFINITY", instruction_sensible_infinity);
 	INSTRUCTION("KEYLABEL", instruction_keylabel);
 	INSTRUCTION("KEYTITLE", instruction_keytitle);
 	INSTRUCTION("LOGSCALE", instruction_logscale);
@@ -917,14 +930,14 @@ analyse_instruction(struct_processus *s_
 			return(NULL);
 		}
 
-		if ((*l_instruction_courante).noeud[pointeur] == NULL)
+		if ((*l_instruction_courante).noeuds[pointeur] == NULL)
 		{
 			// Le chemin de l'instruction candidate n'existe pas.
 
 			return(NULL);
 		}
 
-		l_instruction_courante = (*l_instruction_courante).noeud[pointeur];
+		l_instruction_courante = (*l_instruction_courante).noeuds[pointeur];
 		ptr++;
 
 		if ((l_instruction_courante == NULL) && ((*ptr) != d_code_fin_chaine))
@@ -957,8 +970,13 @@ analyse(struct_processus *s_etat_process
 	static struct timeval			horodatage_initial;
 	struct timeval					horodatage_final;
 
+#	ifndef OS2
 	static struct rusage			usage_initial;
 	struct rusage					usage_final;
+#	else
+	static clock_t					usage_initial;
+	clock_t							usage_final;
+#	endif
 
 	struct timespec					temporisation;
 
@@ -983,13 +1001,20 @@ analyse(struct_processus *s_etat_process
 	 */
 
 #	ifndef SEMAPHORES_NOMMES
-	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
+		if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
+#	else
+		if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#	endif
 	{
 		(*s_etat_processus).erreur_systeme = d_es_processus;
 		return;
 	}
 
-	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+#	ifndef SEMAPHORES_NOMMES
+		while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
+#	else
+		while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
+#	endif
 	{
 		if (errno != EINTR)
 		{
@@ -997,22 +1022,22 @@ analyse(struct_processus *s_etat_process
 			return;
 		}
 	}
-#	else
-	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+
+	/*
+	 * Verrou pour les sections_critiques
+	 */
+
+	if (pthread_mutex_lock(&mutex_sections_critiques) != 0)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_processus;
 		return;
 	}
 
-	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+	if (pthread_mutex_unlock(&mutex_sections_critiques) != 0)
 	{
-		if (errno != EINTR)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_processus;
-			return;
-		}
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return;
 	}
-#	endif
 
 	scrutation_injection(s_etat_processus);
 
@@ -1157,10 +1182,14 @@ analyse(struct_processus *s_etat_process
 --------------------------------------------------------------------------------
 */
 
-#	ifndef OS2
 	if ((*s_etat_processus).pourcentage_maximal_cpu < 100)
 	{
+#		ifndef OS2
 		getrusage(RUSAGE_SELF, &usage_final);
+#		else
+		usage_final = clock();
+#		endif
+
 		gettimeofday(&horodatage_final, NULL);
 
 		if (initialisation == d_vrai)
@@ -1170,8 +1199,12 @@ analyse(struct_processus *s_etat_process
 					(((real8) (horodatage_final.tv_usec -
 					horodatage_initial.tv_usec)) / ((real8) 1E6));
 
+			// Le temps depuis la dernière limitation est de plus de un
+			// dixième de seconde.
+
 			if (temps_reel >= 0.1)
 			{
+#				ifndef OS2
 				temps_cpu = ((real8) ((usage_final.ru_utime.tv_sec +
 						usage_final.ru_stime.tv_sec) -
 						(usage_initial.ru_utime.tv_sec +
@@ -1180,6 +1213,9 @@ analyse(struct_processus *s_etat_process
 						usage_final.ru_stime.tv_usec) -
 						(usage_initial.ru_utime.tv_usec +
 						usage_initial.ru_stime.tv_usec))) / ((real8) 1E6));
+#				else
+				temps_cpu = (usage_final - usage_initial) / CLOCKS_PER_SEC;
+#				endif
 
 				pourcentage = 100 * temps_cpu / temps_reel;
 
@@ -1198,7 +1234,13 @@ analyse(struct_processus *s_etat_process
 					temporisation.tv_nsec = (attente - temporisation.tv_sec) *
 							1E9;
 
-					nanosleep(&temporisation, NULL);
+					while(nanosleep(&temporisation, &temporisation) == -1)
+					{
+						if (errno != EINTR)
+						{
+							break;
+						}
+					}
 				}
 
 				horodatage_initial = horodatage_final;
@@ -1213,7 +1255,10 @@ analyse(struct_processus *s_etat_process
 			usage_initial = usage_final;
 		}
 	}
-#	endif
+	else
+	{
+		initialisation = d_faux;
+	}
 
 /*
 --------------------------------------------------------------------------------