rpl/src/rpl.c - diff

Return to rpl.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/rpl.c between versions 1.100 and 1.119

version 1.100, 2011/11/28 21:42:04	version 1.119, 2012/10/04 15:21:26
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.5	RPL/2 (R) version 4.1.11
Copyright (C) 1989-2011 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 31	Line 31
*/	*/

int	int
rplinit(int argc, char argv[], unsigned char *resultats, char rpl_home)	rplinit(int argc, char argv[], char envp[],
	unsigned char **resultats, char rpl_home)
{	{
# include "copyright-conv.h"	# include "copyright-conv.h"
# include "licence-conv.h"	# include "licence-conv.h"

	char **arg_exec;

# ifdef HAVE_STACK_OVERFLOW_RECOVERY	# ifdef HAVE_STACK_OVERFLOW_RECOVERY
char pile_signaux[SIGSTKSZ];	char pile_signaux[SIGSTKSZ];
# endif	# endif

	# define RPL_PATH_MAX 1024
	char repertoire_initial[RPL_PATH_MAX];

file *f_source;	file *f_source;

int erreur_historique;	int erreur_historique;
Line 176 rplinit(int argc, char *argv[], unsigned	Line 182 rplinit(int argc, char *argv[], unsigned
(*s_etat_processus).langue = 'E';	(*s_etat_processus).langue = 'E';
}	}

	if (getcwd(repertoire_initial, RPL_PATH_MAX) == NULL)
	{
	if ((langue = getenv("LANG")) != NULL)
	{
	if (strncmp(langue, "fr", 2) == 0)
	{
	uprintf("+++Système : Mémoire insuffisante\n");
	}
	else
	{
	uprintf("+++System : Not enough memory\n");
	}
	}
	else
	{
	uprintf("+++System : Not enough memory\n");
	}

	return(EXIT_FAILURE);
	}

	if ((arg_exec = malloc((argc + 1) * sizeof(char *))) == NULL)
	{
	if ((langue = getenv("LANG")) != NULL)
	{
	if (strncmp(langue, "fr", 2) == 0)
	{
	uprintf("+++Système : Mémoire insuffisante\n");
	}
	else
	{
	uprintf("+++System : Not enough memory\n");
	}
	}
	else
	{
	uprintf("+++System : Not enough memory\n");
	}

	return(EXIT_FAILURE);
	}

	for(i = 0; i < (unsigned long) argc; i++)
	{
	arg_exec[i] = argv[i];
	}

	argv[argc] = NULL;

initialisation_contexte_cas(s_etat_processus);	initialisation_contexte_cas(s_etat_processus);

(*s_etat_processus).exception = d_ep;	(*s_etat_processus).exception = d_ep;
(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

	(*s_etat_processus).requete_redemarrage = d_faux;
(*s_etat_processus).rpl_home = rpl_home;	(*s_etat_processus).rpl_home = rpl_home;

pthread_mutexattr_init(&attributs_mutex);	pthread_mutexattr_init(&attributs_mutex);
Line 195 rplinit(int argc, char *argv[], unsigned	Line 251 rplinit(int argc, char *argv[], unsigned
&attributs_mutex);	&attributs_mutex);
pthread_mutexattr_destroy(&attributs_mutex);	pthread_mutexattr_destroy(&attributs_mutex);

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&mutex_sections_critiques, &attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);	sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
# else	# else
Line 289 rplinit(int argc, char *argv[], unsigned	Line 350 rplinit(int argc, char *argv[], unsigned

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
printf("+++Copyright (C) 1989 à 2010, 2011 BERTRAND Joël\n");	printf("+++Copyright (C) 1989 à 2011, 2012 BERTRAND Joël\n");
}	}
else	else
{	{
printf("+++Copyright (C) 1989 to 2010, 2011 BERTRAND Joel\n");	printf("+++Copyright (C) 1989 to 2011, 2012 BERTRAND Joel\n");
}	}

if (getenv("HOME") != NULL)	if (getenv("HOME") != NULL)
Line 373 rplinit(int argc, char *argv[], unsigned	Line 434 rplinit(int argc, char *argv[], unsigned
signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGINT);	kill(getpid(), SIGINT);

	attente.tv_sec = 0;
	attente.tv_nsec = 1000000;

	for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
	{
	nanosleep(&attente, NULL);
	}

if (signal_test != SIGINT)	if (signal_test != SIGINT)
{	{
erreur = d_es_signal;	erreur = d_es_signal;
Line 410 rplinit(int argc, char *argv[], unsigned	Line 479 rplinit(int argc, char *argv[], unsigned
signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGTERM);	kill(getpid(), SIGTERM);

	attente.tv_sec = 0;
	attente.tv_nsec = 1000000;

	for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
	{
	nanosleep(&attente, NULL);
	}

if (signal_test != SIGTERM)	if (signal_test != SIGTERM)
{	{
erreur = d_es_signal;	erreur = d_es_signal;
Line 427 rplinit(int argc, char *argv[], unsigned	Line 504 rplinit(int argc, char *argv[], unsigned
return(EXIT_FAILURE);	return(EXIT_FAILURE);
}	}

	if (sigaction(SIGALRM, &action, NULL) != 0)
	{
	erreur = d_es_signal;

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Système : Initialisation des signaux POSIX "
	"impossible\n");
	}
	else
	{
	printf("+++System : Initialization of POSIX signals failed\n");
	}

	return(EXIT_FAILURE);
	}

	signal_test = SIGTEST;
	kill(getpid(), SIGALRM);

	attente.tv_sec = 0;
	attente.tv_nsec = 1000000;

	for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
	{
	nanosleep(&attente, NULL);
	}

	if (signal_test != SIGALRM)
	{
	erreur = d_es_signal;

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Système : Initialisation des signaux POSIX "
	"impossible\n");
	}
	else
	{
	printf("+++System : Initialization of POSIX signals failed\n");
	}

	return(EXIT_FAILURE);
	}

action.sa_handler = interruption2;	action.sa_handler = interruption2;
action.sa_flags = 0;	action.sa_flags = 0;

Line 448 rplinit(int argc, char *argv[], unsigned	Line 570 rplinit(int argc, char *argv[], unsigned
signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGTSTP);	kill(getpid(), SIGTSTP);

	attente.tv_sec = 0;
	attente.tv_nsec = 1000000;

	for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
	{
	nanosleep(&attente, NULL);
	}

if (signal_test != SIGTSTP)	if (signal_test != SIGTSTP)
{	{
erreur = d_es_signal;	erreur = d_es_signal;
Line 488 rplinit(int argc, char *argv[], unsigned	Line 618 rplinit(int argc, char *argv[], unsigned
signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGPIPE);	kill(getpid(), SIGPIPE);

	attente.tv_sec = 0;
	attente.tv_nsec = 1000000;

	for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
	{
	nanosleep(&attente, NULL);
	}

if (signal_test != SIGPIPE)	if (signal_test != SIGPIPE)
{	{
erreur = d_es_signal;	erreur = d_es_signal;
Line 528 rplinit(int argc, char *argv[], unsigned	Line 666 rplinit(int argc, char *argv[], unsigned
signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGUSR1);	kill(getpid(), SIGUSR1);

	attente.tv_sec = 0;
	attente.tv_nsec = 1000000;

	for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
	{
	nanosleep(&attente, NULL);
	}

if (signal_test != SIGUSR1)	if (signal_test != SIGUSR1)
{	{
erreur = d_es_signal;	erreur = d_es_signal;
Line 1497 rplinit(int argc, char *argv[], unsigned	Line 1643 rplinit(int argc, char *argv[], unsigned
signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGSEGV);	kill(getpid(), SIGSEGV);

	attente.tv_sec = 0;
	attente.tv_nsec = 1000000;

	for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
	{
	nanosleep(&attente, NULL);
	}

if (signal_test != SIGSEGV)	if (signal_test != SIGSEGV)
{	{
erreur = d_es_signal;	erreur = d_es_signal;
Line 1516 rplinit(int argc, char *argv[], unsigned	Line 1670 rplinit(int argc, char *argv[], unsigned
}	}
# endif	# endif

	action.sa_handler = interruption3;
	action.sa_flags = 0;

if (sigaction(SIGBUS, &action, NULL) != 0)	if (sigaction(SIGBUS, &action, NULL) != 0)
{	{
if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
Line 1535 rplinit(int argc, char *argv[], unsigned	Line 1692 rplinit(int argc, char *argv[], unsigned
signal_test = SIGTEST;	signal_test = SIGTEST;
kill(getpid(), SIGBUS);	kill(getpid(), SIGBUS);

	attente.tv_sec = 0;
	attente.tv_nsec = 1000000;

	for(i = 0; (i < 1000) && (signal_test == SIGTEST); i++)
	{
	nanosleep(&attente, NULL);
	}

if (signal_test != SIGBUS)	if (signal_test != SIGBUS)
{	{
erreur = d_es_signal;	erreur = d_es_signal;
Line 1768 rplinit(int argc, char *argv[], unsigned	Line 1933 rplinit(int argc, char *argv[], unsigned
gettimeofday(&((*s_etat_processus).horodatage_profilage), NULL);	gettimeofday(&((*s_etat_processus).horodatage_profilage), NULL);

(*s_etat_processus).liste_mutexes = NULL;	(*s_etat_processus).liste_mutexes = NULL;
	(*s_etat_processus).sections_critiques = 0;

(*s_etat_processus).test_instruction = 'N';	(*s_etat_processus).test_instruction = 'N';
(*s_etat_processus).nombre_arguments = 0;	(*s_etat_processus).nombre_arguments = 0;
Line 1803 rplinit(int argc, char *argv[], unsigned	Line 1969 rplinit(int argc, char *argv[], unsigned
(*s_etat_processus).l_liste_variables_par_niveau = NULL;	(*s_etat_processus).l_liste_variables_par_niveau = NULL;
(*s_etat_processus).gel_liste_variables = d_faux;	(*s_etat_processus).gel_liste_variables = d_faux;
(*s_etat_processus).pointeur_variable_courante = NULL;	(*s_etat_processus).pointeur_variable_courante = NULL;
(*s_etat_processus).s_liste_variables_statiques = NULL;	(*s_etat_processus).pointeur_variable_statique_courante = NULL;
(*s_etat_processus).nombre_variables_statiques = 0;	(*s_etat_processus).l_liste_variables_statiques = NULL;
(*s_etat_processus).nombre_variables_statiques_allouees = 0;
(*s_etat_processus).niveau_courant = 0;	(*s_etat_processus).niveau_courant = 0;
(*s_etat_processus).niveau_initial = 0;	(*s_etat_processus).niveau_initial = 0;
(*s_etat_processus).creation_variables_statiques = d_faux;	(*s_etat_processus).creation_variables_statiques = d_faux;
(*s_etat_processus).creation_variables_partagees = d_faux;	(*s_etat_processus).creation_variables_partagees = d_faux;
(*s_etat_processus).position_variable_statique_courante = 0;

(*s_etat_processus).s_bibliotheques = NULL;	(*s_etat_processus).s_bibliotheques = NULL;
(*s_etat_processus).s_instructions_externes = NULL;	(*s_etat_processus).s_instructions_externes = NULL;
Line 1939 rplinit(int argc, char *argv[], unsigned	Line 2103 rplinit(int argc, char *argv[], unsigned
(*s_etat_processus).arbre_instructions = NULL;	(*s_etat_processus).arbre_instructions = NULL;

(*s_etat_processus).tid_processus_pere = pthread_self();	(*s_etat_processus).tid_processus_pere = pthread_self();
	(*s_etat_processus).tid = pthread_self();
(*s_etat_processus).pid_processus_pere = getpid();	(*s_etat_processus).pid_processus_pere = getpid();
(*s_etat_processus).processus_detache = d_vrai;	(*s_etat_processus).processus_detache = d_vrai;
(*s_etat_processus).var_volatile_processus_pere = -1;	(*s_etat_processus).var_volatile_processus_pere = -1;
Line 2035 rplinit(int argc, char *argv[], unsigned	Line 2200 rplinit(int argc, char *argv[], unsigned
(((s_etat_processus).l_base_pile_systeme))	(((s_etat_processus).l_base_pile_systeme))
.retour_definition = 'Y';	.retour_definition = 'Y';

(s_etat_processus).indep = (struct_objet ) malloc(	(*s_etat_processus).indep = allocation(s_etat_processus, NON);
sizeof(struct_objet));	(*s_etat_processus).depend = allocation(s_etat_processus, NON);
(s_etat_processus).depend = (struct_objet ) malloc(
sizeof(struct_objet));
(*s_etat_processus).parametres_courbes_de_niveau =	(*s_etat_processus).parametres_courbes_de_niveau =
(struct_objet *) malloc(sizeof(struct_objet));	allocation(s_etat_processus, NON);

if (((*s_etat_processus).indep != NULL) &&	if (((*s_etat_processus).indep != NULL) &&
((*s_etat_processus).depend != NULL) &&	((*s_etat_processus).depend != NULL) &&
Line 2450 rplinit(int argc, char *argv[], unsigned	Line 2613 rplinit(int argc, char *argv[], unsigned
home, ds_fichier_historique);	home, ds_fichier_historique);

using_history();	using_history();

	// Pour pouvoir utiliser le keymap avant le premier
	// appel à readline().
	rl_initialize();

erreur_historique = read_history(	erreur_historique = read_history(
(*s_etat_processus).nom_fichier_historique);	(*s_etat_processus).nom_fichier_historique);

Line 2746 rplinit(int argc, char *argv[], unsigned	Line 2914 rplinit(int argc, char *argv[], unsigned
}	}
}	}

	for(i = 0; i < (*s_etat_processus).sections_critiques; i++)
	{
	pthread_mutex_unlock(&mutex_sections_critiques);
	}

liberation(s_etat_processus, (*s_etat_processus).at_exit);	liberation(s_etat_processus, (*s_etat_processus).at_exit);
liberation(s_etat_processus, (*s_etat_processus).at_poke);	liberation(s_etat_processus, (*s_etat_processus).at_poke);

Line 3172 rplinit(int argc, char *argv[], unsigned	Line 3345 rplinit(int argc, char *argv[], unsigned
(*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);

	#warning A FIXER
	/*
for(i = 0; i < (*s_etat_processus)	for(i = 0; i < (*s_etat_processus)
.nombre_variables_statiques; i++)	.nombre_variables_statiques; i++)
{	{
Line 3182 rplinit(int argc, char *argv[], unsigned	Line 3357 rplinit(int argc, char *argv[], unsigned
}	}

free((*s_etat_processus).s_liste_variables_statiques);	free((*s_etat_processus).s_liste_variables_statiques);
	*/

for(i = 0; i < (((s_etat_processus)	for(i = 0; i < (((s_etat_processus)
.s_liste_variables_partagees)).nombre_variables;	.s_liste_variables_partagees)).nombre_variables;
Line 3539 rplinit(int argc, char *argv[], unsigned	Line 3715 rplinit(int argc, char *argv[], unsigned

pthread_mutex_destroy(&((*s_etat_processus).mutex));	pthread_mutex_destroy(&((*s_etat_processus).mutex));
pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));	pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
	pthread_mutex_destroy(&mutex_sections_critiques);

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&((*s_etat_processus).semaphore_fork));	sem_post(&((*s_etat_processus).semaphore_fork));
Line 3551 rplinit(int argc, char *argv[], unsigned	Line 3728 rplinit(int argc, char *argv[], unsigned

free((*s_etat_processus).localisation);	free((*s_etat_processus).localisation);

pthread_mutex_destroy(&mutex_liste_threads);
pthread_mutex_destroy(&mutex_gestionnaires_signaux_atomique);

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_post(&semaphore_gestionnaires_signaux);	sem_post(&semaphore_gestionnaires_signaux);
sem_destroy(&semaphore_gestionnaires_signaux);	sem_destroy(&semaphore_gestionnaires_signaux);
Line 3566 rplinit(int argc, char *argv[], unsigned	Line 3740 rplinit(int argc, char *argv[], unsigned
liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);

free((*s_etat_processus).chemin_fichiers_temporaires);	free((*s_etat_processus).chemin_fichiers_temporaires);

	if ((*s_etat_processus).requete_redemarrage == d_vrai)
	{
	chdir(repertoire_initial);
	execvp(arg_exec[0], &(arg_exec[0]));
	erreur = d_erreur;
	}

	free(arg_exec);
free(s_etat_processus);	free(s_etat_processus);

# ifdef DEBUG_MEMOIRE	# ifdef DEBUG_MEMOIRE

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.100
changed lines
	Added in v.1.119