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.68 and 1.99

version 1.68, 2014/07/26 09:58:02	version 1.99, 2020/01/10 11:15:41
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.19	RPL/2 (R) version 4.1.32
Copyright (C) 1989-2014 Dr. BERTRAND Joël	Copyright (C) 1989-2020 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;	enum t_type registre_type_en_cours;

logical1 drapeau_fin_objet;	logical1 drapeau_fin_objet;
Line 1025 recherche_instruction_suivante(struct_pr	Line 917 recherche_instruction_suivante(struct_pr
int erreur_analyse;	int erreur_analyse;
int erreur_format;	int erreur_format;

	integer8 nombre_caracteres;
	integer8 (__type_parse)(struct_processus , void **);


unsigned char base_binaire;	unsigned char base_binaire;
unsigned char caractere_fin;	unsigned char caractere_fin;
unsigned char *pointeur_caractere_courant;	unsigned char *pointeur_caractere_courant;
Line 1034 recherche_instruction_suivante(struct_pr	Line 930 recherche_instruction_suivante(struct_pr

signed long niveau;	signed long niveau;

	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;
Line 1053 recherche_instruction_suivante(struct_pr	Line 951 recherche_instruction_suivante(struct_pr
}	}

case TBL:	case TBL:
	case REC:
{	{
caractere_fin = ']';	caractere_fin = ']';
break;	break;
Line 1098 recherche_instruction_suivante(struct_pr	Line 997 recherche_instruction_suivante(struct_pr
return(erreur);	return(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;
	(*s_etat_processus).position_courante = pointeur_caractere_courant
	- (*s_etat_processus).definitions_chainees;

	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, NULL)) != 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).definitions_chainees +
	(*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;
	}

pointeur_debut_instruction = pointeur_caractere_courant;	pointeur_debut_instruction = pointeur_caractere_courant;

while(((*pointeur_caractere_courant) != d_code_espace) &&	while(((*pointeur_caractere_courant) != d_code_espace) &&
Line 1458 recherche_instruction_suivante(struct_pr	Line 1402 recherche_instruction_suivante(struct_pr
registre_type_en_cours = (*s_etat_processus).type_en_cours;	registre_type_en_cours = (*s_etat_processus).type_en_cours;
(*s_etat_processus).type_en_cours = LST;	(*s_etat_processus).type_en_cours = LST;

if (recherche_instruction_suivante(s_etat_processus)	if (recherche_instruction_suivante_recursive(
== d_erreur)	s_etat_processus, recursivite + 1) == d_erreur)
{	{
(*s_etat_processus).type_en_cours =	(*s_etat_processus).type_en_cours =
registre_type_en_cours;	registre_type_en_cours;
Line 1474 recherche_instruction_suivante(struct_pr	Line 1418 recherche_instruction_suivante(struct_pr
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;
Line 1585 recherche_instruction_suivante(struct_pr	Line 1530 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 (((*pointeur_caractere_courant) == '>') &&
	((*(pointeur_caractere_courant - 1)) ==
	d_code_espace))
	{
	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;
	}

registre_type_en_cours = (*s_etat_processus)	pointeur_caractere_courant--;
.type_en_cours;	}
(*s_etat_processus).type_en_cours = RPN;

if (recherche_instruction_suivante(s_etat_processus)	if ((erreur_format == d_absence_erreur) &&
== d_erreur)	(drapeau_fin_objet == d_faux))
{	{
(*s_etat_processus).type_en_cours =	(*s_etat_processus).position_courante =
registre_type_en_cours;	pointeur_caractere_courant
	- (*s_etat_processus).definitions_chainees;

if ((*s_etat_processus).instruction_courante	registre_type_en_cours = (*s_etat_processus)
!= NULL)	.type_en_cours;
	(*s_etat_processus).type_en_cours = RPN;

	if ((erreur =
	recherche_instruction_suivante_recursive(
	s_etat_processus, recursivite + 1))
	!= d_absence_erreur)
{	{
free((*s_etat_processus).instruction_courante);	(*s_etat_processus).type_en_cours =
(*s_etat_processus).instruction_courante = NULL;	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);
}	}

return(d_erreur);	(*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);
}	}
	}

(*s_etat_processus).type_en_cours =	if (drapeau_fin_objet == d_faux)
registre_type_en_cours;	{
pointeur_caractere_courant =	erreur_analyse = d_ex_syntaxe;
(*s_etat_processus).definitions_chainees +	drapeau_fin_objet = d_vrai;
(*s_etat_processus).position_courante;	}
	}
	else if ((*pointeur_caractere_courant) == '[')
	{ // Cas <[ ]>
	if (pointeur_debut_instruction !=
	(pointeur_caractere_courant - 1))
	{
	erreur_format = d_ex_syntaxe;
	}

	pointeur_caractere_courant++;
	drapeau_fin_objet = d_faux;

if (strcmp((*s_etat_processus).instruction_courante,	while(((*pointeur_caractere_courant) != d_code_fin_chaine)
"<<") == 0)	&& (erreur_format == d_absence_erreur))
	{
	while((*pointeur_caractere_courant) == d_code_espace)
{	{
niveau++;	pointeur_caractere_courant++;
}	}
else if (strcmp((*s_etat_processus)
.instruction_courante, ">>") == 0)	if ((*pointeur_caractere_courant) == ']')
{	{
niveau--;	if ((*(++pointeur_caractere_courant)) == '>')
	{
	drapeau_fin_objet = d_vrai;
	}
	else
	{
	erreur_analyse = d_ex_syntaxe;
	}

	pointeur_caractere_courant++;
	break;
}	}

free((*s_etat_processus).instruction_courante);	if ((erreur_format == d_absence_erreur) &&
	(drapeau_fin_objet == d_faux))
	{
	(*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 = 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
	!= NULL)
	{
	free((*s_etat_processus)
	.instruction_courante);
	(*s_etat_processus).instruction_courante
	= NULL;
	}

	return(d_erreur);
	}

	(*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) == '[')
{ // Cas <[ ]>	break;
	}

	case '\|' :
	{
	if ((*pointeur_caractere_courant) == '[')
	{ // Cas \|[ ]\|
if (pointeur_debut_instruction !=	if (pointeur_debut_instruction !=
(pointeur_caractere_courant - 1))	(pointeur_caractere_courant - 1))
{	{
Line 1662 recherche_instruction_suivante(struct_pr	Line 1722 recherche_instruction_suivante(struct_pr

if ((*pointeur_caractere_courant) == ']')	if ((*pointeur_caractere_courant) == ']')
{	{
if ((*(++pointeur_caractere_courant)) == '>')	if ((*(++pointeur_caractere_courant)) == '\|')
{	{
drapeau_fin_objet = d_vrai;	drapeau_fin_objet = d_vrai;
}	}
Line 1684 recherche_instruction_suivante(struct_pr	Line 1744 recherche_instruction_suivante(struct_pr

registre_type_en_cours = (*s_etat_processus)	registre_type_en_cours = (*s_etat_processus)
.type_en_cours;	.type_en_cours;
(*s_etat_processus).type_en_cours = TBL;	(*s_etat_processus).type_en_cours = REC;

if ((erreur = recherche_instruction_suivante(	if ((erreur =
s_etat_processus)) != d_absence_erreur)	recherche_instruction_suivante_recursive(
	s_etat_processus, recursivite + 1))
	!= d_absence_erreur)
{	{
(*s_etat_processus).type_en_cours =	(*s_etat_processus).type_en_cours =
registre_type_en_cours;	registre_type_en_cours;
Line 1725 recherche_instruction_suivante(struct_pr	Line 1787 recherche_instruction_suivante(struct_pr
}	}
}	}

if ((*pointeur_caractere_courant) == caractere_fin)	if ((*(pointeur_caractere_courant - 1)) == caractere_fin)
	{
	// Cas des objets composites (LST, RPN, TBL, REC)
	break;
	}
	else if ((*pointeur_caractere_courant) == caractere_fin)
{	{
	// Condition pour traiter les cas "123}"
break;	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 1758 recherche_instruction_suivante(struct_pr	Line 1849 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
{	{
((s_etat_processus).instruction_courante) = d_code_fin_chaine;	((s_etat_processus).instruction_courante) = d_code_fin_chaine;
}	}

uprintf("%c %s\n", caractere_fin, (*s_etat_processus).instruction_courante);
(*s_etat_processus).position_courante = pointeur_fin_instruction	(*s_etat_processus).position_courante = pointeur_fin_instruction
- (*s_etat_processus).definitions_chainees;	- (*s_etat_processus).definitions_chainees;

Line 1774 uprintf("%c %s\n", caractere_fin, (*s_et	Line 1869 uprintf("%c %s\n", caractere_fin, (*s_et

/*	/*
================================================================================	================================================================================
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 1787 uprintf("%c %s\n", caractere_fin, (*s_et	Line 1882 uprintf("%c %s\n", caractere_fin, (*s_et
*/	*/

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.68
changed lines
	Added in v.1.99