rpl/src/instructions_v1.c - diff

Return to instructions_v1.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_v1.c between versions 1.19 and 1.34

version 1.19, 2011/06/10 11:35:13	version 1.34, 2011/10/10 10:58:12
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.0.prerelease.0	RPL/2 (R) version 4.1.4
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2011 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.
Line 237 instruction_version(struct_processus *s_	Line 237 instruction_version(struct_processus *s_
struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;

unsigned char texte[] = "RPL/2 version ";	unsigned char texte[] = "RPL/2 version ";
	unsigned char tampon[256 + 1];

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

Line 499 instruction_version(struct_processus *s_	Line 500 instruction_version(struct_processus *s_
return;	return;
}	}

if ((((l_element_courant).donnee).objet = malloc((strlen(d_date_en_rpl)	if ((((l_element_courant).donnee).objet = date_compilation()) == NULL)
+ 1) * sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

strcpy((unsigned char ) ((*l_element_courant).donnee).objet,
d_date_en_rpl);

/*	/*
* Ajout des options de compilation	* Ajout des options de compilation
*/	*/
Line 830 instruction_version(struct_processus *s_	Line 827 instruction_version(struct_processus *s_
return;	return;
}	}

#ifdef DEBUG	#ifdef RPLCAS
if ((((l_element_courant).donnee).objet = malloc(6 *	if ((((l_element_courant).donnee).objet = malloc(8 *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 839 instruction_version(struct_processus *s_	Line 836 instruction_version(struct_processus *s_
}	}

strcpy((unsigned char ) ((*l_element_courant).donnee).objet,	strcpy((unsigned char ) ((*l_element_courant).donnee).objet,
"DEBUG");	"RPL/CAS");
#else	#else
if ((((l_element_courant).donnee).objet = malloc(15 *	if ((((l_element_courant).donnee).objet = malloc(17 *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 849 instruction_version(struct_processus *s_	Line 846 instruction_version(struct_processus *s_
}	}

strcpy((unsigned char ) ((*l_element_courant).donnee).objet,	strcpy((unsigned char ) ((*l_element_courant).donnee).objet,
"DEBUG DISABLED");	"RPL/CAS DISABLED");
#endif	#endif

if (((*l_element_courant).suivant =	if (((*l_element_courant).suivant =
Line 891 instruction_version(struct_processus *s_	Line 888 instruction_version(struct_processus *s_
"EXPERIMENTAL CODE DISABLED");	"EXPERIMENTAL CODE DISABLED");
#endif	#endif

	if (((*l_element_courant).suivant =
	allocation_maillon(s_etat_processus)) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
	== NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	sprintf(tampon, "%zu BITS ABI", sizeof(void ) 8);

	if ((((l_element_courant).donnee).objet = malloc((strlen(tampon) + 1 )
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	strcpy((unsigned char ) ((*l_element_courant).donnee).objet, tampon);

	if (((*l_element_courant).suivant =
	allocation_maillon(s_etat_processus)) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).suivant = NULL;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
	== NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	if ((((l_element_courant).donnee).objet = conversion_majuscule(HOST))
	== NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

/*	/*
* Empilement du résultat	* Empilement du résultat
*/	*/
Line 920 instruction_version(struct_processus *s_	Line 969 instruction_version(struct_processus *s_
void	void
instruction_vars(struct_processus *s_etat_processus)	instruction_vars(struct_processus *s_etat_processus)
{	{
	int i;
	int nb_variables;

logical1 variable_partagee;	logical1 variable_partagee;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
Line 927 instruction_vars(struct_processus *s_eta	Line 979 instruction_vars(struct_processus *s_eta

struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;

unsigned long i;	struct_tableau_variables *tableau;

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

Line 971 instruction_vars(struct_processus *s_eta	Line 1023 instruction_vars(struct_processus *s_eta
(*s_objet_resultat).objet = NULL;	(*s_objet_resultat).objet = NULL;
l_element_precedent = NULL;	l_element_precedent = NULL;

#if 0	nb_variables = nombre_variables(s_etat_processus,
for(i = 0; i < (*s_etat_processus).nombre_variables; i++)	(*s_etat_processus).s_arbre_variables);

	if ((tableau = malloc(nb_variables * sizeof(struct_tableau_variables)))
	== NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	liste_variables(s_etat_processus, tableau, 0,
	(*s_etat_processus).s_arbre_variables);

	for(i = 0; i < nb_variables; i++)
{	{
if (l_element_precedent == NULL)	if (l_element_precedent == NULL)
{	{
Line 1022 instruction_vars(struct_processus *s_eta	Line 1086 instruction_vars(struct_processus *s_eta
* Mise en place d'un verrou si la variable est partagée.	* Mise en place d'un verrou si la variable est partagée.
*/	*/

if ((*s_etat_processus).s_liste_variables[i].objet == NULL)	if (tableau[i].objet == NULL)
{	{
if (pthread_mutex_lock(&(((s_etat_processus)	if (pthread_mutex_lock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.s_liste_variables_partagees).mutex)) != 0)
Line 1032 instruction_vars(struct_processus *s_eta	Line 1096 instruction_vars(struct_processus *s_eta
}	}

if (recherche_variable_partagee(s_etat_processus,	if (recherche_variable_partagee(s_etat_processus,
((*s_etat_processus).s_liste_variables[i]).nom,	tableau[i].nom, tableau[i].variable_partagee,
((*s_etat_processus).s_liste_variables[i])	tableau[i].origine) == d_faux)
.variable_partagee, ((*s_etat_processus)
.s_liste_variables[i]).origine) == d_faux)
{	{
// La variable partagée n'existe plus.	// La variable partagée n'existe plus.

Line 1084 instruction_vars(struct_processus *s_eta	Line 1146 instruction_vars(struct_processus *s_eta

if (((((struct_nom ) ((((struct_liste_chainee ) (((struct_objet *)	if (((((struct_nom ) ((((struct_liste_chainee ) (((struct_objet *)
(*l_element_courant).donnee)).objet)).donnee).objet)).nom =	(*l_element_courant).donnee)).objet)).donnee).objet)).nom =
malloc((strlen((*s_etat_processus).s_liste_variables[i].nom)	malloc((strlen(tableau[i].nom)
+ 1) * sizeof(unsigned char))) == NULL)	+ 1) * sizeof(unsigned char))) == NULL)
{	{
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
Line 1103 instruction_vars(struct_processus *s_eta	Line 1165 instruction_vars(struct_processus *s_eta

strcpy((((struct_nom ) ((((struct_liste_chainee *)	strcpy((((struct_nom ) ((((struct_liste_chainee *)
(((struct_objet ) (*l_element_courant).donnee)).objet))	(((struct_objet ) (*l_element_courant).donnee)).objet))
.donnee).objet)).nom, (*s_etat_processus)	.donnee).objet)).nom, tableau[i].nom);
.s_liste_variables[i].nom);

/*	/*
* Préparation du niveau	* Préparation du niveau
Line 1148 instruction_vars(struct_processus *s_eta	Line 1209 instruction_vars(struct_processus *s_eta

(((integer8 ) (((((struct_liste_chainee ) (((struct_objet )	(((integer8 ) (((((struct_liste_chainee ) (((struct_objet )
(*l_element_courant).donnee)).objet)).suivant).donnee).objet)) =	(*l_element_courant).donnee)).objet)).suivant).donnee).objet)) =
(integer8) (*s_etat_processus).s_liste_variables[i].niveau;	(integer8) tableau[i].niveau;

/*	/*
* Préparation du contenu de la variable	* Préparation du contenu de la variable
Line 1172 instruction_vars(struct_processus *s_eta	Line 1233 instruction_vars(struct_processus *s_eta
return;	return;
}	}

if ((*s_etat_processus).s_liste_variables[i].objet == NULL)	if (tableau[i].objet == NULL)
{	{
// Variable partagée	// Variable partagée

Line 1208 instruction_vars(struct_processus *s_eta	Line 1269 instruction_vars(struct_processus *s_eta

if (((((((struct_liste_chainee ) (((struct_objet )	if (((((((struct_liste_chainee ) (((struct_objet )
(*l_element_courant).donnee)).objet)).suivant).suivant)	(*l_element_courant).donnee)).objet)).suivant).suivant)
.donnee = copie_objet(s_etat_processus, (*s_etat_processus)	.donnee = copie_objet(s_etat_processus, tableau[i].objet,
.s_liste_variables[i].objet, 'P')) == NULL)	'P')) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1236 instruction_vars(struct_processus *s_eta	Line 1297 instruction_vars(struct_processus *s_eta
return;	return;
}	}

if (((*s_etat_processus).s_liste_variables[i].origine == 'P')	if ((tableau[i].origine == 'P')
? ((*s_etat_processus).s_liste_variables[i]	? (tableau[i].variable_statique.adresse != 0)
.variable_statique.adresse != 0)	: (tableau[i].variable_statique.pointeur != NULL))
: ((*s_etat_processus).s_liste_variables[i]
.variable_statique.pointeur != NULL))
{	{
if (((((((((struct_liste_chainee ) (((struct_objet )	if (((((((((struct_liste_chainee ) (((struct_objet )
(*l_element_courant).donnee)).objet)).suivant).suivant)	(*l_element_courant).donnee)).objet)).suivant).suivant)
Line 1293 instruction_vars(struct_processus *s_eta	Line 1352 instruction_vars(struct_processus *s_eta
return;	return;
}	}

if ((*s_etat_processus).s_liste_variables[i].variable_verrouillee	if (tableau[i].variable_verrouillee == d_vrai)
== d_vrai)
{	{
if ((((((((((struct_liste_chainee ) (((struct_objet *)	if ((((((((((struct_liste_chainee ) (((struct_objet *)
(*l_element_courant).donnee)).objet)).suivant).suivant)	(*l_element_courant).donnee)).objet)).suivant).suivant)
Line 1392 instruction_vars(struct_processus *s_eta	Line 1450 instruction_vars(struct_processus *s_eta

l_element_precedent = l_element_courant;	l_element_precedent = l_element_courant;
}	}
#endif
	free(tableau);

if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
s_objet_resultat) == d_erreur)	s_objet_resultat) == d_erreur)

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.19
changed lines
	Added in v.1.34