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.70 and 1.100

version 1.70, 2015/01/05 13:12:29	version 1.100, 2021/03/13 12:50:37
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.19	RPL/2 (R) version 4.1.33
Copyright (C) 1989-2015 Dr. BERTRAND Joël	Copyright (C) 1989-2021 Dr. BERTRAND Joël

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

Line 20	Line 20
*/	*/


#define DEBUG_ERREURS
#include "rpl-conv.h"	#include "rpl-conv.h"


Line 282 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 291 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 312 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 371 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 388 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 415 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 472 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 490 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 504 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 517 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 535 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 551 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 567 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 589 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 599 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 618 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 632 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 647 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 661 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 676 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 686 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 701 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 715 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 730 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 740 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 757 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 770 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 787 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 797 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 814 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 827 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 840 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 1033 recherche_instruction_suivante_recursive	Line 917 recherche_instruction_suivante_recursive
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 1042 recherche_instruction_suivante_recursive	Line 930 recherche_instruction_suivante_recursive

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 1061 recherche_instruction_suivante_recursive	Line 951 recherche_instruction_suivante_recursive
}	}

case TBL:	case TBL:
	case REC:
{	{
caractere_fin = ']';	caractere_fin = ']';
break;	break;
Line 1106 recherche_instruction_suivante_recursive	Line 997 recherche_instruction_suivante_recursive
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 1605 recherche_instruction_suivante_recursive	Line 1541 recherche_instruction_suivante_recursive
pointeur_caractere_courant++;	pointeur_caractere_courant++;
}	}

if ((*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;
	}

	pointeur_caractere_courant--;
	}

	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 = 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);
	}

	(*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 (drapeau_fin_objet == d_faux)
	{
	erreur_analyse = d_ex_syntaxe;
	drapeau_fin_objet = d_vrai;
	}
	}
	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;

	while(((*pointeur_caractere_courant) != d_code_fin_chaine)
	&& (erreur_format == d_absence_erreur))
	{
	while((*pointeur_caractere_courant) == d_code_espace)
	{
	pointeur_caractere_courant++;
	}

	if ((*pointeur_caractere_courant) == ']')
{	{
if ((*(++pointeur_caractere_courant)) == '>')	if ((*(++pointeur_caractere_courant)) == '>')
{	{
Line 1629 recherche_instruction_suivante_recursive	Line 1657 recherche_instruction_suivante_recursive

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 = RPN;	(*s_etat_processus).type_en_cours = TBL;

if ((erreur =	if ((erreur =
recherche_instruction_suivante_recursive(	recherche_instruction_suivante_recursive(
Line 1667 recherche_instruction_suivante_recursive	Line 1695 recherche_instruction_suivante_recursive
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 1688 recherche_instruction_suivante_recursive	Line 1722 recherche_instruction_suivante_recursive

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 1710 recherche_instruction_suivante_recursive	Line 1744 recherche_instruction_suivante_recursive

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 =	if ((erreur =
recherche_instruction_suivante_recursive(	recherche_instruction_suivante_recursive(
Line 1755 recherche_instruction_suivante_recursive	Line 1789 recherche_instruction_suivante_recursive

if ((*(pointeur_caractere_courant - 1)) == caractere_fin)	if ((*(pointeur_caractere_courant - 1)) == caractere_fin)
{	{
// Cas des objets composites (LST, RPN, TBL)	// Cas des objets composites (LST, RPN, TBL, REC)
break;	break;
}	}
else if ((*pointeur_caractere_courant) == caractere_fin)	else if ((*pointeur_caractere_courant) == caractere_fin)
{	{
// Condition pour traiter les cas 123}	// Condition pour traiter les cas "123}"
break;	break;
}	}
}	}
Line 1785 recherche_instruction_suivante_recursive	Line 1819 recherche_instruction_suivante_recursive
default:	default:
{	{
(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
return(d_erreur);	// return(d_erreur);
}	}
}	}
}	}
Line 1815 recherche_instruction_suivante_recursive	Line 1849 recherche_instruction_suivante_recursive
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 1843 recherche_instruction_suivante_recursive	Line 1882 recherche_instruction_suivante_recursive
*/	*/

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.70
changed lines
	Added in v.1.100