rpl/src/sequenceur.c - diff

Return to sequenceur.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/sequenceur.c between versions 1.1.1.1 and 1.99

version 1.1.1.1, 2010/01/26 15:22:45	version 1.99, 2017/07/30 21:59:41
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.9	RPL/2 (R) version 4.1.27
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2017 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.

Line 20	Line 20
*/	*/


#include "rpl.conv.h"	#include "rpl-conv.h"


/*	/*
================================================================================	================================================================================
Boucle principale de l'interpréteur RPL/2	Boucle principale de l'interprète RPL/2
================================================================================	================================================================================
Entrées : structure sur l'état du processus	Entrées : structure sur l'état du processus
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Sorties : Néant	Sorties : néant
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Effets de bord : néant	Effets de bord : néant
================================================================================	================================================================================
Line 41 sequenceur(struct_processus *s_etat_proc	Line 41 sequenceur(struct_processus *s_etat_proc
struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;

struct_objet *s_objet;	struct_objet *s_objet;
	struct_objet *s_objet_evaluation;
struct_objet *s_sous_objet;	struct_objet *s_sous_objet;

	integer8 niveau;
	integer8 position_courante;

logical1 drapeau_appel_definition;	logical1 drapeau_appel_definition;
logical1 drapeau_fin;	logical1 drapeau_fin;
logical1 drapeau_then;	logical1 drapeau_then;
logical1 erreur;	logical1 erreur;
	logical1 presence_compteur;

static logical1 completion_valide = d_faux;	static logical1 completion_valide = d_faux;

Line 59 sequenceur(struct_processus *s_etat_proc	Line 64 sequenceur(struct_processus *s_etat_proc
unsigned char *message;	unsigned char *message;
unsigned char *registre;	unsigned char *registre;
unsigned char *tampon;	unsigned char *tampon;
unsigned char tampon_retour;
unsigned char *t_ligne;	unsigned char *t_ligne;

unsigned long i;	Keymap ancien_keymap;
unsigned long j;	Keymap nouveau_keymap;
unsigned long niveau;
unsigned long position_courante;

(*s_etat_processus).retour_routine_evaluation = 'N';	(*s_etat_processus).retour_routine_evaluation = 'N';

Line 77 sequenceur(struct_processus *s_etat_proc	Line 79 sequenceur(struct_processus *s_etat_proc
{	{
if ((*s_etat_processus).langue == 'F')	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);	(int) getpid(), (*s_etat_processus).niveau_recursivite);
}	}
else	else
{	{
printf("[%d] %lu level recursive execution\n",	printf("[%d] %lld level recursive execution\n",
(int) getpid(), (*s_etat_processus).niveau_recursivite);	(int) getpid(), (*s_etat_processus).niveau_recursivite);
}	}
}	}
Line 103 sequenceur(struct_processus *s_etat_proc	Line 105 sequenceur(struct_processus *s_etat_proc

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Boucle de l'interpréteur RPL/2	Boucle de l'interprète RPL/2
On boucle tant qu'on n'a pas une bonne raison de sortir...	On boucle tant qu'on n'a pas une bonne raison de sortir...
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

i = 0;
j = 0;

do	do
{	{
drapeau_appel_definition = d_faux;	drapeau_appel_definition = d_faux;
Line 181 sequenceur(struct_processus *s_etat_proc	Line 180 sequenceur(struct_processus *s_etat_proc
flockfile(stdin);	flockfile(stdin);
flockfile(stdout);	flockfile(stdout);

	ancien_keymap = rl_get_keymap();
	nouveau_keymap = rl_copy_keymap(ancien_keymap);
	rl_set_keymap(nouveau_keymap);

	rl_bind_key(NEWLINE, readline_analyse_syntaxique);
	rl_bind_key(RETURN, readline_analyse_syntaxique);
	rl_bind_key(CTRL('g'), readline_effacement);
	rl_done = 0;

ligne = readline("RPL/2> ");	ligne = readline("RPL/2> ");

	rl_set_keymap(ancien_keymap);
	rl_free(nouveau_keymap);

funlockfile(stdin);	funlockfile(stdin);
funlockfile(stdout);	funlockfile(stdout);

if ((*s_etat_processus).var_volatile_requete_arret != 0)
{
(*s_etat_processus).requete_arret = 'Y';
break;
}

if (ligne != NULL)	if (ligne != NULL)
{	{
if ((t_ligne = transliteration(s_etat_processus, ligne,	if ((t_ligne = transliteration(s_etat_processus, ligne,
(*s_etat_processus).localisation, d_locale))	(*s_etat_processus).localisation, d_locale))
== NULL)	== NULL)
{	{
	free((*s_etat_processus).instruction_courante);
return(d_erreur);	return(d_erreur);
}	}

free(ligne);	free(ligne);
ligne = t_ligne;	ligne = t_ligne;

if ((ligne = compactage(ligne)) == NULL)	if ((ligne = compactage(s_etat_processus, ligne)) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 253 sequenceur(struct_processus *s_etat_proc	Line 259 sequenceur(struct_processus *s_etat_proc
sprintf(ligne, "dup");	sprintf(ligne, "dup");
}	}

	if ((*s_etat_processus).var_volatile_requete_arret != 0)
	{
	free(ligne);
	(*s_etat_processus).requete_arret = 'Y';
	break;
	}

add_history(ligne);	add_history(ligne);
stifle_history(ds_longueur_historique);	stifle_history(ds_longueur_historique);

Line 282 sequenceur(struct_processus *s_etat_proc	Line 295 sequenceur(struct_processus *s_etat_proc

tampon = (*s_etat_processus).instruction_courante;	tampon = (*s_etat_processus).instruction_courante;
(*s_etat_processus).instruction_courante = ligne;	(*s_etat_processus).instruction_courante = ligne;

	(*s_etat_processus).type_en_cours = NON;
recherche_type(s_etat_processus);	recherche_type(s_etat_processus);

	(*s_etat_processus).instruction_courante = tampon;

if ((((*s_etat_processus).erreur_execution != d_ex) \|\|	if ((((*s_etat_processus).erreur_execution != d_ex) \|\|
((*s_etat_processus).erreur_systeme != d_es)) &&	((*s_etat_processus).erreur_systeme != d_es)) &&
((*s_etat_processus).invalidation_message_erreur	((*s_etat_processus).invalidation_message_erreur
Line 301 sequenceur(struct_processus *s_etat_proc	Line 318 sequenceur(struct_processus *s_etat_proc

if ((message = messages(s_etat_processus)) == NULL)	if ((message = messages(s_etat_processus)) == NULL)
{	{
	free((*s_etat_processus).instruction_courante);
return(d_erreur);	return(d_erreur);
}	}

Line 317 sequenceur(struct_processus *s_etat_proc	Line 335 sequenceur(struct_processus *s_etat_proc
}	}
else	else
{	{
tampon_retour = ((s_etat_processus)	position_courante =
.l_base_pile_systeme).retour_definition;	(*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)	((s_etat_processus).l_base_pile_systeme)
.retour_definition = 'Y';	.retour_definition = 'Y';

Line 339 sequenceur(struct_processus *s_etat_proc	Line 364 sequenceur(struct_processus *s_etat_proc
printf("+++Error : Too few arguments\n");	printf("+++Error : Too few arguments\n");
}	}

((s_etat_processus).l_base_pile_systeme)	depilement_pile_systeme(s_etat_processus);
.retour_definition = tampon_retour;
	if ((*s_etat_processus).erreur_systeme != d_es)
	{
	return(d_erreur);
	}

fflush(stdout);	fflush(stdout);
}	}
else if (evaluation(s_etat_processus, s_objet, 'I') ==	else if (evaluation(s_etat_processus, s_objet, 'I') ==
d_erreur)	d_erreur)
{	{
((s_etat_processus).l_base_pile_systeme)
.retour_definition = tampon_retour;

if ((*s_etat_processus).erreur_systeme != d_es)	if ((*s_etat_processus).erreur_systeme != d_es)
{	{
if (test_cfsf(s_etat_processus, 51) == d_faux)	if (test_cfsf(s_etat_processus, 51) == d_faux)
Line 360 sequenceur(struct_processus *s_etat_proc	Line 386 sequenceur(struct_processus *s_etat_proc
if ((message = messages(s_etat_processus))	if ((message = messages(s_etat_processus))
== NULL)	== NULL)
{	{
	free((*s_etat_processus)
	.instruction_courante);
return(d_erreur);	return(d_erreur);
}	}

printf("%s [%d]\n", message, (int) getpid());	printf("%s [%d]\n", message, (int) getpid());
free(message);

	free(message);
	free((*s_etat_processus).instruction_courante);
return(d_erreur);	return(d_erreur);
}	}
else if ((*s_etat_processus)	else if ((*s_etat_processus)
Line 383 sequenceur(struct_processus *s_etat_proc	Line 412 sequenceur(struct_processus *s_etat_proc
if ((message = messages(s_etat_processus))	if ((message = messages(s_etat_processus))
== NULL)	== NULL)
{	{
	free((*s_etat_processus)
	.instruction_courante);
return(d_erreur);	return(d_erreur);
}	}

Line 430 sequenceur(struct_processus *s_etat_proc	Line 461 sequenceur(struct_processus *s_etat_proc
liberation(s_etat_processus, s_objet);	liberation(s_etat_processus, s_objet);
}	}

((s_etat_processus).l_base_pile_systeme)	(*s_etat_processus).position_courante =
.retour_definition = tampon_retour;	position_courante;
}	}

(*s_etat_processus).instruction_courante = tampon;
}	}
else if ((*s_etat_processus).invalidation_message_erreur	else if ((*s_etat_processus).invalidation_message_erreur
== d_faux)	== d_faux)
Line 450 sequenceur(struct_processus *s_etat_proc	Line 479 sequenceur(struct_processus *s_etat_proc

if ((message = messages(s_etat_processus)) == NULL)	if ((message = messages(s_etat_processus)) == NULL)
{	{
	free((*s_etat_processus).instruction_courante);
free(ligne);	free(ligne);
return(d_erreur);	return(d_erreur);
}	}
Line 497 sequenceur(struct_processus *s_etat_proc	Line 527 sequenceur(struct_processus *s_etat_proc
/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Dans le cas où une instruction est retournée, celle-ci est évaluée. Dans le	Dans le cas où une instruction est retournée, celle-ci est évaluée. Dans le
cas contraire, l'interpréteur renvoie un message d'erreur et s'interrompt.	cas contraire, l'interprète renvoie un message d'erreur et s'interrompt.
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

Line 511 sequenceur(struct_processus *s_etat_proc	Line 541 sequenceur(struct_processus *s_etat_proc
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

	(*s_etat_processus).instruction_sensible = 'N';

analyse(s_etat_processus, NULL);	analyse(s_etat_processus, NULL);

if ((*s_etat_processus).traitement_cycle_exit != 'N')	if ((*s_etat_processus).traitement_cycle_exit != 'N')
Line 545 sequenceur(struct_processus *s_etat_proc	Line 577 sequenceur(struct_processus *s_etat_proc
d_vrai) && ((*s_etat_processus)	d_vrai) && ((*s_etat_processus)
.autorisation_evaluation_nom == 'Y'))	.autorisation_evaluation_nom == 'Y'))
{	{
if (((*s_etat_processus).s_liste_variables	if (((s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus)	.objet == NULL)
.position_variable_courante]).objet == NULL)
{	{

/*	/*
Line 556 sequenceur(struct_processus *s_etat_proc	Line 587 sequenceur(struct_processus *s_etat_proc
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

if ((*s_etat_processus).debug == d_vrai)	if (recherche_variable_partagee(s_etat_processus,
if (((*s_etat_processus).type_debug &	((s_etat_processus)
d_debug_variables) != 0)	.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] Empilement de la variable "	if ((*s_etat_processus).langue == 'F')
	{
	printf("[%d] Évaluation de la variable "
"partagée %s de type %d\n",	"partagée %s de type %d\n",
(int) getpid(),	(int) getpid(), (*s_etat_processus)
(*s_etat_processus)
.instruction_courante,	.instruction_courante,
(((s_etat_processus).s_liste_variables	(((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_partagee_courante)
.position_variable_courante]).objet)	.objet).type);
.type);	}
}	else
else	{
{	printf("[%d] Pushing %s as %d type shared "
printf("[%d] Pushing %s as %d type shared "	"variable\n", (int) getpid(),
"variable \n", (int) getpid(),
(*s_etat_processus)	(*s_etat_processus)
.instruction_courante,	.instruction_courante,
(((s_etat_processus).s_liste_variables	(((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_partagee_courante)
.position_variable_courante]).objet)	.objet).type);
.type);	}
}

fflush(stdout);
}

if (pthread_mutex_lock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme =
d_es_processus;
return(d_erreur);
}

if (recherche_variable_partagee(s_etat_processus,	fflush(stdout);
((*s_etat_processus).s_liste_variables	}
[(*s_etat_processus)
.position_variable_courante]).nom,
((*s_etat_processus).s_liste_variables
[(*s_etat_processus)
.position_variable_courante])
.variable_partagee, 'P') == d_vrai)
{
// La variable existe.

if ((s_objet = copie_objet(s_etat_processus,	if ((s_objet = copie_objet(s_etat_processus,
((s_etat_processus)	((s_etat_processus)
.s_liste_variables_partagees)	.pointeur_variable_partagee_courante)
.table[((s_etat_processus)	.objet, 'P')) == NULL)
.s_liste_variables_partagees)
.position_variable].objet, 'P'))
== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 620 sequenceur(struct_processus *s_etat_proc	Line 635 sequenceur(struct_processus *s_etat_proc
}	}

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex))	.pointeur_variable_partagee_courante)
!= 0)	.mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_processus;	d_es_processus;
return(d_erreur);	return(d_erreur);
}	}

if (empilement(s_etat_processus,	if (evaluation(s_etat_processus, s_objet, 'E')
&((*s_etat_processus).l_base_pile),	== d_erreur)
s_objet) == d_erreur)
{	{
(*s_etat_processus).erreur_systeme =	liberation(s_etat_processus, s_objet);
d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
}	}

	liberation(s_etat_processus, s_objet);
}	}
else	else
{	{
// La variable n'existe plus.	// La variable n'existe plus.
	if ((*s_etat_processus).debug == d_vrai)
(*s_etat_processus).erreur_systeme = d_es;	if (((*s_etat_processus).type_debug &
	d_debug_variables) != 0)
if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex))
!= 0)
{	{
(*s_etat_processus).erreur_systeme =	if ((*s_etat_processus).langue == 'F')
d_es_processus;	{
return(d_erreur);	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);
	}

recherche_type(s_etat_processus);	fflush(stdout);
	}
}	}
}	}

Line 662 sequenceur(struct_processus *s_etat_proc	Line 686 sequenceur(struct_processus *s_etat_proc
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

else if ((((s_etat_processus).s_liste_variables	else if ((((*s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus).position_variable_courante])
.objet).type == ADR)	.objet).type == ADR)
{	{

Line 731 sequenceur(struct_processus *s_etat_proc	Line 754 sequenceur(struct_processus *s_etat_proc
.niveau_courant;	.niveau_courant;

(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
(((unsigned long )	(((integer8 )
((((s_etat_processus).s_liste_variables	((((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante)
.position_variable_courante]	.objet).objet)));
.objet)).objet)));

drapeau_appel_definition = d_vrai;	drapeau_appel_definition = d_vrai;
}	}
Line 748 sequenceur(struct_processus *s_etat_proc	Line 770 sequenceur(struct_processus *s_etat_proc
{	{
if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
printf("[%d] Empilement de la variable "	printf("[%d] Évaluation de la variable "
"%s de type %d\n",	"%s de type %d\n",
(int) getpid(),	(int) getpid(),
(*s_etat_processus)	(*s_etat_processus)
.instruction_courante,	.instruction_courante,
(((s_etat_processus).s_liste_variables	(((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet)
.position_variable_courante]).objet)
.type);	.type);
}	}
else	else
Line 764 sequenceur(struct_processus *s_etat_proc	Line 785 sequenceur(struct_processus *s_etat_proc
"\n", (int) getpid(),	"\n", (int) getpid(),
(*s_etat_processus)	(*s_etat_processus)
.instruction_courante,	.instruction_courante,
(((s_etat_processus).s_liste_variables	(((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet)
.position_variable_courante]).objet)
.type);	.type);
}	}

Line 774 sequenceur(struct_processus *s_etat_proc	Line 794 sequenceur(struct_processus *s_etat_proc
}	}

if ((s_objet = copie_objet(s_etat_processus,	if ((s_objet = copie_objet(s_etat_processus,
((*s_etat_processus)	((s_etat_processus)
.s_liste_variables[(*s_etat_processus)	.pointeur_variable_courante).objet, 'P'))
.position_variable_courante]).objet, 'P'))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 784 sequenceur(struct_processus *s_etat_proc	Line 803 sequenceur(struct_processus *s_etat_proc
return(d_erreur);	return(d_erreur);
}	}

if (empilement(s_etat_processus,	if (evaluation(s_etat_processus, s_objet, 'E')
&((*s_etat_processus).l_base_pile),	== d_erreur)
s_objet) == d_erreur)
{	{
(*s_etat_processus).erreur_systeme =	liberation(s_etat_processus, s_objet);
d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
}	}

	liberation(s_etat_processus, s_objet);
}	}
}	}
else	else
Line 804 sequenceur(struct_processus *s_etat_proc	Line 823 sequenceur(struct_processus *s_etat_proc
*/	*/

(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
	(*s_etat_processus).type_en_cours = NON;
recherche_type(s_etat_processus);	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) &&
	((*s_etat_processus).erreur_execution !=
	d_ex_syntaxe))
	{
	(*s_etat_processus).erreur_execution =
	d_ex_manque_argument;
	}
	}
	else if ((((*s_etat_processus).l_base_pile).donnee)
	.type == NOM)
	{
	if ((((struct_nom ) (((*s_etat_processus)
	.l_base_pile).donnee).objet)).symbole
	== d_faux)
	{
	(*s_etat_processus).erreur_execution =
	d_ex_nom_implicite;

	// Si le niveau de récursivité est non nul, on
	// arrive ici depuis la fonction
	// recherche_type(). On retourne à cette
	// dernière en indiquant une erreur.

	if ((*s_etat_processus).niveau_recursivite != 0)
	{
	free((*s_etat_processus)
	.instruction_courante);
	return(d_erreur);
	}
	}
	}
	}

	// Le séquenceur est appelé depuis la routine d'évaluation

	if ((*s_etat_processus).evaluation_forcee == 'Y')
	{
	if (depilement(s_etat_processus,
	&((*s_etat_processus).l_base_pile),
	&s_objet_evaluation) == d_erreur)
	{
	free((*s_etat_processus).instruction_courante);
	(*s_etat_processus).erreur_execution =
	d_ex_manque_argument;
	return(d_erreur);
	}

	if (evaluation(s_etat_processus, s_objet_evaluation,
	'N') == d_erreur)
	{
	free((*s_etat_processus).instruction_courante);
	liberation(s_etat_processus, s_objet_evaluation);
	return(d_erreur);
	}

	liberation(s_etat_processus, s_objet_evaluation);
	}

	// Le séquenceur est appelé depuis la routine de
	// recherche de type

	else if ((*s_etat_processus).recherche_type == 'Y')
	{
	if ((*s_etat_processus).erreur_execution != d_ex)
	{
	free((*s_etat_processus).instruction_courante);
	return(d_erreur);
	}
	}
}	}
}	}
else if (((*s_etat_processus).test_instruction == 'Y') &&	else if (((*s_etat_processus).test_instruction == 'Y') &&
Line 818 sequenceur(struct_processus *s_etat_proc	Line 913 sequenceur(struct_processus *s_etat_proc
*/	*/

if ((instruction_majuscule = conversion_majuscule(	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 =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 829 sequenceur(struct_processus *s_etat_proc	Line 925 sequenceur(struct_processus *s_etat_proc
!= 0) && (strcmp((*s_etat_processus)	!= 0) && (strcmp((*s_etat_processus)
.instruction_courante, ">>") != 0))	.instruction_courante, ">>") != 0))
{	{
if ((s_objet = (struct_objet *) malloc(	if ((s_objet = allocation(s_etat_processus, FCT)) == NULL)
sizeof(struct_objet))) == NULL)
{
(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;
return(d_erreur);
}

initialisation_objet(s_objet);
(*s_objet).type = FCT;

if (((*s_objet).objet = allocation(s_etat_processus, FCT))
== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 851 sequenceur(struct_processus *s_etat_proc	Line 935 sequenceur(struct_processus *s_etat_proc
(((struct_fonction ) (*s_objet).objet))	(((struct_fonction ) (*s_objet).objet))
.nombre_arguments = 0;	.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))	if (((((struct_fonction ) (*s_objet).objet))
.nom_fonction = conversion_majuscule(	.nom_fonction = conversion_majuscule(
(*s_etat_processus).instruction_courante))	s_etat_processus, (*s_etat_processus)
== NULL)	.instruction_courante)) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 904 sequenceur(struct_processus *s_etat_proc	Line 989 sequenceur(struct_processus *s_etat_proc
free(instruction_majuscule);	free(instruction_majuscule);
}	}

erreur \|= (((*s_etat_processus).erreur_execution != d_ex)	erreur = (logical1) (erreur \| (((*s_etat_processus)
? d_erreur : d_absence_erreur);	.erreur_execution != d_ex) ? d_erreur : d_absence_erreur));
}	}
else	else
{	{
Line 924 sequenceur(struct_processus *s_etat_proc	Line 1009 sequenceur(struct_processus *s_etat_proc

fflush(stdout);	fflush(stdout);

	free((*s_etat_processus).instruction_courante);
return(d_erreur);	return(d_erreur);
}	}

Line 1005 sequenceur(struct_processus *s_etat_proc	Line 1091 sequenceur(struct_processus *s_etat_proc

if ((message = messages(s_etat_processus)) == NULL)	if ((message = messages(s_etat_processus)) == NULL)
{	{
	free((*s_etat_processus).instruction_courante);
return(d_erreur);	return(d_erreur);
}	}

Line 1016 sequenceur(struct_processus *s_etat_proc	Line 1103 sequenceur(struct_processus *s_etat_proc
(*s_etat_processus).exception = d_ep;	(*s_etat_processus).exception = d_ep;
erreur = d_absence_erreur;	erreur = d_absence_erreur;

(*s_etat_processus).position_courante -=	(*s_etat_processus).position_courante -= (integer8)
strlen((*s_etat_processus).instruction_courante);	strlen((*s_etat_processus).instruction_courante);
}	}

Line 1091 sequenceur(struct_processus *s_etat_proc	Line 1178 sequenceur(struct_processus *s_etat_proc

if (erreur == d_erreur)	if (erreur == d_erreur)
{	{
	free((*s_etat_processus).instruction_courante);
return(d_erreur);	return(d_erreur);
}	}

if (recherche_variable(s_etat_processus,	if (recherche_variable(s_etat_processus,
(*s_etat_processus).instruction_courante) == d_vrai)	(*s_etat_processus).instruction_courante) == d_vrai)
{	{
if (((*s_etat_processus).s_liste_variables	if (((s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus)	.objet == NULL)
.position_variable_courante]).objet == NULL)
{	{
// Variable partagée	// Variable partagée
}	}
else if ((((s_etat_processus).s_liste_variables	else if ((((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante).objet).type == ADR)
.position_variable_courante]).objet).type ==
ADR)
{	{
empilement_pile_systeme(s_etat_processus);	empilement_pile_systeme(s_etat_processus);

if ((*s_etat_processus).erreur_systeme != d_es)	if ((*s_etat_processus).erreur_systeme != d_es)
{	{
	free((*s_etat_processus).instruction_courante);
return(d_erreur);	return(d_erreur);
}	}

Line 1127 sequenceur(struct_processus *s_etat_proc	Line 1213 sequenceur(struct_processus *s_etat_proc
.niveau_courant;	.niveau_courant;

(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
(((unsigned long )	(((integer8 )
((((s_etat_processus).s_liste_variables	((((*s_etat_processus)
[(*s_etat_processus)	.pointeur_variable_courante)
.position_variable_courante]	.objet).objet)));
.objet)).objet)));

(*s_etat_processus)	(*s_etat_processus)
.autorisation_empilement_programme = 'N';	.autorisation_empilement_programme = 'N';
Line 1141 sequenceur(struct_processus *s_etat_proc	Line 1226 sequenceur(struct_processus *s_etat_proc
{	{
(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
instruction_majuscule = conversion_majuscule(	instruction_majuscule = conversion_majuscule(
(*s_etat_processus).instruction_courante);	s_etat_processus, (*s_etat_processus)
	.instruction_courante);

if (instruction_majuscule == NULL)	if (instruction_majuscule == NULL)
{	{
	free((*s_etat_processus).instruction_courante);
return(d_erreur);	return(d_erreur);
}	}

Line 1158 sequenceur(struct_processus *s_etat_proc	Line 1245 sequenceur(struct_processus *s_etat_proc
(strcmp(instruction_majuscule, "DO") == 0) \|\|	(strcmp(instruction_majuscule, "DO") == 0) \|\|
(strcmp(instruction_majuscule, "WHILE") == 0) \|\|	(strcmp(instruction_majuscule, "WHILE") == 0) \|\|
(strcmp(instruction_majuscule, "FOR") == 0) \|\|	(strcmp(instruction_majuscule, "FOR") == 0) \|\|
	(strcmp(instruction_majuscule, "FORALL") == 0)
	\|\|
(strcmp(instruction_majuscule, "START") == 0) \|\|	(strcmp(instruction_majuscule, "START") == 0) \|\|
(strcmp(instruction_majuscule, "SELECT") == 0)	(strcmp(instruction_majuscule, "SELECT") == 0)
	\|\|
	(strcmp(instruction_majuscule, "CRITICAL") == 0)
\|\| (strcmp(instruction_majuscule, "CASE") == 0)	\|\| (strcmp(instruction_majuscule, "CASE") == 0)
\|\| (strcmp(instruction_majuscule, "<<") == 0))	\|\| (strcmp(instruction_majuscule, "<<") == 0))
{	{
Line 1167 sequenceur(struct_processus *s_etat_proc	Line 1258 sequenceur(struct_processus *s_etat_proc
{	{
analyse(s_etat_processus, NULL);	analyse(s_etat_processus, NULL);
}	}
	else if ((strcmp(instruction_majuscule, "FOR") == 0)
	\|\| (strcmp(instruction_majuscule, "FORALL")
	== 0) \|\| (strcmp(instruction_majuscule,
	"START") == 0))
	{
	empilement_pile_systeme(s_etat_processus);

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
	return(d_erreur);
	}

	((s_etat_processus).l_base_pile_systeme)
	.type_cloture = 'L';
	}
else	else
{	{
empilement_pile_systeme(s_etat_processus);	empilement_pile_systeme(s_etat_processus);
Line 1199 sequenceur(struct_processus *s_etat_proc	Line 1305 sequenceur(struct_processus *s_etat_proc
return(d_absence_erreur);	return(d_absence_erreur);
}	}
}	}
	else if (((strcmp(instruction_majuscule, "NEXT")
	== 0) \|\| (strcmp(instruction_majuscule,
	"STEP") == 0)) && (((s_etat_processus)
	.l_base_pile_systeme).type_cloture != 'L'))
	{
	/*
	* Libération des compteurs de boucle.
	*/

	presence_compteur = ((((s_etat_processus)
	.l_base_pile_systeme).type_cloture
	== 'F') \|\| (((s_etat_processus)
	.l_base_pile_systeme).type_cloture
	== 'A')) ? d_vrai : d_faux;

	if ((((s_etat_processus).l_base_pile_systeme)
	.type_cloture != 'S') &&
	(presence_compteur == d_faux))
	{
	return(d_erreur);
	}

	if (presence_compteur == d_vrai)
	{
	if (recherche_variable(s_etat_processus,
	((s_etat_processus)
	.l_base_pile_systeme).nom_variable)
	== d_faux)
	{
	return(d_erreur);
	}

	if (((s_etat_processus)
	.pointeur_variable_courante).objet
	== NULL)
	{
	return(d_erreur);
	}

	(*s_etat_processus).niveau_courant--;

	if (retrait_variables_par_niveau(
	s_etat_processus) == d_erreur)
	{
	return(d_erreur);
	}
	}

	depilement_pile_systeme(s_etat_processus);

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
	return(d_erreur);
	}
	}
else	else
{	{
	// Traitement spécifique pour la fin
	// d'une section critique

	if ((*s_etat_processus).l_base_pile_systeme
	== NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_processus;
	return(d_erreur);
	}

	if (((s_etat_processus).l_base_pile_systeme)
	.type_cloture == 'Q')
	{
	if (pthread_mutex_unlock(
	&mutex_sections_critiques) != 0)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_processus;
	return(d_erreur);
	}

	(*s_etat_processus).sections_critiques--;
	}

depilement_pile_systeme(s_etat_processus);	depilement_pile_systeme(s_etat_processus);

if ((*s_etat_processus).erreur_systeme != d_es)	if ((*s_etat_processus).erreur_systeme != d_es)
Line 1229 sequenceur(struct_processus *s_etat_proc	Line 1415 sequenceur(struct_processus *s_etat_proc
}	}

instruction_majuscule = conversion_majuscule(	instruction_majuscule = conversion_majuscule(
	s_etat_processus,
(*s_etat_processus).instruction_courante);	(*s_etat_processus).instruction_courante);

if (instruction_majuscule == NULL)	if (instruction_majuscule == NULL)
Line 1241 sequenceur(struct_processus *s_etat_proc	Line 1428 sequenceur(struct_processus *s_etat_proc
(strcmp(instruction_majuscule, "DO") == 0) \|\|	(strcmp(instruction_majuscule, "DO") == 0) \|\|
(strcmp(instruction_majuscule, "WHILE") == 0) \|\|	(strcmp(instruction_majuscule, "WHILE") == 0) \|\|
(strcmp(instruction_majuscule, "FOR") == 0) \|\|	(strcmp(instruction_majuscule, "FOR") == 0) \|\|
	(strcmp(instruction_majuscule, "FORALL") == 0) \|\|
(strcmp(instruction_majuscule, "START") == 0) \|\|	(strcmp(instruction_majuscule, "START") == 0) \|\|
(strcmp(instruction_majuscule, "SELECT") == 0)	(strcmp(instruction_majuscule, "SELECT") == 0)
	\|\| (strcmp(instruction_majuscule, "CRITICAL") == 0)
\|\| (strcmp(instruction_majuscule, "CASE") == 0)	\|\| (strcmp(instruction_majuscule, "CASE") == 0)
\|\| (strcmp(instruction_majuscule, "<<") == 0))	\|\| (strcmp(instruction_majuscule, "<<") == 0))
{	{
Line 1337 sequenceur(struct_processus *s_etat_proc	Line 1526 sequenceur(struct_processus *s_etat_proc

if ((*s_etat_processus).var_volatile_processus_pere == 0)	if ((*s_etat_processus).var_volatile_processus_pere == 0)
{	{
kill((*s_etat_processus).pid_processus_pere, SIGALRM);	envoi_signal_processus((*s_etat_processus).pid_processus_pere,
	rpl_sigalrm, d_faux);
}	}
else	else
{	{

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.1.1.1
changed lines
	Added in v.1.99