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.72

version 1.19, 2010/08/26 19:07:35	version 1.72, 2015/01/27 14:18:05
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.19	RPL/2 (R) version 4.1.20
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2015 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 358 compilation(struct_processus *s_etat_pro	Line 358 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;	typedef struct pile
unsigned char registre;	{
	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;

typedef struct pile	if ((nouvelle_base = malloc(sizeof(struct_pile_analyse))) == NULL)
{	{
enum t_condition condition;	return(NULL);
struct pile *suivant;	}
} struct_pile_analyse;

struct_pile_analyse *l_base_pile;	(*nouvelle_base).suivant = ancienne_base;
struct_pile_analyse *l_nouvelle_base_pile;	(*nouvelle_base).condition = condition;

inline struct_pile_analyse *	return(nouvelle_base);
empilement_analyse(struct_pile_analyse *ancienne_base,	}
enum t_condition condition)
{
struct_pile_analyse *nouvelle_base;

if ((nouvelle_base = malloc(sizeof(struct_pile_analyse))) == NULL)
{
return(NULL);
}

(*nouvelle_base).suivant = ancienne_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 474 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 492 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 506 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 537 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 553 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 569 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 588 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 601 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 620 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 634 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 649 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 663 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 678 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 688 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 703 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 717 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 732 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 742 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 759 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(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(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 756 analyse_syntaxique(struct_processus *s_e	Line 786 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 799 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 816 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 829 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 855 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 892 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;

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;

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

	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 985 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 1204 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 1329 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 '}' :
{
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;
niveau_annexe++;

if (niveau_annexe > 2)	if (recherche_instruction_suivante_recursive(
{	s_etat_processus, recursivite + 1) == d_erreur)
erreur_analyse = d_ex_syntaxe;	{
}	(*s_etat_processus).type_en_cours =
	registre_type_en_cours;
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 1461 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) == '>')
{	{
niveau--;	if ((*(++pointeur_caractere_courant)) == '>')
	{
	drapeau_fin_objet = d_vrai;
	}
	else
	{
	erreur_analyse = d_ex_syntaxe;
	}

pointeur_caractere_courant++;	pointeur_caractere_courant++;
	break;
}	}
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 1582 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 1626 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 1628 recherche_instruction_suivante(struct_pr	Line 1704 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 1717 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 1736 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 1765 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 1811 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 1826 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.72