--- rpl/src/instructions_n2.c	2011/04/21 16:00:58	1.18
+++ rpl/src/instructions_n2.c	2019/01/01 09:03:06	1.65
@@ -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.30
+  Copyright (C) 1989-2019 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -38,9 +38,13 @@
 void
 instruction_num(struct_processus *s_etat_processus)
 {
+	integer8					longueur;
+
 	struct_objet				*s_objet_argument;
 	struct_objet				*s_objet_resultat;
 
+	unsigned char				*chaine;
+
 	(*s_etat_processus).erreur_execution = d_ex;
 
 	if ((*s_etat_processus).affichage_arguments == 'Y')
@@ -90,7 +94,8 @@ instruction_num(struct_processus *s_etat
 
 	if ((*s_objet_argument).type == CHN)
 	{
-		if (strlen((unsigned char *) (*s_objet_argument).objet) != 1)
+		if (longueur_chaine(s_etat_processus, (unsigned char *)
+				(*s_objet_argument).objet) != 1)
 		{
 			liberation(s_etat_processus, s_objet_argument);
 
@@ -98,14 +103,21 @@ instruction_num(struct_processus *s_etat
 			return;
 		}
 
+		if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
+				(*s_objet_argument).objet, &longueur)) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
 		if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
 
-		(*((integer8 *) (*s_objet_resultat).objet)) =
-				(integer8) ((unsigned char *) (*s_objet_argument).objet)[0];
+		(*((integer8 *) (*s_objet_resultat).objet)) = chaine[0];
+		free(chaine);
 	}
 
 /*
@@ -149,10 +161,6 @@ instruction_num(struct_processus *s_etat
 void
 instruction_ns(struct_processus *s_etat_processus)
 {
-	logical1					presence_variable;
-
-	long						i;
-
 	struct_objet				*s_objet_resultat;
 
 	(*s_etat_processus).erreur_execution = d_ex;
@@ -194,73 +202,33 @@ instruction_ns(struct_processus *s_etat_
 		return;
 	}
 
-	if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
+	if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
 	{
 		/*
 		 * Aucune variable SIGMA
 		 */
 
 		(*s_etat_processus).erreur_systeme = d_es;
+		(*s_etat_processus).erreur_execution = d_ex;
+
 		(*((integer8 *) (*s_objet_resultat).objet)) = 0;
 	}
 	else
 	{
-		/*
-		 * Il existe une variable locale SIGMA. Reste à vérifier l'existence
-		 * d'une variable SIGMA globale...
-		 */
-
-		i = (*s_etat_processus).position_variable_courante;
-		presence_variable = d_faux;
-
-		while(i >= 0)
+		if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
+				.type != MIN) && ((*(*(*s_etat_processus)
+				.pointeur_variable_courante).objet).type != MRL))
 		{
-			if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
-					ds_sdat) == 0) && ((*s_etat_processus)
-					.s_liste_variables[i].niveau == 1))
-			{
-				presence_variable = d_vrai;
-				break;
-			}
-
-			i--;
-		}
+			liberation(s_etat_processus, s_objet_resultat);
 
-		if (presence_variable == d_faux)
-		{
-			(*((integer8 *) (*s_objet_resultat).objet)) = 0;
+			(*s_etat_processus).erreur_execution =
+					d_ex_matrice_statistique_invalide;
+			return;
 		}
-		else
-		{
-			(*s_etat_processus).position_variable_courante = i;
 
-			if (((*s_etat_processus).s_liste_variables[i]).objet == NULL)
-			{
-				liberation(s_etat_processus, s_objet_resultat);
-
-				(*s_etat_processus).erreur_execution = d_ex_variable_partagee;
-				return;
-			}
-
-			if (((*((*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante].objet))
-					.type != MIN) && ((*((*s_etat_processus)
-					.s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].objet)).type != MRL))
-			{
-				liberation(s_etat_processus, s_objet_resultat);
-
-				(*s_etat_processus).erreur_execution =
-						d_ex_matrice_statistique_invalide;
-				return;
-			}
-
-			(*((integer8 *) (*s_objet_resultat).objet)) =
-					(*((struct_matrice *) (*((*s_etat_processus)
-					.s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].objet)).objet))
-					.nombre_lignes;
-		}
+		(*((integer8 *) (*s_objet_resultat).objet)) =
+				(*((struct_matrice *) (*(*(*s_etat_processus)
+				.pointeur_variable_courante).objet).objet)).nombre_lignes;
 	}
 
 	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
@@ -381,5 +349,73 @@ instruction_nrproc(struct_processus *s_e
 
 	return;
 }
+
+
+/*
+================================================================================
+  Fonction 'nbrcpus'
+================================================================================
+  Entrées : structure processus
+--------------------------------------------------------------------------------
+  Sorties :
+--------------------------------------------------------------------------------
+  Effets de bord : néant
+================================================================================
+*/
+
+void
+instruction_nbrcpus(struct_processus *s_etat_processus)
+{
+	struct_objet				*s_objet_resultat;
+
+	(*s_etat_processus).erreur_execution = d_ex;
+
+	if ((*s_etat_processus).affichage_arguments == 'Y')
+	{
+		printf("\n  NBRCPUS ");
+
+		if ((*s_etat_processus).langue == 'F')
+		{
+			printf("(nombre de processeurs sur le système)\n\n");
+			printf("->  1: %s\n", d_INT);
+		}
+		else
+		{
+			printf("(number of processors on system)\n\n");
+			printf("->  1: %s\n", d_INT);
+		}
+
+		return;
+	}
+	else if ((*s_etat_processus).test_instruction == 'Y')
+	{
+		(*s_etat_processus).nombre_arguments = -1;
+		return;
+	}
+	
+	if (test_cfsf(s_etat_processus, 31) == d_vrai)
+	{
+		if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
+		{
+			return;
+		}
+	}
+
+	if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	(*((integer8 *) (*s_objet_resultat).objet)) = omp_get_num_procs();
+
+	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+			s_objet_resultat) == d_erreur)
+	{
+		return;
+	}
+
+	return;
+}
 
 // vim: ts=4