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.85 and 1.112

version 1.85, 2015/01/27 14:18:09	version 1.112, 2023/08/07 17:43:00
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.20	RPL/2 (R) version 4.1.35
Copyright (C) 1989-2015 Dr. BERTRAND Joël	Copyright (C) 1989-2023 Dr. BERTRAND Joël

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

Line 134 sequenceur(struct_processus *s_etat_proc	Line 134 sequenceur(struct_processus *s_etat_proc
*/	*/

action.sa_handler = SIG_IGN;	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).execution_pas_suivant = d_faux;
(*s_etat_processus).traitement_instruction_halt = d_vrai;	(*s_etat_processus).traitement_instruction_halt = d_vrai;
Line 162 sequenceur(struct_processus *s_etat_proc	Line 162 sequenceur(struct_processus *s_etat_proc
fflush(stdout);	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)	if (sigaction(SIGINT, &action, &action_defaut) != 0)
{	{
	pthread_mutex_unlock(&mutex_sigaction);
(*s_etat_processus).erreur_systeme = d_es_signal;	(*s_etat_processus).erreur_systeme = d_es_signal;
return(d_erreur);	return(d_erreur);
}	}

if (sigaction(SIGTSTP, &action, &action_defaut2) != 0)	if (sigaction(SIGTSTP, &action, &action_defaut2) != 0)
{	{
	pthread_mutex_unlock(&mutex_sigaction);
(*s_etat_processus).erreur_systeme = d_es_signal;	(*s_etat_processus).erreur_systeme = d_es_signal;
return(d_erreur);	return(d_erreur);
}	}
Line 203 sequenceur(struct_processus *s_etat_proc	Line 211 sequenceur(struct_processus *s_etat_proc
(*s_etat_processus).localisation, d_locale))	(*s_etat_processus).localisation, d_locale))
== NULL)	== NULL)
{	{
	pthread_mutex_unlock(&mutex_sigaction);
free((*s_etat_processus).instruction_courante);	free((*s_etat_processus).instruction_courante);
return(d_erreur);	return(d_erreur);
}	}
Line 212 sequenceur(struct_processus *s_etat_proc	Line 221 sequenceur(struct_processus *s_etat_proc

if ((ligne = compactage(s_etat_processus, ligne)) == NULL)	if ((ligne = compactage(s_etat_processus, ligne)) == NULL)
{	{
	pthread_mutex_unlock(&mutex_sigaction);
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 220 sequenceur(struct_processus *s_etat_proc	Line 230 sequenceur(struct_processus *s_etat_proc

if (sigaction(SIGINT, &action_defaut, NULL) != 0)	if (sigaction(SIGINT, &action_defaut, NULL) != 0)
{	{
	pthread_mutex_unlock(&mutex_sigaction);
(*s_etat_processus).erreur_systeme = d_es_signal;	(*s_etat_processus).erreur_systeme = d_es_signal;
return(d_erreur);	return(d_erreur);
}	}

if (sigaction(SIGTSTP, &action_defaut2, NULL) != 0)	if (sigaction(SIGTSTP, &action_defaut2, NULL) != 0)
{	{
	pthread_mutex_unlock(&mutex_sigaction);
(*s_etat_processus).erreur_systeme = d_es_signal;	(*s_etat_processus).erreur_systeme = d_es_signal;
return(d_erreur);	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 == NULL)
{	{
if ((ligne = (unsigned char ) malloc(6	if ((ligne = (unsigned char ) malloc(6
Line 541 sequenceur(struct_processus *s_etat_proc	Line 559 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 585 sequenceur(struct_processus *s_etat_proc	Line 605 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] Évaluation 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(), (*s_etat_processus)	(int) getpid(), (*s_etat_processus)
.instruction_courante,	.instruction_courante,
(((*s_etat_processus)	(((*s_etat_processus)
.pointeur_variable_courante).objet)	.pointeur_variable_partagee_courante)
.type);	.objet).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_etat_processus)
.pointeur_variable_courante).objet)	.pointeur_variable_partagee_courante)
.type);	.objet).type);
}	}

fflush(stdout);
}

if (recherche_variable_partagee(s_etat_processus,	fflush(stdout);
((s_etat_processus)	}
.pointeur_variable_courante).nom,
((s_etat_processus)
.pointeur_variable_courante).variable_partagee,
'P') != NULL)
{
// 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)
Line 653 sequenceur(struct_processus *s_etat_proc	Line 673 sequenceur(struct_processus *s_etat_proc
else	else
{	{
// La variable n'existe plus.	// 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);
	}
}	}
}	}

Line 718 sequenceur(struct_processus *s_etat_proc	Line 760 sequenceur(struct_processus *s_etat_proc
}	}
}	}

	(*s_etat_processus).debug_programme = d_faux;

((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.adresse_retour = (*s_etat_processus)	.adresse_retour = (*s_etat_processus)
.position_courante;	.position_courante;
Line 806 sequenceur(struct_processus *s_etat_proc	Line 850 sequenceur(struct_processus *s_etat_proc
{	{
if ((*s_etat_processus).l_base_pile == NULL)	if ((*s_etat_processus).l_base_pile == NULL)
{	{
if ((*s_etat_processus).erreur_execution !=	if (((*s_etat_processus).erreur_execution !=
d_ex_nom_implicite)	d_ex_nom_implicite) &&
	((*s_etat_processus).erreur_execution !=
	d_ex_syntaxe))
{	{
(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_manque_argument;	d_ex_manque_argument;
Line 909 sequenceur(struct_processus *s_etat_proc	Line 955 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(
Line 1500 sequenceur(struct_processus *s_etat_proc	Line 1547 sequenceur(struct_processus *s_etat_proc
if ((*s_etat_processus).var_volatile_processus_pere == 0)	if ((*s_etat_processus).var_volatile_processus_pere == 0)
{	{
envoi_signal_processus((*s_etat_processus).pid_processus_pere,	envoi_signal_processus((*s_etat_processus).pid_processus_pere,
rpl_sigalrm);	rpl_sigalrm, d_faux);
}	}
else	else
{	{

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.85
changed lines
	Added in v.1.112