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.4 and 1.51

version 1.4, 2010/02/05 19:02:56	version 1.51, 2012/03/01 10:14:09
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.10	RPL/2 (R) version 4.1.7
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2012 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"


/*	/*
Line 63 sequenceur(struct_processus *s_etat_proc	Line 63 sequenceur(struct_processus *s_etat_proc
unsigned char tampon_retour;	unsigned char tampon_retour;
unsigned char *t_ligne;	unsigned char *t_ligne;

unsigned long i;
unsigned long j;
unsigned long niveau;	unsigned long niveau;
unsigned long position_courante;	unsigned long position_courante;

	Keymap ancien_keymap;
	Keymap nouveau_keymap;

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

if ((*s_etat_processus).debug == d_vrai)	if ((*s_etat_processus).debug == d_vrai)
Line 109 sequenceur(struct_processus *s_etat_proc	Line 110 sequenceur(struct_processus *s_etat_proc
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

i = 0;
j = 0;

do	do
{	{
drapeau_appel_definition = d_faux;	drapeau_appel_definition = d_faux;
Line 182 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);

Line 199 sequenceur(struct_processus *s_etat_proc	Line 209 sequenceur(struct_processus *s_etat_proc
(*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);
}	}

Line 283 sequenceur(struct_processus *s_etat_proc	Line 294 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;

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 302 sequenceur(struct_processus *s_etat_proc	Line 316 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 361 sequenceur(struct_processus *s_etat_proc	Line 376 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 384 sequenceur(struct_processus *s_etat_proc	Line 402 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 434 sequenceur(struct_processus *s_etat_proc	Line 454 sequenceur(struct_processus *s_etat_proc
((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.retour_definition = tampon_retour;	.retour_definition = tampon_retour;
}	}

(*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 451 sequenceur(struct_processus *s_etat_proc	Line 469 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 546 sequenceur(struct_processus *s_etat_proc	Line 565 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 565 sequenceur(struct_processus *s_etat_proc	Line 583 sequenceur(struct_processus *s_etat_proc
{	{
printf("[%d] Empilement de la variable "	printf("[%d] Empilement 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_courante).objet)
.position_variable_courante]).objet)
.type);	.type);
}	}
else	else
Line 579 sequenceur(struct_processus *s_etat_proc	Line 595 sequenceur(struct_processus *s_etat_proc
"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_courante).objet)
.position_variable_courante]).objet)
.type);	.type);
}	}

Line 597 sequenceur(struct_processus *s_etat_proc	Line 612 sequenceur(struct_processus *s_etat_proc
}	}

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

Line 663 sequenceur(struct_processus *s_etat_proc	Line 676 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 733 sequenceur(struct_processus *s_etat_proc	Line 745 sequenceur(struct_processus *s_etat_proc

(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
(((unsigned long )	(((unsigned long )
((((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 754 sequenceur(struct_processus *s_etat_proc	Line 765 sequenceur(struct_processus *s_etat_proc
(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 765 sequenceur(struct_processus *s_etat_proc	Line 775 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 775 sequenceur(struct_processus *s_etat_proc	Line 784 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 807 sequenceur(struct_processus *s_etat_proc	Line 815 sequenceur(struct_processus *s_etat_proc
(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
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_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	// Le séquenceur est appelé depuis la routine d'évaluation

if ((*s_etat_processus).evaluation_forcee == 'Y')	if ((*s_etat_processus).evaluation_forcee == 'Y')
Line 815 sequenceur(struct_processus *s_etat_proc	Line 859 sequenceur(struct_processus *s_etat_proc
&((*s_etat_processus).l_base_pile),	&((*s_etat_processus).l_base_pile),
&s_objet_evaluation) == d_erreur)	&s_objet_evaluation) == d_erreur)
{	{
	free((*s_etat_processus).instruction_courante);
(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_manque_argument;	d_ex_manque_argument;
return(d_erreur);	return(d_erreur);
Line 823 sequenceur(struct_processus *s_etat_proc	Line 868 sequenceur(struct_processus *s_etat_proc
if (evaluation(s_etat_processus, s_objet_evaluation,	if (evaluation(s_etat_processus, s_objet_evaluation,
'N') == d_erreur)	'N') == d_erreur)
{	{
	free((*s_etat_processus).instruction_courante);
liberation(s_etat_processus, s_objet_evaluation);	liberation(s_etat_processus, s_objet_evaluation);
return(d_erreur);	return(d_erreur);
}	}

liberation(s_etat_processus, s_objet_evaluation);	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 853 sequenceur(struct_processus *s_etat_proc	Line 911 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 948 sequenceur(struct_processus *s_etat_proc	Line 994 sequenceur(struct_processus *s_etat_proc

fflush(stdout);	fflush(stdout);

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

Line 1029 sequenceur(struct_processus *s_etat_proc	Line 1076 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 1115 sequenceur(struct_processus *s_etat_proc	Line 1163 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 1152 sequenceur(struct_processus *s_etat_proc	Line 1199 sequenceur(struct_processus *s_etat_proc

(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
(((unsigned long )	(((unsigned long )
((((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 1169 sequenceur(struct_processus *s_etat_proc	Line 1215 sequenceur(struct_processus *s_etat_proc

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

Line 1361 sequenceur(struct_processus *s_etat_proc	Line 1408 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);
}	}
else	else
{	{

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.4
changed lines
	Added in v.1.51