rpl/src/analyse.c - diff

Return to analyse.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/analyse.c between versions 1.61 and 1.96

CVSweb interface <joel.bertrand@systella.fr>

version 1.61, 2011/10/14 08:13:05	version 1.96, 2014/10/05 19:53:16
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.4	RPL/2 (R) version 4.1.19
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2014 Dr. BERTRAND Joël

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

Line 61 creation_instruction(struct_processus *s	Line 61 creation_instruction(struct_processus *s
((s_etat_processus).arbre_instructions).feuille = NULL;	((s_etat_processus).arbre_instructions).feuille = NULL;

if ((((s_etat_processus).arbre_instructions).noeuds =	if ((((s_etat_processus).arbre_instructions).noeuds =
malloc((*s_etat_processus).nombre_caracteres	malloc(((size_t) (*s_etat_processus).nombre_caracteres)
* sizeof(struct_instruction))) == NULL)	* sizeof(struct_instruction))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 101 creation_instruction(struct_processus *s	Line 101 creation_instruction(struct_processus *s

if ((((l_instruction_courante).noeuds[(*s_etat_processus)	if ((((l_instruction_courante).noeuds[(*s_etat_processus)
.pointeurs_caracteres[*ptr]]).noeuds =	.pointeurs_caracteres[*ptr]]).noeuds =
malloc((*s_etat_processus).nombre_caracteres	malloc(((size_t) (*s_etat_processus).nombre_caracteres)
* sizeof(struct_instruction))) == NULL)	* sizeof(struct_instruction))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 180 initialisation_instructions(struct_proce	Line 180 initialisation_instructions(struct_proce
}	}

if (((*s_etat_processus).pointeurs_caracteres =	if (((*s_etat_processus).pointeurs_caracteres =
malloc(longueur_tableau * sizeof(int))) == NULL)	malloc(((size_t) longueur_tableau * sizeof(int)))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 323 initialisation_instructions(struct_proce	Line 323 initialisation_instructions(struct_proce
INSTRUCTION("EGV", instruction_egv);	INSTRUCTION("EGV", instruction_egv);
INSTRUCTION("END", instruction_end);	INSTRUCTION("END", instruction_end);
INSTRUCTION("ENG", instruction_eng);	INSTRUCTION("ENG", instruction_eng);
	INSTRUCTION("EQV", instruction_eqv);
INSTRUCTION("EXP", instruction_exp);	INSTRUCTION("EXP", instruction_exp);
INSTRUCTION("FC?", instruction_fc_test);	INSTRUCTION("FC?", instruction_fc_test);
INSTRUCTION("FFT", instruction_fft);	INSTRUCTION("FFT", instruction_fft);
Line 487 initialisation_instructions(struct_proce	Line 488 initialisation_instructions(struct_proce
INSTRUCTION("PMAX", instruction_pmax);	INSTRUCTION("PMAX", instruction_pmax);
INSTRUCTION("PMIN", instruction_pmin);	INSTRUCTION("PMIN", instruction_pmin);
INSTRUCTION("POKE", instruction_poke);	INSTRUCTION("POKE", instruction_poke);
	INSTRUCTION("POLL", instruction_poll);
INSTRUCTION("PPAR", instruction_ppar);	INSTRUCTION("PPAR", instruction_ppar);
INSTRUCTION("PRMD", instruction_prmd);	INSTRUCTION("PRMD", instruction_prmd);
INSTRUCTION("PRST", instruction_prst);	INSTRUCTION("PRST", instruction_prst);
Line 512 initialisation_instructions(struct_proce	Line 514 initialisation_instructions(struct_proce
INSTRUCTION("RECV", instruction_recv);	INSTRUCTION("RECV", instruction_recv);
INSTRUCTION("REGV", instruction_regv);	INSTRUCTION("REGV", instruction_regv);
INSTRUCTION("REPL", instruction_repl);	INSTRUCTION("REPL", instruction_repl);
	INSTRUCTION("RGDL", instruction_rgdl);
	INSTRUCTION("RGDR", instruction_rgdr);
INSTRUCTION("RNRM", instruction_rnrm);	INSTRUCTION("RNRM", instruction_rnrm);
INSTRUCTION("ROLL", instruction_roll);	INSTRUCTION("ROLL", instruction_roll);
//INSTRUCTION("ROOT")	//INSTRUCTION("ROOT")
Line 676 initialisation_instructions(struct_proce	Line 680 initialisation_instructions(struct_proce
INSTRUCTION("PSDEV", instruction_psdev);	INSTRUCTION("PSDEV", instruction_psdev);
INSTRUCTION("PURGE", instruction_purge);	INSTRUCTION("PURGE", instruction_purge);
INSTRUCTION("RDATE", instruction_rdate);	INSTRUCTION("RDATE", instruction_rdate);
	INSTRUCTION("REGEX", instruction_regex);
INSTRUCTION("RELAX", instruction_relax);	INSTRUCTION("RELAX", instruction_relax);
INSTRUCTION("RFUSE", instruction_rfuse);	INSTRUCTION("RFUSE", instruction_rfuse);
INSTRUCTION("RSTOP", instruction_rstop);	INSTRUCTION("RSTOP", instruction_rstop);
Line 720 initialisation_instructions(struct_proce	Line 725 initialisation_instructions(struct_proce
INSTRUCTION("ATEXIT", instruction_atexit);	INSTRUCTION("ATEXIT", instruction_atexit);
INSTRUCTION("ATPOKE", instruction_atpoke);	INSTRUCTION("ATPOKE", instruction_atpoke);
INSTRUCTION("BESSEL", instruction_bessel);	INSTRUCTION("BESSEL", instruction_bessel);
	INSTRUCTION("CIPHER", instruction_cipher);
INSTRUCTION("CLRERR", instruction_clrerr);	INSTRUCTION("CLRERR", instruction_clrerr);
INSTRUCTION("CLRMTX", instruction_clrmtx);	INSTRUCTION("CLRMTX", instruction_clrmtx);
INSTRUCTION("CLRSWI", instruction_clrswi);	INSTRUCTION("CLRSWI", instruction_clrswi);
Line 744 initialisation_instructions(struct_proce	Line 750 initialisation_instructions(struct_proce
INSTRUCTION("DETACH", instruction_spawn);	INSTRUCTION("DETACH", instruction_spawn);
# endif	# endif
INSTRUCTION("DIAG->", instruction_diag_fleche);	INSTRUCTION("DIAG->", instruction_diag_fleche);
	INSTRUCTION("DIGEST", instruction_digest);
//INSTRUCTION("DOLIST")	//INSTRUCTION("DOLIST")
//Instruction HP48 (application d'une fonction à une liste)	//Instruction HP48 (application d'une fonction à une liste)
//liste(s) nombre_de_listes_a_traiter fonction DOLIST	//liste(s) nombre_de_listes_a_traiter fonction DOLIST
Line 755 initialisation_instructions(struct_proce	Line 762 initialisation_instructions(struct_proce
//DOLIST	//DOLIST
//=> { 29 42 57 }	//=> { 29 42 57 }
INSTRUCTION("ELSEIF", instruction_elseif);	INSTRUCTION("ELSEIF", instruction_elseif);
	INSTRUCTION("FORALL", instruction_forall);
INSTRUCTION("FORMAT", instruction_format);	INSTRUCTION("FORMAT", instruction_format);
//INSTRUCTION("HEIGHT")	//INSTRUCTION("HEIGHT")
INSTRUCTION("ITRACE", instruction_itrace);	INSTRUCTION("ITRACE", instruction_itrace);
Line 823 initialisation_instructions(struct_proce	Line 831 initialisation_instructions(struct_proce
INSTRUCTION("PROTECT", instruction_protect);	INSTRUCTION("PROTECT", instruction_protect);
INSTRUCTION("PSHPRFL", instruction_pshprfl);	INSTRUCTION("PSHPRFL", instruction_pshprfl);
INSTRUCTION("PULPRFL", instruction_pulprfl);	INSTRUCTION("PULPRFL", instruction_pulprfl);
	INSTRUCTION("RESTART", instruction_restart);
INSTRUCTION("REVLIST", instruction_revlist);	INSTRUCTION("REVLIST", instruction_revlist);
INSTRUCTION("SCATTER", instruction_scatter);	INSTRUCTION("SCATTER", instruction_scatter);
INSTRUCTION("SUSPEND", instruction_suspend);	INSTRUCTION("SUSPEND", instruction_suspend);
Line 836 initialisation_instructions(struct_proce	Line 845 initialisation_instructions(struct_proce

INSTRUCTION("CLRCNTXT", instruction_clrcntxt);	INSTRUCTION("CLRCNTXT", instruction_clrcntxt);
INSTRUCTION("CLRSMPHR", instruction_clrsmphr);	INSTRUCTION("CLRSMPHR", instruction_clrsmphr);
	INSTRUCTION("COMPRESS", instruction_compress);
INSTRUCTION("CONTINUE", instruction_continue);	INSTRUCTION("CONTINUE", instruction_continue);
	INSTRUCTION("CRITICAL", instruction_critical);
INSTRUCTION("DUPCNTXT", instruction_dupcntxt);	INSTRUCTION("DUPCNTXT", instruction_dupcntxt);
INSTRUCTION("FUNCTION", instruction_function);	INSTRUCTION("FUNCTION", instruction_function);
INSTRUCTION("IMPLICIT", instruction_implicit);	INSTRUCTION("IMPLICIT", instruction_implicit);
Line 894 initialisation_instructions(struct_proce	Line 905 initialisation_instructions(struct_proce
//pentes	//pentes
//représentent la valeur de la fonction (x,y) en leur milieu.	//représentent la valeur de la fonction (x,y) en leur milieu.
//=> utile pour y'=F(x,y)	//=> utile pour y'=F(x,y)
	INSTRUCTION("UNCOMPRESS", instruction_uncompress);

INSTRUCTION("LOCALIZATION", instruction_localization);	INSTRUCTION("LOCALIZATION", instruction_localization);
INSTRUCTION("SMPHRTRYDECR", instruction_smphrtrydecr);	INSTRUCTION("SMPHRTRYDECR", instruction_smphrtrydecr);
Line 955 analyse_instruction(struct_processus *s_	Line 967 analyse_instruction(struct_processus *s_
void	void
analyse(struct_processus s_etat_processus, void (fonction)())	analyse(struct_processus s_etat_processus, void (fonction)())
{	{
static logical1 initialisation = d_faux;

real8 attente;	real8 attente;
real8 pourcentage;	real8 pourcentage;
real8 temps_cpu;	real8 temps_cpu;
Line 1018 analyse(struct_processus *s_etat_process	Line 1028 analyse(struct_processus *s_etat_process
}	}
}	}

	/*
	* Verrou pour les sections_critiques
	*/

	if (pthread_mutex_lock(&mutex_sections_critiques) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

	if (pthread_mutex_unlock(&mutex_sections_critiques) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

scrutation_injection(s_etat_processus);	scrutation_injection(s_etat_processus);

if (fonction == NULL)	if (fonction == NULL)
Line 1080 analyse(struct_processus *s_etat_process	Line 1106 analyse(struct_processus *s_etat_process
if ((position = index((*s_etat_processus).instruction_courante, '$'))	if ((position = index((*s_etat_processus).instruction_courante, '$'))
!= NULL)	!= NULL)
{	{
if ((bibliotheque_candidate = malloc((position + 1	if ((bibliotheque_candidate = malloc(((size_t) (position + 1
- (*s_etat_processus).instruction_courante)	- (*s_etat_processus).instruction_courante))
* 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 1090 analyse(struct_processus *s_etat_process	Line 1116 analyse(struct_processus *s_etat_process

(*bibliotheque_candidate) = d_code_fin_chaine;	(*bibliotheque_candidate) = d_code_fin_chaine;
strncat(bibliotheque_candidate,	strncat(bibliotheque_candidate,
(*s_etat_processus).instruction_courante,	(*s_etat_processus).instruction_courante, ((size_t)
position - (*s_etat_processus).instruction_courante);	(position - (*s_etat_processus).instruction_courante)));

position++;	position++;

Line 1136 analyse(struct_processus *s_etat_process	Line 1162 analyse(struct_processus *s_etat_process
{	{
if ((*s_etat_processus).test_instruction == 'N')	if ((*s_etat_processus).test_instruction == 'N')
{	{
if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)	if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
	!= 0)
{	{
affectation_interruptions_logicielles(s_etat_processus);	(*s_etat_processus).erreur_systeme = d_es_processus;
	}
	else
	{
	if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
	{
	affectation_interruptions_logicielles(s_etat_processus);
	}

	if (pthread_mutex_unlock(&(*s_etat_processus)
	.mutex_interruptions) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	}
}	}

if (((*s_etat_processus).nombre_interruptions_en_queue != 0) &&	if (((*s_etat_processus).nombre_interruptions_en_queue != 0) &&
Line 1171 analyse(struct_processus *s_etat_process	Line 1211 analyse(struct_processus *s_etat_process

gettimeofday(&horodatage_final, NULL);	gettimeofday(&horodatage_final, NULL);

if (initialisation == d_vrai)	if ((*s_etat_processus).initialisation_scheduler == d_vrai)
{	{
temps_reel = ((real8) (horodatage_final.tv_sec -	temps_reel = ((real8) (horodatage_final.tv_sec -
horodatage_initial.tv_sec)) +	horodatage_initial.tv_sec)) +
Line 1209 analyse(struct_processus *s_etat_process	Line 1249 analyse(struct_processus *s_etat_process
(*s_etat_processus).pourcentage_maximal_cpu)	(*s_etat_processus).pourcentage_maximal_cpu)
- (pourcentage * temps_cpu / 100);	- (pourcentage * temps_cpu / 100);

temporisation.tv_sec = floor(attente);	temporisation.tv_sec = (time_t) floor(attente);
temporisation.tv_nsec = (attente - temporisation.tv_sec) *	temporisation.tv_nsec = (suseconds_t) ((attente
1E9;	- ((real8) temporisation.tv_sec)) * 1E9);

while(nanosleep(&temporisation, &temporisation) == -1);	while(nanosleep(&temporisation, &temporisation) == -1)
	{
	if (errno != EINTR)
	{
	break;
	}
	}
}	}

horodatage_initial = horodatage_final;	horodatage_initial = horodatage_final;
Line 1222 analyse(struct_processus *s_etat_process	Line 1268 analyse(struct_processus *s_etat_process
}	}
else	else
{	{
initialisation = d_vrai;	(*s_etat_processus).initialisation_scheduler = d_vrai;

horodatage_initial = horodatage_final;	horodatage_initial = horodatage_final;
usage_initial = usage_final;	usage_initial = usage_final;
Line 1230 analyse(struct_processus *s_etat_process	Line 1276 analyse(struct_processus *s_etat_process
}	}
else	else
{	{
initialisation = d_faux;	(*s_etat_processus).initialisation_scheduler = d_faux;
}	}

/*	/*

Removed from v.1.61
changed lines
	Added in v.1.96