rpl/src/instructions_d5.c - diff

Return to instructions_d5.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_d5.c between versions 1.91 and 1.105

version 1.91, 2012/09/15 12:57:09	version 1.105, 2013/03/26 09:04:32
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.10	RPL/2 (R) version 4.1.13
Copyright (C) 1989-2012 Dr. BERTRAND Joël	Copyright (C) 1989-2013 Dr. BERTRAND Joël

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

Line 40 instruction_dft(struct_processus *s_etat	Line 40 instruction_dft(struct_processus *s_etat
{	{
integer4 erreur;	integer4 erreur;
integer4 inverse;	integer4 inverse;
	integer4 longueur_dft;
integer4 nombre_colonnes;	integer4 nombre_colonnes;
integer4 nombre_lignes;	integer4 nombre_lignes;

logical1 presence_longueur_dft;	logical1 presence_longueur_dft;

long longueur_dft_signee;	integer8 longueur_dft_signee;

struct_complexe16 *matrice_f77;	struct_complexe16 *matrice_f77;

Line 53 instruction_dft(struct_processus *s_etat	Line 54 instruction_dft(struct_processus *s_etat
struct_objet *s_objet_longueur_dft;	struct_objet *s_objet_longueur_dft;
struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;
unsigned long k;	integer8 k;
unsigned long longueur_dft;

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

Line 135 instruction_dft(struct_processus *s_etat	Line 135 instruction_dft(struct_processus *s_etat
return;	return;
}	}

longueur_dft = longueur_dft_signee;	longueur_dft = (integer4) longueur_dft_signee;
}	}
else	else
{	{
Line 170 instruction_dft(struct_processus *s_etat	Line 170 instruction_dft(struct_processus *s_etat
{	{
if (presence_longueur_dft == d_faux)	if (presence_longueur_dft == d_faux)
{	{
longueur_dft = (((struct_vecteur )	longueur_dft = (integer4) (((struct_vecteur )
(*s_objet_argument).objet)).taille;	(*s_objet_argument).objet)).taille;
}	}

if ((matrice_f77 = malloc(longueur_dft *	if ((matrice_f77 = malloc(((size_t) longueur_dft) *
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 260 instruction_dft(struct_processus *s_etat	Line 260 instruction_dft(struct_processus *s_etat
{	{
if (presence_longueur_dft == d_faux)	if (presence_longueur_dft == d_faux)
{	{
longueur_dft = (((struct_matrice )	longueur_dft = (integer4) (((struct_matrice )
(*s_objet_argument).objet)).nombre_colonnes;	(*s_objet_argument).objet)).nombre_colonnes;
}	}

if ((matrice_f77 = malloc(longueur_dft *	if ((matrice_f77 = malloc(((size_t) longueur_dft) * ((size_t)
(((struct_matrice ) (*s_objet_argument).objet))	(((struct_matrice ) (*s_objet_argument).objet))
.nombre_lignes * sizeof(struct_complexe16))) == NULL)	.nombre_lignes) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 342 instruction_dft(struct_processus *s_etat	Line 342 instruction_dft(struct_processus *s_etat
}	}
}	}

nombre_lignes = (((struct_matrice ) (*s_objet_argument).objet))	nombre_lignes = (integer4) (((struct_matrice ) (*s_objet_argument)
.nombre_lignes;	.objet)).nombre_lignes;
nombre_colonnes = longueur_dft;	nombre_colonnes = longueur_dft;
inverse = 0;	inverse = 0;

Line 371 instruction_dft(struct_processus *s_etat	Line 371 instruction_dft(struct_processus *s_etat
longueur_dft;	longueur_dft;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_matrice ) (*s_objet_resultat).objet))	malloc(((size_t) (((struct_matrice ) (*s_objet_resultat)
.nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet)).nombre_lignes) * sizeof(struct_complexe16 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 383 instruction_dft(struct_processus *s_etat	Line 383 instruction_dft(struct_processus *s_etat
{	{
if ((((struct_complexe16 *) (((struct_matrice *)	if ((((struct_complexe16 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i] =	(*s_objet_resultat).objet)).tableau)[i] =
malloc((((struct_matrice )	malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_colonnes	(s_objet_resultat).objet)).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 814 instruction_der(struct_processus *s_etat	Line 814 instruction_der(struct_processus *s_etat
void	void
instruction_detach(struct_processus *s_etat_processus)	instruction_detach(struct_processus *s_etat_processus)
{	{
int pipe_initialisation_segment_signaux[2];	int pipe_initialisation_segment_signaux[2];

logical1 drapeau;	logical1 drapeau;

pid_t ppid;	pid_t ppid;
pid_t pid_final;	pid_t pid_final;

pthread_attr_t attributs;	pthread_attr_t attributs;

pthread_mutexattr_t attributs_mutex;	pthread_mutexattr_t attributs_mutex;

pthread_t thread_surveillance;	pthread_t thread_surveillance;

sig_atomic_t registre_stop;	sig_atomic_t registre_stop;

ssize_t longueur_ecriture;	ssize_t longueur_ecriture;

struct_descripteur_thread *s_argument_thread;	struct_descripteur_thread *s_argument_thread;
struct_descripteur_thread *s_argument_thread2;	struct_descripteur_thread *s_argument_thread2;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_precedent;	struct_liste_chainee *l_element_precedent;
struct_liste_chainee *l_element_suivant;	struct_liste_chainee *l_element_suivant;

struct_objet *s_copie;	struct_liste_variables_partagees *l_element_partage_courant;
struct_objet *s_objet;	struct_liste_variables_partagees *l_element_partage_suivant;
struct_objet *s_objet_systeme;
struct_objet *s_objet_temporaire;

struct sigaction action;	struct_liste_variables_statiques *l_element_statique_courant;
struct sigaction registre;	struct_liste_variables_statiques *l_element_statique_suivant;

struct timespec attente;	struct_objet *s_copie;
	struct_objet *s_objet;
	struct_objet *s_objet_systeme;
	struct_objet *s_objet_temporaire;

unsigned char caractere;	struct sigaction action;
unsigned char *message;	struct sigaction registre;

unsigned int erreur;	struct timespec attente;

unsigned long i;	unsigned char caractere;
	unsigned char *message;

volatile logical1 variable_partagee;	unsigned int erreur;

	integer8 i;

	volatile logical1 variable_partagee;

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

Line 931 instruction_detach(struct_processus *s_e	Line 937 instruction_detach(struct_processus *s_e
if (((s_etat_processus).pointeur_variable_courante).objet	if (((s_etat_processus).pointeur_variable_courante).objet
== NULL)	== NULL)
{	{
if (pthread_mutex_lock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

if (recherche_variable_partagee(s_etat_processus,	if (recherche_variable_partagee(s_etat_processus,
((s_etat_processus).pointeur_variable_courante).nom,	((s_etat_processus).pointeur_variable_courante).nom,
((s_etat_processus).pointeur_variable_courante)	((s_etat_processus).pointeur_variable_courante)
.variable_partagee, ((s_etat_processus)	.variable_partagee, ((s_etat_processus)
.pointeur_variable_courante).origine) == d_faux)	.pointeur_variable_courante).origine) == NULL)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

liberation(s_etat_processus, s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
Line 959 instruction_detach(struct_processus *s_e	Line 951 instruction_detach(struct_processus *s_e
return;	return;
}	}

if (((((*s_etat_processus).s_liste_variables_partagees)	if (((((*s_etat_processus)
.table[((s_etat_processus)	.pointeur_variable_partagee_courante).objet).type
.s_liste_variables_partagees).position_variable].objet)	== RPN) && ((((*s_etat_processus)
.type != RPN) && ((((*s_etat_processus)	.pointeur_variable_partagee_courante).objet).type
.s_liste_variables_partagees).table	== ADR))
[((s_etat_processus).s_liste_variables_partagees)
.position_variable].objet).type != ADR))
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 982 instruction_detach(struct_processus *s_e	Line 972 instruction_detach(struct_processus *s_e
}	}

if ((s_copie = copie_objet(s_etat_processus,	if ((s_copie = copie_objet(s_etat_processus,
((s_etat_processus).s_liste_variables_partagees).table	((s_etat_processus)
[((s_etat_processus).s_liste_variables_partagees)	.pointeur_variable_partagee_courante).objet, 'P'))
.position_variable].objet, 'P')) == NULL)	== NULL)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1002 instruction_detach(struct_processus *s_e	Line 992 instruction_detach(struct_processus *s_e
variable_partagee = d_vrai;	variable_partagee = d_vrai;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1278 instruction_detach(struct_processus *s_e	Line 1268 instruction_detach(struct_processus *s_e
* Processus fils	* Processus fils
*/	*/

	if (lancement_thread_signaux(s_etat_processus) != d_absence_erreur)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	}

liberation_queue_signaux(s_etat_processus);	liberation_queue_signaux(s_etat_processus);
creation_queue_signaux(s_etat_processus);	creation_queue_signaux(s_etat_processus);
routine_recursive = 0;	routine_recursive = 0;
Line 1376 instruction_detach(struct_processus *s_e	Line 1371 instruction_detach(struct_processus *s_e
(*s_etat_processus).liste_mutexes = NULL;	(*s_etat_processus).liste_mutexes = NULL;

liberation_threads(s_etat_processus);	liberation_threads(s_etat_processus);

((s_etat_processus).s_liste_variables_partagees)
.table = NULL;
((s_etat_processus).s_liste_variables_partagees)
.nombre_variables = 0;
((s_etat_processus).s_liste_variables_partagees)
.nombre_variables_allouees = 0;

insertion_thread(s_etat_processus, d_vrai);	insertion_thread(s_etat_processus, d_vrai);

// Envoi d'une donnée pour signaler le démarrage du processus au thread	// Envoi d'une donnée pour signaler le démarrage du processus au thread
Line 2012 instruction_detach(struct_processus *s_e	Line 1999 instruction_detach(struct_processus *s_e
}	}
else	else
{	{
if (((*s_etat_processus).var_volatile_alarme == 0)	if (((*s_etat_processus).arret_depuis_abort == 0)
&& ((*s_etat_processus).arret_depuis_abort == 0)
&& ((*s_etat_processus).at_exit != NULL))	&& ((*s_etat_processus).at_exit != NULL))
{	{
(*s_etat_processus).var_volatile_requete_arret = 0;	(*s_etat_processus).var_volatile_requete_arret = 0;
	(*s_etat_processus).var_volatile_alarme = 0;

if (evaluation(s_etat_processus,	if (evaluation(s_etat_processus,
(*s_etat_processus).at_exit, 'E') ==	(*s_etat_processus).at_exit, 'E') ==
Line 2041 instruction_detach(struct_processus *s_e	Line 2028 instruction_detach(struct_processus *s_e
}	}
else	else
{	{
if (((*s_etat_processus).var_volatile_alarme == 0)	if (((*s_etat_processus).arret_depuis_abort == 0)
&& ((*s_etat_processus).arret_depuis_abort == 0)
&& ((*s_etat_processus).at_exit != NULL))	&& ((*s_etat_processus).at_exit != NULL))
{	{
(*s_etat_processus).var_volatile_requete_arret = 0;	(*s_etat_processus).var_volatile_requete_arret = 0;
	(*s_etat_processus).var_volatile_alarme = 0;

if (evaluation(s_etat_processus,	if (evaluation(s_etat_processus,
(*s_etat_processus).at_exit, 'E') ==	(*s_etat_processus).at_exit, 'E') ==
Line 2390 instruction_detach(struct_processus *s_e	Line 2377 instruction_detach(struct_processus *s_e
.var_volatile_traitement_retarde_stop;	.var_volatile_traitement_retarde_stop;
(*s_etat_processus).var_volatile_traitement_retarde_stop = 1;	(*s_etat_processus).var_volatile_traitement_retarde_stop = 1;

for(i = 0; i < (unsigned long) ((((struct_processus_fils *)	for(i = 0; i < ((((struct_processus_fils *)
((l_element_courant)	((l_element_courant)
.donnee).objet)).thread).nombre_objets_dans_pipe; i++)	.donnee).objet)).thread).nombre_objets_dans_pipe; i++)
{	{
Line 2580 instruction_detach(struct_processus *s_e	Line 2567 instruction_detach(struct_processus *s_e
(*s_etat_processus).arbre_instructions);	(*s_etat_processus).arbre_instructions);
free((*s_etat_processus).pointeurs_caracteres);	free((*s_etat_processus).pointeurs_caracteres);

	l_element_statique_courant = (*s_etat_processus)
	.l_liste_variables_statiques;

	while(l_element_statique_courant != NULL)
	{
	l_element_statique_suivant = (*l_element_statique_courant).suivant;
	free(l_element_statique_courant);
	l_element_statique_courant = l_element_statique_suivant;
	}

	l_element_partage_courant = ((s_etat_processus)
	.l_liste_variables_partagees);

	while(l_element_partage_courant != NULL)
	{
	l_element_partage_suivant = (*l_element_partage_courant).suivant;
	free(l_element_partage_courant);
	l_element_partage_courant = l_element_partage_suivant;
	}

if ((*s_etat_processus).entree_standard != NULL)	if ((*s_etat_processus).entree_standard != NULL)
{	{
pclose((*s_etat_processus).entree_standard);	pclose((*s_etat_processus).entree_standard);
Line 2604 instruction_detach(struct_processus *s_e	Line 2611 instruction_detach(struct_processus *s_e
(*s_etat_processus).instruction_derniere_erreur = NULL;	(*s_etat_processus).instruction_derniere_erreur = NULL;
}	}

	liberation_arbre_variables_partagees(s_etat_processus,
	((s_etat_processus).s_arbre_variables_partagees));
liberation_arbre_variables(s_etat_processus,	liberation_arbre_variables(s_etat_processus,
(*s_etat_processus).s_arbre_variables, d_vrai);	(*s_etat_processus).s_arbre_variables, d_vrai);
free((*s_etat_processus).pointeurs_caracteres_variables);	free((*s_etat_processus).pointeurs_caracteres_variables);

for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
{
liberation(s_etat_processus,
(*s_etat_processus).s_liste_variables_statiques[i].objet);
free((*s_etat_processus).s_liste_variables_statiques[i].nom);
}

free((*s_etat_processus).s_liste_variables_statiques);

for(i = 0; i < ((s_etat_processus).s_liste_variables_partagees)
.nombre_variables; i++)
{
liberation(s_etat_processus,
((s_etat_processus).s_liste_variables_partagees)
.table[i].objet);
free(((s_etat_processus).s_liste_variables_partagees)
.table[i].nom);
}

if (((s_etat_processus).s_liste_variables_partagees).table
!= NULL)
{
free((struct_variable_partagee *)
((s_etat_processus).s_liste_variables_partagees).table);
}

pthread_mutex_destroy(&(((s_etat_processus)
.s_liste_variables_partagees).mutex));

l_element_courant = (*s_etat_processus).l_base_pile;	l_element_courant = (*s_etat_processus).l_base_pile;
while(l_element_courant != NULL)	while(l_element_courant != NULL)
{	{
Line 2833 instruction_detach(struct_processus *s_e	Line 2813 instruction_detach(struct_processus *s_e

destruction_queue_signaux(s_etat_processus);	destruction_queue_signaux(s_etat_processus);
liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);
	arret_thread_signaux(s_etat_processus);
free(s_etat_processus);	free(s_etat_processus);

# ifdef DEBUG_MEMOIRE	# ifdef DEBUG_MEMOIRE

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.91
changed lines
	Added in v.1.105