rpl/src/bibliotheques_externes.c - diff

Return to bibliotheques_externes.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/bibliotheques_externes.c between versions 1.34 and 1.52

version 1.34, 2011/09/14 17:55:59	version 1.52, 2013/03/29 10:30:32
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.3	RPL/2 (R) version 4.1.13
Copyright (C) 1989-2011 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 41 void *	Line 41 void *
chargement_bibliotheque(struct_processus *s_etat_processus,	chargement_bibliotheque(struct_processus *s_etat_processus,
unsigned char *bibliotheque)	unsigned char *bibliotheque)
{	{
char *(fonction)(unsigned long , const char );	char *(fonction)(struct_rpl_arguments *,
	integer8 , const char );
char *message;	char *message;

long i;	integer8 i;
long nombre_symboles;	integer8 nombre_symboles;

struct_rpl_arguments rpl_arguments;	struct_rpl_arguments rpl_arguments;

Line 56 chargement_bibliotheque(struct_processus	Line 57 chargement_bibliotheque(struct_processus
unsigned char *tampon;	unsigned char *tampon;

void *descripteur_bibliotheque;	void *descripteur_bibliotheque;
void (onloading)(struct_rpl_arguments );	int (onloading)(struct_rpl_arguments );

/*	/*
* On vérifie que la bibliothèque n'est pas déjà chargée.	* On vérifie que la bibliothèque n'est pas déjà chargée.
Line 161 chargement_bibliotheque(struct_processus	Line 162 chargement_bibliotheque(struct_processus
}	}
}	}

if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0)	# ifndef SEMAPHORES_NOMMES
	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);	return(NULL);
Line 169 chargement_bibliotheque(struct_processus	Line 174 chargement_bibliotheque(struct_processus

(*onloading)(&rpl_arguments);	(*onloading)(&rpl_arguments);

if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0)	# ifndef SEMAPHORES_NOMMES
	while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	if (errno != EINTR)
return(NULL);	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return(NULL);
	}
}	}

if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
Line 324 chargement_bibliotheque(struct_processus	Line 336 chargement_bibliotheque(struct_processus
* Ajout des symboles externes	* Ajout des symboles externes
*/	*/

if ((tableau = (unsigned char *) (fonction)((&nombre_symboles),	if ((tableau = (unsigned char *) (fonction)(&rpl_arguments,
d_version_rpl)) == NULL)	(&nombre_symboles), d_version_rpl)) == NULL)
{	{
/*	/*
* Nombre symboles :	* Nombre symboles :
Line 351 chargement_bibliotheque(struct_processus	Line 363 chargement_bibliotheque(struct_processus
}	}

if (((*s_etat_processus).s_instructions_externes = realloc(	if (((*s_etat_processus).s_instructions_externes = realloc(
(*s_etat_processus).s_instructions_externes,	(*s_etat_processus).s_instructions_externes, ((size_t)
((*s_etat_processus).nombre_instructions_externes + nombre_symboles)	((*s_etat_processus).nombre_instructions_externes +
* sizeof(struct_instruction_externe))) == NULL)	nombre_symboles)) * sizeof(struct_instruction_externe))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 474 retrait_bibliotheque(struct_processus *s	Line 486 retrait_bibliotheque(struct_processus *s

unsigned char *tampon;	unsigned char *tampon;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;
unsigned long nombre_symboles_residuels;	integer8 nombre_symboles_residuels;

void (onclosing)(struct_rpl_arguments );	int (onclosing)(struct_rpl_arguments );

l_element_courant = (*s_etat_processus).s_bibliotheques;	l_element_courant = (*s_etat_processus).s_bibliotheques;
presence_bibliotheque = d_faux;	presence_bibliotheque = d_faux;
Line 569 retrait_bibliotheque(struct_processus *s	Line 581 retrait_bibliotheque(struct_processus *s
}	}
}	}

if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0)	# ifndef SEMAPHORES_NOMMES
	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(d_erreur);	return(d_erreur);
Line 577 retrait_bibliotheque(struct_processus *s	Line 593 retrait_bibliotheque(struct_processus *s

(*onclosing)(&rpl_arguments);	(*onclosing)(&rpl_arguments);

if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0)	# ifndef SEMAPHORES_NOMMES
	while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	if (errno != EINTR)
return(d_erreur);	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return(d_erreur);
	}
}	}

if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
Line 764 retrait_bibliotheque(struct_processus *s	Line 787 retrait_bibliotheque(struct_processus *s
registre = (*s_etat_processus).s_instructions_externes;	registre = (*s_etat_processus).s_instructions_externes;

if (((*s_etat_processus).s_instructions_externes =	if (((*s_etat_processus).s_instructions_externes =
malloc(nombre_symboles_residuels *	malloc(((size_t) nombre_symboles_residuels) *
sizeof(struct_instruction_externe))) == NULL)	sizeof(struct_instruction_externe))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 830 execution_fonction_de_bibliotheque(struc	Line 853 execution_fonction_de_bibliotheque(struc
logical1 presence_bibliotheque;	logical1 presence_bibliotheque;
logical1 unicite_symbole;	logical1 unicite_symbole;

long difference;	int difference;
long difference_inferieure;	int difference_inferieure;
long difference_superieure;	int difference_superieure;
long i;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;

Line 842 execution_fonction_de_bibliotheque(struc	Line 864 execution_fonction_de_bibliotheque(struc
unsigned char *nom_fonction_externe;	unsigned char *nom_fonction_externe;
unsigned char *tampon;	unsigned char *tampon;

unsigned long borne_inferieure;	integer8 borne_inferieure;
unsigned long borne_superieure;	integer8 borne_superieure;
unsigned long moyenne;	integer8 i;
unsigned long nombre_iterations_maximal;	integer8 moyenne;
unsigned long ordre_iteration;	integer8 nombre_iterations_maximal;
	integer8 ordre_iteration;

void (fonction)(struct_rpl_arguments );	int (fonction)(struct_rpl_arguments );

/*	/*
* Recherche dichotomique de la définition externe	* Recherche dichotomique de la définition externe
Line 883 execution_fonction_de_bibliotheque(struc	Line 906 execution_fonction_de_bibliotheque(struc
}	}

ordre_iteration = 0;	ordre_iteration = 0;
nombre_iterations_maximal = ((unsigned long)	nombre_iterations_maximal = ((integer8)
(log((*s_etat_processus).nombre_instructions_externes) / log(2)))	(log((real8) (*s_etat_processus).nombre_instructions_externes) /
+ 2;	log(2))) + 2;

borne_inferieure = 0;	borne_inferieure = 0;
borne_superieure = (*s_etat_processus).nombre_instructions_externes - 1;	borne_superieure = (*s_etat_processus).nombre_instructions_externes - 1;
Line 895 execution_fonction_de_bibliotheque(struc	Line 918 execution_fonction_de_bibliotheque(struc
moyenne = (borne_inferieure + borne_superieure) / 2;	moyenne = (borne_inferieure + borne_superieure) / 2;
ordre_iteration++;	ordre_iteration++;

if ((2 * ((unsigned long) ((borne_inferieure + borne_superieure) / 2)))	if ((2 * ((integer8) ((borne_inferieure + borne_superieure) / 2)))
== (borne_inferieure + borne_superieure))	== (borne_inferieure + borne_superieure))
{	{
difference = strcmp(nom_fonction, (*s_etat_processus)	difference = strcmp(nom_fonction, (*s_etat_processus)
Line 982 execution_fonction_de_bibliotheque(struc	Line 1005 execution_fonction_de_bibliotheque(struc
{	{
i = moyenne;	i = moyenne;

while((unsigned long) i <	while(i < (*s_etat_processus).nombre_instructions_externes)
(*s_etat_processus).nombre_instructions_externes)
{	{
if (strcmp((*s_etat_processus).s_instructions_externes[i]	if (strcmp((*s_etat_processus).s_instructions_externes[i]
.nom, nom_fonction) != 0)	.nom, nom_fonction) != 0)
Line 1133 execution_fonction_de_bibliotheque(struc	Line 1155 execution_fonction_de_bibliotheque(struc
}	}
}	}

if (pthread_mutex_unlock(&((*s_etat_processus).mutex_fork)) != 0)	# ifndef SEMAPHORES_NOMMES
	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return(d_faux);	return(d_faux);
Line 1141 execution_fonction_de_bibliotheque(struc	Line 1167 execution_fonction_de_bibliotheque(struc

(*fonction)(&rpl_arguments);	(*fonction)(&rpl_arguments);

if (pthread_mutex_lock(&((*s_etat_processus).mutex_fork)) != 0)	# ifndef SEMAPHORES_NOMMES
	while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	if (errno != EINTR)
return(d_faux);	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return(d_faux);
	}
}	}

if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
Line 1443 depilement_pile_operationnelle(struct_rp	Line 1476 depilement_pile_operationnelle(struct_rp

struct_liste_chainee *	struct_liste_chainee *
sauvegarde_arguments(struct_rpl_arguments *s_rpl_arguments,	sauvegarde_arguments(struct_rpl_arguments *s_rpl_arguments,
unsigned long nombre_arguments)	integer8 nombre_arguments)
{	{
struct_liste_chainee *l_ancienne_base_liste;	struct_liste_chainee *l_ancienne_base_liste;
struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
Line 1461 sauvegarde_arguments(struct_rpl_argument	Line 1494 sauvegarde_arguments(struct_rpl_argument
unsigned char indice_drapeau;	unsigned char indice_drapeau;
unsigned char taille_bloc;	unsigned char taille_bloc;

unsigned long i;	integer8 i;

struct_processus *s_etat_processus;	struct_processus *s_etat_processus;

Line 1474 sauvegarde_arguments(struct_rpl_argument	Line 1507 sauvegarde_arguments(struct_rpl_argument
indice_bloc = indice_drapeau / taille_bloc;	indice_bloc = indice_drapeau / taille_bloc;
indice_bit = indice_drapeau % taille_bloc;	indice_bit = indice_drapeau % taille_bloc;

masque = ((t_8_bits) 1) << (taille_bloc - indice_bit - 1);	masque = (t_8_bits) ((1 << (taille_bloc - indice_bit - 1)) & 0xFF);

if (((*s_rpl_arguments).drapeaux_etat[indice_bloc] & masque) == 0)	if (((*s_rpl_arguments).drapeaux_etat[indice_bloc] & masque) == 0)
{	{
Line 1572 tri_base_symboles_externes(struct_proces	Line 1605 tri_base_symboles_externes(struct_proces
logical1 terminaison_boucle_2;	logical1 terminaison_boucle_2;
logical1 terminaison_boucle_3;	logical1 terminaison_boucle_3;

signed long indice_i;	integer8 borne_inferieure;
signed long indice_j;	integer8 borne_superieure;
signed long indice_k;	integer8 ecartement;
signed long indice_l;	integer8 indice;
	integer8 indice_i;
unsigned long borne_inferieure;	integer8 indice_j;
unsigned long borne_superieure;	integer8 indice_k;
unsigned long ecartement;	integer8 indice_l;
unsigned long indice;

ecartement = (*s_etat_processus).nombre_instructions_externes;	ecartement = (*s_etat_processus).nombre_instructions_externes;

Line 1659 tri_base_symboles_externes(struct_proces	Line 1691 tri_base_symboles_externes(struct_proces
{	{
indice_j = indice_i;	indice_j = indice_i;

while(((unsigned long) (indice_i + 1) < (*s_etat_processus)	while(((indice_i + 1) < (*s_etat_processus)
.nombre_instructions_externes) && (strcmp(((*s_etat_processus)	.nombre_instructions_externes) && (strcmp(((*s_etat_processus)
.s_instructions_externes[indice_i]).nom, ((*s_etat_processus)	.s_instructions_externes[indice_i]).nom, ((*s_etat_processus)
.s_instructions_externes[indice_i + 1]).nom) == 0))	.s_instructions_externes[indice_i + 1]).nom) == 0))
Line 1693 tri_base_symboles_externes(struct_proces	Line 1725 tri_base_symboles_externes(struct_proces
} while(terminaison_boucle == d_faux);	} while(terminaison_boucle == d_faux);

indice_i++;	indice_i++;
} while((unsigned long) (indice_i + 1) <	} while((indice_i + 1) < (*s_etat_processus).nombre_instructions_externes);
(*s_etat_processus).nombre_instructions_externes);

return;	return;
}	}

CVSweb interface <joel.bertrand@systella.fr>

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