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.60 and 1.86

version 1.60, 2013/03/24 22:06:09	version 1.86, 2016/09/27 15:29:32
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.13	RPL/2 (R) version 4.1.26
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2016 Dr. BERTRAND Joël

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

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 370 typedef struct pile	Line 380 typedef struct pile
} struct_pile_analyse;	} struct_pile_analyse;

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

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

Line 414 test_analyse(struct_pile_analyse *l_base	Line 426 test_analyse(struct_pile_analyse *l_base
}	}

static inline void	static inline void
liberation_analyse(struct_pile_analyse *l_base_pile)	liberation_analyse(struct_processus *s_etat_processus,
	struct_pile_analyse *l_base_pile)
{	{
struct_pile_analyse *l_nouvelle_base_pile;	struct_pile_analyse *l_nouvelle_base_pile;

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(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 516 analyse_syntaxique(struct_processus *s_e	Line 529 analyse_syntaxique(struct_processus *s_e
}	}
else if (strcmp(instruction, "CRITICAL") == 0)	else if (strcmp(instruction, "CRITICAL") == 0)
{	{
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
AN_CRITICAL)) == NULL)	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 534 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 550 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 566 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 588 analyse_syntaxique(struct_processus *s_e	Line 601 analyse_syntaxique(struct_processus *s_e
(test_analyse(l_base_pile, AN_CRITICAL) == 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 598 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 617 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 631 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 646 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 660 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 675 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 685 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 700 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 714 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 729 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 739 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 756 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;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 769 analyse_syntaxique(struct_processus *s_e	Line 782 analyse_syntaxique(struct_processus *s_e
}	}
else if (strcmp(instruction, "FORALL") == 0)	else if (strcmp(instruction, "FORALL") == 0)
{	{
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
AN_FORALL)) == NULL)	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 786 analyse_syntaxique(struct_processus *s_e	Line 799 analyse_syntaxique(struct_processus *s_e
(test_analyse(l_base_pile, AN_FORALL) == 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 796 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 813 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 826 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 839 analyse_syntaxique(struct_processus *s_e	Line 852 analyse_syntaxique(struct_processus *s_e

/*	/*
================================================================================	================================================================================
Procédure de d'analyse syntaxique du source pour readline
================================================================================
Entrées :
--------------------------------------------------------------------------------
Sorties :
- rl_done à 0 ou à 1.
--------------------------------------------------------------------------------
Effets de bord :
================================================================================
*/

static char *ligne = NULL;
static unsigned int niveau = 0;

int
readline_analyse_syntaxique(int count, int key)
{
char prompt[] = "+ %03d> ";
char prompt2[8];
char *registre;

struct_processus s_etat_processus;

if ((*rl_line_buffer) == d_code_fin_chaine)
{
if (ligne == NULL)
{
rl_done = 1;
}
else
{
rl_done = 0;
}
}
else
{
if (ligne == NULL)
{
if ((ligne = malloc((strlen(rl_line_buffer) + 1)
* sizeof(char))) == NULL)
{
rl_done = 1;
return(0);
}

strcpy(ligne, rl_line_buffer);
}
else
{
registre = ligne;

if ((ligne = malloc((strlen(registre)
+ strlen(rl_line_buffer) + 2) * sizeof(char))) == NULL)
{
rl_done = 1;
return(0);
}

sprintf(ligne, "%s %s", registre, rl_line_buffer);
}

rl_replace_line("", 1);

s_etat_processus.definitions_chainees = ligne;
s_etat_processus.debug = d_faux;
s_etat_processus.erreur_systeme = d_es;
s_etat_processus.erreur_execution = d_ex;

if (analyse_syntaxique(&s_etat_processus) == d_absence_erreur)
{
rl_done = 1;
}
else
{
if (s_etat_processus.erreur_systeme != d_es)
{
rl_done = 1;
}
else
{
rl_done = 0;
rl_crlf();

sprintf(prompt2, prompt, ++niveau);

rl_expand_prompt(prompt2);
rl_on_new_line();
}
}
}

if (rl_done != 0)
{
uprintf("\n");

if (ligne != NULL)
{
rl_replace_line(ligne, 1);

free(ligne);
ligne = NULL;
}

niveau = 0;
}

return(0);
}

int
readline_effacement(int count, int key)
{
rl_done = 0;
rl_replace_line("", 1);

free(ligne);
ligne = NULL;
niveau = 0;

uprintf("^G\n");
rl_expand_prompt("RPL/2> ");
rl_on_new_line();
return(0);
}


/*
================================================================================
Routine d'échange de deux variables	Routine d'échange de deux variables
================================================================================	================================================================================
Entrées :	Entrées :
Line 1017 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;

Line 1024 recherche_instruction_suivante(struct_pr	Line 918 recherche_instruction_suivante(struct_pr
int erreur_format;	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 1074 recherche_instruction_suivante(struct_pr	Line 995 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++)
{	{
Line 1294 recherche_instruction_suivante(struct_pr	Line 1214 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 1418 recherche_instruction_suivante(struct_pr	Line 1339 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))
Line 1427 recherche_instruction_suivante(struct_pr	Line 1347 recherche_instruction_suivante(struct_pr
pointeur_caractere_courant	pointeur_caractere_courant
- (*s_etat_processus).definitions_chainees;	- (*s_etat_processus).definitions_chainees;

if (recherche_instruction_suivante(s_etat_processus)	registre_type_en_cours = (*s_etat_processus).type_en_cours;
== d_erreur)	(*s_etat_processus).type_en_cours = LST;

	if (recherche_instruction_suivante_recursive(
	s_etat_processus, recursivite + 1) == d_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).instruction_courante);	free((*s_etat_processus).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 =	pointeur_caractere_courant =
(*s_etat_processus).definitions_chainees +	(*s_etat_processus).definitions_chainees +
(*s_etat_processus).position_courante;	(*s_etat_processus).position_courante;

if (strcmp((*s_etat_processus).instruction_courante, "{")	if (strcmp((*s_etat_processus).instruction_courante, "}")
== 0)	== 0)
{	{
if (niveau_annexe == 0)
{
niveau++;
}
else
{
erreur_analyse = d_ex_syntaxe;
}
}
else if (strcmp((*s_etat_processus).instruction_courante,
"}") == 0)
{
if (niveau_annexe == 0)
{
niveau--;
}
else
{
erreur_analyse = d_ex_syntaxe;
}
}
else if (strcmp((*s_etat_processus).instruction_courante,
"<[") == 0)
{
niveau++;
}
else if (strcmp((*s_etat_processus).instruction_courante,
"]>") == 0)
{
niveau--;	niveau--;
}	}
else if (strcmp((*s_etat_processus).instruction_courante,
"[") == 0)
{
niveau_annexe++;

if (niveau_annexe > 2)
{
erreur_analyse = d_ex_syntaxe;
}
}
else if (strcmp((*s_etat_processus).instruction_courante,
"[[") == 0)
{
niveau_annexe += 2;

if (niveau_annexe > 2)
{
erreur_analyse = d_ex_syntaxe;
}
}
else if (strcmp((*s_etat_processus).instruction_courante,
"]") == 0)
{
niveau_annexe--;

if (niveau_annexe < 0)
{
erreur_analyse = d_ex_syntaxe;
}
}
else if (strcmp((*s_etat_processus).instruction_courante,
"]]") == 0)
{
niveau_annexe -= 2;

if (niveau_annexe < 0)
{
erreur_analyse = d_ex_syntaxe;
}
}
else if ((*s_etat_processus).instruction_courante[0] == '"')
{
if (niveau_annexe != 0)
{
erreur_analyse = d_ex_syntaxe;
}
}

free((*s_etat_processus).instruction_courante);	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 1626 recherche_instruction_suivante(struct_pr	Line 1478 recherche_instruction_suivante(struct_pr
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))
{	{
(*s_etat_processus).position_courante =	while((*pointeur_caractere_courant) == d_code_espace)
pointeur_caractere_courant	{
- (*s_etat_processus).definitions_chainees;	pointeur_caractere_courant++;
	}

if (recherche_instruction_suivante(s_etat_processus)	if (((*pointeur_caractere_courant) == '>') &&
== d_erreur)	((*(pointeur_caractere_courant - 1)) ==
	d_code_espace))
{	{
if ((*s_etat_processus).instruction_courante	pointeur_caractere_courant++;
!= NULL)
{	if ((*pointeur_caractere_courant) == '>')
free((*s_etat_processus).instruction_courante);	{ // 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;
}	}

return(d_erreur);	pointeur_caractere_courant--;
}	}

pointeur_caractere_courant =	if ((erreur_format == d_absence_erreur) &&
(*s_etat_processus).definitions_chainees +	(drapeau_fin_objet == d_faux))
(*s_etat_processus).position_courante;

if (strcmp((*s_etat_processus).instruction_courante,
"<<") == 0)
{
niveau++;
}
else if (strcmp((*s_etat_processus)
.instruction_courante, ">>") == 0)
{	{
niveau--;	(*s_etat_processus).position_courante =
}	pointeur_caractere_courant
	- (*s_etat_processus).definitions_chainees;

	registre_type_en_cours = (*s_etat_processus)
	.type_en_cours;
	(*s_etat_processus).type_en_cours = RPN;

	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
	!= NULL)
	{
	free((*s_etat_processus)
	.instruction_courante);
	(*s_etat_processus).instruction_courante
	= NULL;
	}

	return(d_erreur);
	}

free((*s_etat_processus).instruction_courante);	(*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 <[ ]>	{ // Cas <[ ]>
Line 1713 recherche_instruction_suivante(struct_pr	Line 1603 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 1744 recherche_instruction_suivante(struct_pr	Line 1647 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((((size_t) (pointeur_fin_instruction	malloc((((size_t) (pointeur_fin_instruction
- pointeur_debut_instruction)) + 1) * sizeof(unsigned char));	- pointeur_debut_instruction)) + 1) * sizeof(unsigned char));
Line 1773 recherche_instruction_suivante(struct_pr	Line 1710 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 1788 recherche_instruction_suivante(struct_pr	Line 1730 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 1801 recherche_instruction_suivante(struct_pr	Line 1743 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;

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.60
changed lines
	Added in v.1.86