rpl/src/compilation.c - diff

Return to compilation.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/compilation.c between versions 1.19 and 1.89

version 1.19, 2010/08/26 19:07:35	version 1.89, 2017/06/29 12:33:34
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.19	RPL/2 (R) version 4.1.27
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2017 Dr. BERTRAND Joël

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

Line 54 compilation(struct_processus *s_etat_pro	Line 54 compilation(struct_processus *s_etat_pro
unsigned char ouverture_definition;	unsigned char ouverture_definition;
unsigned char position_debut_nom_definition_valide;	unsigned char position_debut_nom_definition_valide;

unsigned long *adresse;	integer8 *adresse;
unsigned long i;	integer8 i;
unsigned long niveau_definition;	integer8 niveau_definition;
unsigned long niveau_definition_registre;	integer8 niveau_definition_registre;
unsigned long position_courante;	integer8 position_courante;
unsigned long position_debut_nom_definition;	integer8 position_debut_nom_definition;
unsigned long position_fin_nom_definition;	integer8 position_fin_nom_definition;
unsigned long validation;	integer8 validation;
unsigned long validation_registre;	integer8 validation_registre;

(*s_etat_processus).erreur_compilation = d_ec;	(*s_etat_processus).erreur_compilation = d_ec;
(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
Line 257 compilation(struct_processus *s_etat_pro	Line 257 compilation(struct_processus *s_etat_pro
s_variable = (struct_variable *)	s_variable = (struct_variable *)
malloc(sizeof(struct_variable));	malloc(sizeof(struct_variable));
adresse = (*s_objet).objet;	adresse = (*s_objet).objet;
definition = (unsigned char *) malloc(	definition = (unsigned char *) malloc(((size_t)
(position_fin_nom_definition -	(position_fin_nom_definition -
position_debut_nom_definition + 2) *	position_debut_nom_definition + 2)) *
sizeof(unsigned char));	sizeof(unsigned char));

if ((s_objet == NULL) \|\| (s_variable == NULL) \|\|	if ((s_objet == NULL) \|\| (s_variable == NULL) \|\|
Line 281 compilation(struct_processus *s_etat_pro	Line 281 compilation(struct_processus *s_etat_pro

while(i <= position_fin_nom_definition)	while(i <= position_fin_nom_definition)
{	{
	if ((*s_etat_processus).pointeurs_caracteres_variables
	[(*s_etat_processus).definitions_chainees[i]] < 0)
	{
	free(s_variable);

	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
	return(d_erreur);
	}

(definition++) = (s_etat_processus)	(definition++) = (s_etat_processus)
.definitions_chainees[i++];	.definitions_chainees[i++];
}	}
Line 290 compilation(struct_processus *s_etat_pro	Line 299 compilation(struct_processus *s_etat_pro
if (recherche_variable(s_etat_processus, (*s_variable).nom)	if (recherche_variable(s_etat_processus, (*s_variable).nom)
== d_vrai)	== d_vrai)
{	{
	free(s_variable);

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
printf("+++Attention : Plusieurs définitions de"	printf("+++Attention : Plusieurs définitions de"
Line 311 compilation(struct_processus *s_etat_pro	Line 322 compilation(struct_processus *s_etat_pro
if ((*s_etat_processus).erreur_systeme != d_es)	if ((*s_etat_processus).erreur_systeme != d_es)
{	{
free(s_variable);	free(s_variable);

return(d_erreur);	return(d_erreur);
}	}

Line 358 compilation(struct_processus *s_etat_pro	Line 368 compilation(struct_processus *s_etat_pro
================================================================================	================================================================================
*/	*/

logical1	enum t_condition { AN_IF = 1, AN_IFERR, AN_THEN, AN_ELSE, AN_ELSEIF,
analyse_syntaxique(struct_processus *s_etat_processus)	AN_END, AN_DO, AN_UNTIL, AN_WHILE, AN_REPEAT, AN_SELECT,
{	AN_CASE, AN_DEFAULT, AN_UP, AN_DOWN, AN_FOR, AN_START,
enum t_condition { AN_IF = 1, AN_IFERR, AN_THEN, AN_ELSE, AN_ELSEIF,	AN_NEXT, AN_STEP, AN_CRITICAL, AN_FORALL };
AN_END, AN_DO, AN_UNTIL, AN_WHILE, AN_REPEAT, AN_SELECT,
AN_CASE, AN_DEFAULT, AN_UP, AN_DOWN, AN_FOR, AN_START,
AN_NEXT, AN_STEP };

unsigned char *instruction;
unsigned char registre;

typedef struct pile
{
enum t_condition condition;
struct pile *suivant;
} struct_pile_analyse;

struct_pile_analyse *l_base_pile;	typedef struct pile
struct_pile_analyse *l_nouvelle_base_pile;	{
	enum t_condition condition;
	struct pile *suivant;
	} struct_pile_analyse;

	static inline struct_pile_analyse *
	empilement_analyse(struct_processus *s_etat_processus,
	struct_pile_analyse *ancienne_base,
	enum t_condition condition)
	{
	struct_pile_analyse *nouvelle_base;

inline struct_pile_analyse *	if ((nouvelle_base = malloc(sizeof(struct_pile_analyse))) == NULL)
empilement_analyse(struct_pile_analyse *ancienne_base,
enum t_condition condition)
{	{
struct_pile_analyse *nouvelle_base;	return(NULL);
	}

if ((nouvelle_base = malloc(sizeof(struct_pile_analyse))) == NULL)	(*nouvelle_base).suivant = ancienne_base;
{	(*nouvelle_base).condition = condition;
return(NULL);
}

(*nouvelle_base).suivant = ancienne_base;	return(nouvelle_base);
(*nouvelle_base).condition = condition;	}

return(nouvelle_base);	static inline struct_pile_analyse *
}	depilement_analyse(struct_processus *s_etat_processus,
	struct_pile_analyse *ancienne_base)
	{
	struct_pile_analyse *nouvelle_base;

inline struct_pile_analyse *	if (ancienne_base == NULL)
depilement_analyse(struct_pile_analyse *ancienne_base)
{	{
struct_pile_analyse *nouvelle_base;	return(NULL);
	}

if (ancienne_base == NULL)	nouvelle_base = (*ancienne_base).suivant;
{	free(ancienne_base);
return(NULL);
}

nouvelle_base = (*ancienne_base).suivant;	return(nouvelle_base);
free(ancienne_base);	}

return(nouvelle_base);	static inline logical1
	test_analyse(struct_pile_analyse *l_base_pile, enum t_condition condition)
	{
	if (l_base_pile == NULL)
	{
	return(d_faux);
}	}

inline logical1	return(((*l_base_pile).condition == condition) ? d_vrai : d_faux);
test_analyse(struct_pile_analyse *l_base_pile, enum t_condition condition)	}
{
if (l_base_pile == NULL)
{
return(d_faux);
}

return(((*l_base_pile).condition == condition) ? d_vrai : d_faux);	static inline void
}	liberation_analyse(struct_processus *s_etat_processus,
	struct_pile_analyse *l_base_pile)
	{
	struct_pile_analyse *l_nouvelle_base_pile;

inline void	while(l_base_pile != NULL)
liberation_analyse(struct_pile_analyse *l_base_pile)
{	{
struct_pile_analyse *l_nouvelle_base_pile;	l_nouvelle_base_pile = (*l_base_pile).suivant;
	free(l_base_pile);
	l_base_pile = l_nouvelle_base_pile;
	}

while(l_base_pile != NULL)	return;
{	}
l_nouvelle_base_pile = (*l_base_pile).suivant;
free(l_base_pile);
l_base_pile = l_nouvelle_base_pile;
}

return;	logical1
}	analyse_syntaxique(struct_processus *s_etat_processus)
	{
	unsigned char *instruction;
	unsigned char registre;

	struct_pile_analyse *l_base_pile;
	struct_pile_analyse *l_nouvelle_base_pile;

l_base_pile = NULL;	l_base_pile = NULL;
l_nouvelle_base_pile = NULL;	l_nouvelle_base_pile = NULL;
Line 471 analyse_syntaxique(struct_processus *s_e	Line 484 analyse_syntaxique(struct_processus *s_e
if (recherche_instruction_suivante(s_etat_processus) !=	if (recherche_instruction_suivante(s_etat_processus) !=
d_absence_erreur)	d_absence_erreur)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme = registre;	(*s_etat_processus).autorisation_empilement_programme = registre;
return(d_erreur);	return(d_erreur);
}	}

if ((instruction = conversion_majuscule(	if ((instruction = conversion_majuscule(s_etat_processus,
(*s_etat_processus).instruction_courante)) == NULL)	(*s_etat_processus).instruction_courante)) == NULL)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme = registre;	(*s_etat_processus).autorisation_empilement_programme = registre;
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 489 analyse_syntaxique(struct_processus *s_e	Line 502 analyse_syntaxique(struct_processus *s_e

if (strcmp(instruction, "IF") == 0)	if (strcmp(instruction, "IF") == 0)
{	{
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_IF))	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
== NULL)	l_base_pile, AN_IF)) == NULL)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 503 analyse_syntaxique(struct_processus *s_e	Line 516 analyse_syntaxique(struct_processus *s_e
}	}
else if (strcmp(instruction, "IFERR") == 0)	else if (strcmp(instruction, "IFERR") == 0)
{	{
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
AN_IFERR)) == NULL)	l_base_pile, AN_IFERR)) == NULL)
	{
	liberation_analyse(s_etat_processus, l_base_pile);

	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(d_erreur);
	}

	l_base_pile = l_nouvelle_base_pile;
	}
	else if (strcmp(instruction, "CRITICAL") == 0)
	{
	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
	l_base_pile, AN_CRITICAL)) == NULL)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 521 analyse_syntaxique(struct_processus *s_e	Line 547 analyse_syntaxique(struct_processus *s_e
(test_analyse(l_base_pile, AN_CASE) == d_faux) &&	(test_analyse(l_base_pile, AN_CASE) == d_faux) &&
(test_analyse(l_base_pile, AN_IFERR) == d_faux))	(test_analyse(l_base_pile, AN_IFERR) == d_faux))
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre;	registre;
Line 537 analyse_syntaxique(struct_processus *s_e	Line 563 analyse_syntaxique(struct_processus *s_e
{	{
if (test_analyse(l_base_pile, AN_THEN) == d_faux)	if (test_analyse(l_base_pile, AN_THEN) == d_faux)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre;	registre;
Line 553 analyse_syntaxique(struct_processus *s_e	Line 579 analyse_syntaxique(struct_processus *s_e
{	{
if (test_analyse(l_base_pile, AN_THEN) == d_faux)	if (test_analyse(l_base_pile, AN_THEN) == d_faux)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre;	registre;
Line 572 analyse_syntaxique(struct_processus *s_e	Line 598 analyse_syntaxique(struct_processus *s_e
(test_analyse(l_base_pile, AN_DEFAULT) == d_faux) &&	(test_analyse(l_base_pile, AN_DEFAULT) == d_faux) &&
(test_analyse(l_base_pile, AN_SELECT) == d_faux) &&	(test_analyse(l_base_pile, AN_SELECT) == d_faux) &&
(test_analyse(l_base_pile, AN_THEN) == d_faux) &&	(test_analyse(l_base_pile, AN_THEN) == d_faux) &&
	(test_analyse(l_base_pile, AN_CRITICAL) == d_faux) &&
(test_analyse(l_base_pile, AN_ELSE) == d_faux))	(test_analyse(l_base_pile, AN_ELSE) == d_faux))
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre;	registre;
Line 584 analyse_syntaxique(struct_processus *s_e	Line 611 analyse_syntaxique(struct_processus *s_e
return(d_erreur);	return(d_erreur);
}	}

l_base_pile = depilement_analyse(l_base_pile);	l_base_pile = depilement_analyse(s_etat_processus, l_base_pile);
}	}
else if (strcmp(instruction, "DO") == 0)	else if (strcmp(instruction, "DO") == 0)
{	{
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_DO))	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
== NULL)	l_base_pile, AN_DO)) == NULL)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 603 analyse_syntaxique(struct_processus *s_e	Line 630 analyse_syntaxique(struct_processus *s_e
{	{
if (test_analyse(l_base_pile, AN_DO) == d_faux)	if (test_analyse(l_base_pile, AN_DO) == d_faux)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre;	registre;
Line 617 analyse_syntaxique(struct_processus *s_e	Line 644 analyse_syntaxique(struct_processus *s_e
}	}
else if (strcmp(instruction, "WHILE") == 0)	else if (strcmp(instruction, "WHILE") == 0)
{	{
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
AN_WHILE)) == NULL)	l_base_pile, AN_WHILE)) == NULL)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 632 analyse_syntaxique(struct_processus *s_e	Line 659 analyse_syntaxique(struct_processus *s_e
{	{
if (test_analyse(l_base_pile, AN_WHILE) == d_faux)	if (test_analyse(l_base_pile, AN_WHILE) == d_faux)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre;	registre;
Line 646 analyse_syntaxique(struct_processus *s_e	Line 673 analyse_syntaxique(struct_processus *s_e
}	}
else if (strcmp(instruction, "SELECT") == 0)	else if (strcmp(instruction, "SELECT") == 0)
{	{
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
AN_SELECT)) == NULL)	l_base_pile, AN_SELECT)) == NULL)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 661 analyse_syntaxique(struct_processus *s_e	Line 688 analyse_syntaxique(struct_processus *s_e
{	{
if (test_analyse(l_base_pile, AN_SELECT) == d_faux)	if (test_analyse(l_base_pile, AN_SELECT) == d_faux)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre;	registre;
Line 671 analyse_syntaxique(struct_processus *s_e	Line 698 analyse_syntaxique(struct_processus *s_e
return(d_erreur);	return(d_erreur);
}	}

if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
AN_CASE)) == NULL)	l_base_pile, AN_CASE)) == NULL)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 686 analyse_syntaxique(struct_processus *s_e	Line 713 analyse_syntaxique(struct_processus *s_e
{	{
if (test_analyse(l_base_pile, AN_SELECT) == d_faux)	if (test_analyse(l_base_pile, AN_SELECT) == d_faux)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre;	registre;
Line 700 analyse_syntaxique(struct_processus *s_e	Line 727 analyse_syntaxique(struct_processus *s_e
}	}
else if (strcmp(instruction, "<<") == 0)	else if (strcmp(instruction, "<<") == 0)
{	{
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_UP))	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
== NULL)	l_base_pile, AN_UP)) == NULL)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 715 analyse_syntaxique(struct_processus *s_e	Line 742 analyse_syntaxique(struct_processus *s_e
{	{
if (test_analyse(l_base_pile, AN_UP) == d_faux)	if (test_analyse(l_base_pile, AN_UP) == d_faux)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre;	registre;
Line 725 analyse_syntaxique(struct_processus *s_e	Line 752 analyse_syntaxique(struct_processus *s_e
return(d_erreur);	return(d_erreur);
}	}

l_base_pile = depilement_analyse(l_base_pile);	l_base_pile = depilement_analyse(s_etat_processus, l_base_pile);
}	}
else if (strcmp(instruction, "FOR") == 0)	else if (strcmp(instruction, "FOR") == 0)
{	{
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile, AN_FOR))	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
== NULL)	l_base_pile, AN_FOR)) == NULL)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 742 analyse_syntaxique(struct_processus *s_e	Line 769 analyse_syntaxique(struct_processus *s_e
}	}
else if (strcmp(instruction, "START") == 0)	else if (strcmp(instruction, "START") == 0)
{	{
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
AN_START)) == NULL)	l_base_pile, AN_START)) == NULL)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(d_erreur);
	}

	l_base_pile = l_nouvelle_base_pile;
	}
	else if (strcmp(instruction, "FORALL") == 0)
	{
	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
	l_base_pile, AN_FORALL)) == NULL)
	{
	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 756 analyse_syntaxique(struct_processus *s_e	Line 796 analyse_syntaxique(struct_processus *s_e
else if (strcmp(instruction, "NEXT") == 0)	else if (strcmp(instruction, "NEXT") == 0)
{	{
if ((test_analyse(l_base_pile, AN_FOR) == d_faux) &&	if ((test_analyse(l_base_pile, AN_FOR) == d_faux) &&
	(test_analyse(l_base_pile, AN_FORALL) == d_faux) &&
(test_analyse(l_base_pile, AN_START) == d_faux))	(test_analyse(l_base_pile, AN_START) == d_faux))
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre;	registre;
Line 768 analyse_syntaxique(struct_processus *s_e	Line 809 analyse_syntaxique(struct_processus *s_e
return(d_erreur);	return(d_erreur);
}	}

l_base_pile = depilement_analyse(l_base_pile);	l_base_pile = depilement_analyse(s_etat_processus, l_base_pile);
}	}
else if (strcmp(instruction, "STEP") == 0)	else if (strcmp(instruction, "STEP") == 0)
{	{
if ((test_analyse(l_base_pile, AN_FOR) == d_faux) &&	if ((test_analyse(l_base_pile, AN_FOR) == d_faux) &&
(test_analyse(l_base_pile, AN_START) == d_faux))	(test_analyse(l_base_pile, AN_START) == d_faux))
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre;	registre;
Line 785 analyse_syntaxique(struct_processus *s_e	Line 826 analyse_syntaxique(struct_processus *s_e
return(d_erreur);	return(d_erreur);
}	}

l_base_pile = depilement_analyse(l_base_pile);	l_base_pile = depilement_analyse(s_etat_processus, l_base_pile);
}	}

// Invalidation de l'instruction courante dans le fichier rpl-core	// Invalidation de l'instruction courante dans le fichier rpl-core
Line 798 analyse_syntaxique(struct_processus *s_e	Line 839 analyse_syntaxique(struct_processus *s_e

if (l_base_pile != NULL)	if (l_base_pile != NULL)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

(*s_etat_processus).autorisation_empilement_programme = registre;	(*s_etat_processus).autorisation_empilement_programme = registre;
(*s_etat_processus).erreur_compilation = d_ec_source_incoherent;	(*s_etat_processus).erreur_compilation = d_ec_source_incoherent;
Line 824 analyse_syntaxique(struct_processus *s_e	Line 865 analyse_syntaxique(struct_processus *s_e
*/	*/

void	void
swap(void variable_1, void variable_2, unsigned long taille)	swap(void variable_1, void variable_2, integer8 taille)
{	{
register unsigned char *t_var_1;	register unsigned char *t_var_1;
register unsigned char *t_var_2;	register unsigned char *t_var_2;
register unsigned char variable_temporaire;	register unsigned char variable_temporaire;

register unsigned long i;	register integer8 i;

t_var_1 = (unsigned char *) variable_1;	t_var_1 = (unsigned char *) variable_1;
t_var_2 = (unsigned char *) variable_2;	t_var_2 = (unsigned char *) variable_2;
Line 861 swap(void variable_1, void variable_2,	Line 902 swap(void variable_1, void variable_2,
logical1	logical1
recherche_instruction_suivante(struct_processus *s_etat_processus)	recherche_instruction_suivante(struct_processus *s_etat_processus)
{	{
	return(recherche_instruction_suivante_recursive(s_etat_processus, 0));
	}

	logical1
	recherche_instruction_suivante_recursive(struct_processus *s_etat_processus,
	integer8 recursivite)
	{
	enum t_type registre_type_en_cours;

logical1 drapeau_fin_objet;	logical1 drapeau_fin_objet;
logical1 erreur;	logical1 erreur;
logical1 erreur_analyse;
logical1 erreur_format;	int erreur_analyse;
	int erreur_format;

	integer8 nombre_caracteres;
	integer8 (*__type_parse)(struct_processus
	*s_etat_processus);


unsigned char base_binaire;	unsigned char base_binaire;
	unsigned char caractere_fin;
unsigned char *pointeur_caractere_courant;	unsigned char *pointeur_caractere_courant;
unsigned char *pointeur_caractere_destination;	unsigned char *pointeur_caractere_destination;
unsigned char *pointeur_debut_instruction;	unsigned char *pointeur_debut_instruction;
unsigned char *pointeur_fin_instruction;	unsigned char *pointeur_fin_instruction;

signed long niveau;	signed long niveau;
signed long niveau_annexe;
	struct_liste_chainee *l_element_courant;

erreur_analyse = d_ex;	erreur_analyse = d_ex;
erreur_format = d_ex;	erreur_format = d_ex;
erreur = d_absence_erreur;	erreur = d_absence_erreur;

	/*
	* On regarde s'il existe des fonctions permettant de parser
	* les objets dans les bibliothèques externes.
	*/

	l_element_courant = (*s_etat_processus).s_bibliotheques;

	while(l_element_courant != NULL)
	{
	if ((__type_parse = dlsym((((struct_bibliotheque )
	(*l_element_courant).donnee)).descripteur, "__type_parse"))
	!= NULL)
	{
	// Une fonction declareTypeExtension(parse) se trouve dans la
	// bibliothèque. Si cette fonction renvoie une valeur non nulle,
	// elle a réussi à parser correctement un objet.

	if ((nombre_caracteres = __type_parse(s_etat_processus)) != 0)
	{
	if (((*s_etat_processus).instruction_courante =
	malloc((((unsigned) nombre_caracteres) + 1)
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(d_erreur);
	}

	strncpy((*s_etat_processus).instruction_courante,
	(*s_etat_processus).instruction_courante +
	(*s_etat_processus).position_courante,
	(unsigned) nombre_caracteres);
	(*s_etat_processus).instruction_courante[nombre_caracteres]
	= d_code_fin_chaine;

	(*s_etat_processus).position_courante += nombre_caracteres;
	return(erreur);
	}
	}

	l_element_courant = (*l_element_courant).suivant;
	}

	/*
	* Gestion des types intrinsèques
	*/

	switch((*s_etat_processus).type_en_cours)
	{
	case RPN:
	{
	caractere_fin = '>';
	break;
	}

	case LST:
	{
	caractere_fin = '}';
	break;
	}

	case TBL:
	{
	caractere_fin = ']';
	break;
	}

	default:
	{
	caractere_fin = d_code_espace;
	break;
	}
	}

drapeau_fin_objet = d_faux;	drapeau_fin_objet = d_faux;
niveau = 0;	niveau = 0;

Line 917 recherche_instruction_suivante(struct_pr	Line 1049 recherche_instruction_suivante(struct_pr
while(((*pointeur_caractere_courant) != d_code_espace) &&	while(((*pointeur_caractere_courant) != d_code_espace) &&
((*pointeur_caractere_courant) != d_code_fin_chaine) &&	((*pointeur_caractere_courant) != d_code_fin_chaine) &&
(drapeau_fin_objet == d_faux) &&	(drapeau_fin_objet == d_faux) &&
(erreur_analyse == d_ex) &&	(erreur_analyse == d_ex) && (erreur_format == d_ex))
(erreur_format == d_ex))
{	{
switch(*pointeur_caractere_courant++)	switch(*pointeur_caractere_courant++)
{	{
case ']' :	case ']' :
case '}' :	case '}' :
	{
	break;
	}

case ')' :	case ')' :
{	{
erreur_format = d_ex_syntaxe;	erreur_format = d_ex_syntaxe;
Line 1133 recherche_instruction_suivante(struct_pr	Line 1268 recherche_instruction_suivante(struct_pr
pointeur_caractere_courant++;	pointeur_caractere_courant++;

if (((*pointeur_caractere_courant) != d_code_fin_chaine) &&	if (((*pointeur_caractere_courant) != d_code_fin_chaine) &&
((*pointeur_caractere_courant) != ' '))	((*pointeur_caractere_courant) != d_code_espace) &&
	((*pointeur_caractere_courant) != caractere_fin))
{	{
erreur_analyse = d_ex_syntaxe;	erreur_analyse = d_ex_syntaxe;
}	}
Line 1257 recherche_instruction_suivante(struct_pr	Line 1393 recherche_instruction_suivante(struct_pr
}	}

niveau = 1;	niveau = 1;
niveau_annexe = 0;

while((niveau != 0) && ((*pointeur_caractere_courant) !=	while((niveau != 0) && ((*pointeur_caractere_courant) !=
d_code_fin_chaine))	d_code_fin_chaine))
{	{
switch(*pointeur_caractere_courant)	(*s_etat_processus).position_courante =
{	pointeur_caractere_courant
case '{' :	- (*s_etat_processus).definitions_chainees;
{
if (niveau_annexe == 0)
{
niveau++;
}
else
{
erreur_analyse = d_ex_syntaxe;
}

break;
}

case '}' :	registre_type_en_cours = (*s_etat_processus).type_en_cours;
{	(*s_etat_processus).type_en_cours = LST;
if (niveau_annexe == 0)
{
niveau--;
}
else
{
erreur_analyse = d_ex_syntaxe;
}

break;	if (recherche_instruction_suivante_recursive(
}	s_etat_processus, recursivite + 1) == d_erreur)
	{
case '[' :	(*s_etat_processus).type_en_cours =
{	registre_type_en_cours;
niveau_annexe++;

if (niveau_annexe > 2)
{
erreur_analyse = d_ex_syntaxe;
}

break;
}

case ']' :	if ((*s_etat_processus).instruction_courante
	!= NULL)
{	{
niveau_annexe--;	free((*s_etat_processus).instruction_courante);
	(*s_etat_processus).instruction_courante = NULL;
if (niveau_annexe < 0)
{
erreur_analyse = d_ex_syntaxe;
}

break;
}	}

case '"' :	return(d_erreur);
{	}
if (niveau_annexe == 0)
{
pointeur_caractere_courant++;

while((*pointeur_caractere_courant != '"') &&	(*s_etat_processus).type_en_cours = registre_type_en_cours;
((*pointeur_caractere_courant) !=	pointeur_caractere_courant =
d_code_fin_chaine))	(*s_etat_processus).definitions_chainees +
{	(*s_etat_processus).position_courante;
if (*pointeur_caractere_courant == '\\')
{
pointeur_caractere_courant++;

switch(*pointeur_caractere_courant)
{
case '\\' :
case '"' :
{
pointeur_caractere_courant++;
break;
}
}
}
else
{
pointeur_caractere_courant++;
}
}
}
else
{
erreur_analyse = d_ex_syntaxe;
}

break;	if (strcmp((*s_etat_processus).instruction_courante, "}")
}	== 0)
	{
	niveau--;
}	}

pointeur_caractere_courant++;	free((*s_etat_processus).instruction_courante);
}	}

if ((niveau != 0) \|\| (niveau_annexe != 0))	if (niveau != 0)
{	{
erreur_analyse = d_ex_syntaxe;	erreur_analyse = d_ex_syntaxe;
}	}
Line 1449 recherche_instruction_suivante(struct_pr	Line 1525 recherche_instruction_suivante(struct_pr
{	{
if (((*s_etat_processus).autorisation_empilement_programme	if (((*s_etat_processus).autorisation_empilement_programme
== 'Y') && ((*pointeur_caractere_courant) == '<'))	== 'Y') && ((*pointeur_caractere_courant) == '<'))
{	{ // Cas << >>
if (pointeur_debut_instruction !=	if (pointeur_debut_instruction !=
(pointeur_caractere_courant - 1))	(pointeur_caractere_courant - 1))
{	{
erreur_format = d_ex_syntaxe;	erreur_format = d_ex_syntaxe;
}	}

niveau = 1;	pointeur_caractere_courant++;
	drapeau_fin_objet = d_faux;

while((niveau != 0) && ((*pointeur_caractere_courant) !=	while(((*pointeur_caractere_courant) != d_code_fin_chaine)
d_code_fin_chaine))	&& (erreur_format == d_absence_erreur))
{	{
if (((*pointeur_caractere_courant) == '<') &&	while((*pointeur_caractere_courant) == d_code_espace)
((*(pointeur_caractere_courant + 1)) == '<'))
{	{
niveau++;
pointeur_caractere_courant++;	pointeur_caractere_courant++;
}	}
else if (((*pointeur_caractere_courant) == '>') &&
((*(pointeur_caractere_courant + 1)) == '>'))	if (((*pointeur_caractere_courant) == '>') &&
	((*(pointeur_caractere_courant - 1)) ==
	d_code_espace))
{	{
niveau--;
pointeur_caractere_courant++;	pointeur_caractere_courant++;

	if ((*pointeur_caractere_courant) == '>')
	{ // Cas de '>>'
	drapeau_fin_objet = d_vrai;
	pointeur_caractere_courant++;
	break;
	}
	else if ((*pointeur_caractere_courant) == '=')
	{ // Cas de '>='
	pointeur_caractere_courant++;
	}
	else if ((*pointeur_caractere_courant) !=
	d_code_espace)
	{ // Tous les cas différents de '>'
	erreur_analyse = d_ex_syntaxe;
	break;
	}

	pointeur_caractere_courant--;
}	}
else if ((*pointeur_caractere_courant) == '"')
	if ((erreur_format == d_absence_erreur) &&
	(drapeau_fin_objet == d_faux))
{	{
pointeur_caractere_courant++;	(*s_etat_processus).position_courante =
	pointeur_caractere_courant
	- (*s_etat_processus).definitions_chainees;

while((*pointeur_caractere_courant != '"') &&	registre_type_en_cours = (*s_etat_processus)
((*pointeur_caractere_courant) !=	.type_en_cours;
d_code_fin_chaine))	(*s_etat_processus).type_en_cours = RPN;

	if ((erreur =
	recherche_instruction_suivante_recursive(
	s_etat_processus, recursivite + 1))
	!= d_absence_erreur)
{	{
if (*pointeur_caractere_courant == '\\')	(*s_etat_processus).type_en_cours =
{	registre_type_en_cours;
pointeur_caractere_courant++;

switch(*pointeur_caractere_courant)	if ((*s_etat_processus).instruction_courante
{	!= NULL)
case '\\' :
case '"' :
{
pointeur_caractere_courant++;
break;
}
}
}
else
{	{
pointeur_caractere_courant++;	free((*s_etat_processus)
	.instruction_courante);
	(*s_etat_processus).instruction_courante
	= NULL;
}	}

	return(d_erreur);
}	}
}

pointeur_caractere_courant++;	(*s_etat_processus).type_en_cours =
	registre_type_en_cours;
	pointeur_caractere_courant = (*s_etat_processus)
	.definitions_chainees + (*s_etat_processus)
	.position_courante;

	free((*s_etat_processus).instruction_courante);
	}
}	}

if (niveau != 0)	if (drapeau_fin_objet == d_faux)
{	{
erreur_analyse = d_ex_syntaxe;	erreur_analyse = d_ex_syntaxe;
	drapeau_fin_objet = d_vrai;
}	}

drapeau_fin_objet = d_vrai;
}	}
else if ((*pointeur_caractere_courant) == '[')	else if ((*pointeur_caractere_courant) == '[')
{	{ // Cas <[ ]>
if (pointeur_debut_instruction !=	if (pointeur_debut_instruction !=
(pointeur_caractere_courant - 1))	(pointeur_caractere_courant - 1))
{	{
Line 1553 recherche_instruction_suivante(struct_pr	Line 1657 recherche_instruction_suivante(struct_pr
pointeur_caractere_courant	pointeur_caractere_courant
- (*s_etat_processus).definitions_chainees;	- (*s_etat_processus).definitions_chainees;

if ((erreur = recherche_instruction_suivante(	registre_type_en_cours = (*s_etat_processus)
s_etat_processus)) != d_absence_erreur)	.type_en_cours;
	(*s_etat_processus).type_en_cours = TBL;

	if ((erreur =
	recherche_instruction_suivante_recursive(
	s_etat_processus, recursivite + 1))
	!= d_absence_erreur)
{	{
	(*s_etat_processus).type_en_cours =
	registre_type_en_cours;

if ((*s_etat_processus).instruction_courante	if ((*s_etat_processus).instruction_courante
!= NULL)	!= NULL)
{	{
free((*s_etat_processus)	free((*s_etat_processus)
.instruction_courante);	.instruction_courante);
	(*s_etat_processus).instruction_courante
	= NULL;
}	}

return(d_erreur);	return(d_erreur);
}	}

	(*s_etat_processus).type_en_cours =
	registre_type_en_cours;
pointeur_caractere_courant = (*s_etat_processus)	pointeur_caractere_courant = (*s_etat_processus)
.definitions_chainees + (*s_etat_processus)	.definitions_chainees + (*s_etat_processus)
.position_courante;	.position_courante;
Line 1584 recherche_instruction_suivante(struct_pr	Line 1701 recherche_instruction_suivante(struct_pr
break;	break;
}	}
}	}

	if ((*(pointeur_caractere_courant - 1)) == caractere_fin)
	{
	// Cas des objets composites (LST, RPN, TBL)
	break;
	}
	else if ((*pointeur_caractere_courant) == caractere_fin)
	{
	// Condition pour traiter les cas "123}"
	break;
	}
}	}

pointeur_fin_instruction = pointeur_caractere_courant;	pointeur_fin_instruction = pointeur_caractere_courant;

	if (recursivite == 0)
	{
	// Si la variable récursivité est nulle, il faut que le caractère
	// suivant l'objet soit un espace ou une fin de chaîne. Si ce n'est pas
	// le cas, il faut retourner une erreur car les objets de type
	// [[ 1 4 ]]3 doivent être invalides.

	switch((*pointeur_fin_instruction))
	{
	case d_code_fin_chaine:
	case d_code_espace:
	{
	break;
	}

	default:
	{
	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
	// return(d_erreur);
	}
	}
	}

(s_etat_processus).instruction_courante = (unsigned char )	(s_etat_processus).instruction_courante = (unsigned char )
malloc(((pointeur_fin_instruction - pointeur_debut_instruction)	malloc((((size_t) (pointeur_fin_instruction
+ 1) * sizeof(unsigned char));	- pointeur_debut_instruction)) + 1) * sizeof(unsigned char));

if ((*s_etat_processus).instruction_courante == NULL)	if ((*s_etat_processus).instruction_courante == NULL)
{	{
Line 1613 recherche_instruction_suivante(struct_pr	Line 1764 recherche_instruction_suivante(struct_pr
erreur = ((erreur_analyse == d_ex) && (erreur_format == d_ex))	erreur = ((erreur_analyse == d_ex) && (erreur_format == d_ex))
? d_absence_erreur : d_erreur;	? d_absence_erreur : d_erreur;
(*s_etat_processus).erreur_execution = erreur_analyse;	(*s_etat_processus).erreur_execution = erreur_analyse;

	if ((*s_etat_processus).erreur_execution == d_ex)
	{
	(*s_etat_processus).erreur_execution = erreur_format;
	}
}	}
else	else
{	{
Line 1628 recherche_instruction_suivante(struct_pr	Line 1784 recherche_instruction_suivante(struct_pr

/*	/*
================================================================================	================================================================================
Routine mettant la chaine d'entrée en majuscule	Routine mettant la chaîne d'entrée en majuscule
================================================================================	================================================================================
Entrée : pointeur sur une chaine en minuscules.	Entrée : pointeur sur une chaîne en minuscules.
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Sortie : pointeur sur la chaine en majuscules. Si le pointeur retourné	Sortie : pointeur sur la chaîne en majuscules. Si le pointeur retourné
est nul, il s'est produit une erreur. L'allocation est faite dans la	est nul, il s'est produit une erreur. L'allocation est faite dans la
routine.	routine.
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Line 1641 recherche_instruction_suivante(struct_pr	Line 1797 recherche_instruction_suivante(struct_pr
*/	*/

unsigned char *	unsigned char *
conversion_majuscule(unsigned char *chaine)	conversion_majuscule(struct_processus s_etat_processus, unsigned char chaine)
{	{
register unsigned char *caractere_courant;	register unsigned char *caractere_courant;
register unsigned char *caractere_courant_converti;	register unsigned char *caractere_courant_converti;
register unsigned char *chaine_convertie;	register unsigned char *chaine_convertie;

unsigned long longueur_chaine_plus_terminaison;	integer8 longueur_chaine_plus_terminaison;

longueur_chaine_plus_terminaison = 0;	longueur_chaine_plus_terminaison = 0;
caractere_courant = chaine;	caractere_courant = chaine;
Line 1660 conversion_majuscule(unsigned char *chai	Line 1816 conversion_majuscule(unsigned char *chai

caractere_courant = chaine;	caractere_courant = chaine;
caractere_courant_converti = chaine_convertie = (unsigned char *) malloc(	caractere_courant_converti = chaine_convertie = (unsigned char *) malloc(
(longueur_chaine_plus_terminaison + 1) * sizeof(unsigned char));	((size_t) (longueur_chaine_plus_terminaison + 1))
	* sizeof(unsigned char));

if (chaine_convertie != NULL)	if (chaine_convertie != NULL)
{	{
Line 1688 conversion_majuscule(unsigned char *chai	Line 1845 conversion_majuscule(unsigned char *chai

void	void
conversion_majuscule_limitee(unsigned char *chaine_entree,	conversion_majuscule_limitee(unsigned char *chaine_entree,
unsigned char *chaine_sortie, unsigned long longueur)	unsigned char *chaine_sortie, integer8 longueur)
{	{
unsigned long i;	integer8 i;

for(i = 0; i < longueur; i++)	for(i = 0; i < longueur; i++)
{	{
Line 1734 initialisation_drapeaux(struct_processus	Line 1891 initialisation_drapeaux(struct_processus
{	{
unsigned long i;	unsigned long i;

for(i = 0; i < 31; cf(s_etat_processus, i++));	for(i = 0; i < 31; cf(s_etat_processus, (unsigned char) i++));

if ((*s_etat_processus).lancement_interactif == d_vrai)	if ((*s_etat_processus).lancement_interactif == d_vrai)
{	{
Line 1749 initialisation_drapeaux(struct_processus	Line 1906 initialisation_drapeaux(struct_processus

cf(s_etat_processus, 32); /* Impression automatique */	cf(s_etat_processus, 32); /* Impression automatique */
cf(s_etat_processus, 33); /* CR automatique (disp) */	cf(s_etat_processus, 33); /* CR automatique (disp) */
cf(s_etat_processus, 34); /* Valeur principale (intervalle de déf.) */	sf(s_etat_processus, 34); /* Évaluation des caractères de contrôle */
sf(s_etat_processus, 35); /* Evaluation symbolique des constantes */	sf(s_etat_processus, 35); /* Évaluation symbolique des constantes */
sf(s_etat_processus, 36); /* Evaluation symbolique des fonctions */	sf(s_etat_processus, 36); /* Évaluation symbolique des fonctions */
sf(s_etat_processus, 37); /* Taille de mot pour les entiers binaires */	sf(s_etat_processus, 37); /* Taille de mot pour les entiers binaires */
sf(s_etat_processus, 38); /* Taille de mot pour les entiers binaires */	sf(s_etat_processus, 38); /* Taille de mot pour les entiers binaires */
sf(s_etat_processus, 39); /* Taille de mot pour les entiers binaires */	sf(s_etat_processus, 39); /* Taille de mot pour les entiers binaires */

CVSweb interface <joel.bertrand@systella.fr>

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