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.61 and 1.72

version 1.61, 2013/04/01 15:29:33	version 1.72, 2015/01/27 14:18:05
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.14	RPL/2 (R) version 4.1.20
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2015 Dr. BERTRAND Joël

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

Line 370 typedef struct pile	Line 370 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 388 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 416 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 474 analyse_syntaxique(struct_processus *s_e
if (recherche_instruction_suivante(s_etat_processus) !=	if (recherche_instruction_suivante(s_etat_processus) !=
d_absence_erreur)	d_absence_erreur)
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

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

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

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

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

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 503 analyse_syntaxique(struct_processus *s_e	Line 506 analyse_syntaxique(struct_processus *s_e
}	}
else if (strcmp(instruction, "IFERR") == 0)	else if (strcmp(instruction, "IFERR") == 0)
{	{
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
AN_IFERR)) == NULL)	l_base_pile, AN_IFERR)) == NULL)
{	{
liberation_analyse(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 519 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 537 analyse_syntaxique(struct_processus *s_e
(test_analyse(l_base_pile, AN_CASE) == d_faux) &&	(test_analyse(l_base_pile, AN_CASE) == d_faux) &&
(test_analyse(l_base_pile, AN_IFERR) == d_faux))	(test_analyse(l_base_pile, AN_IFERR) == d_faux))
{	{
liberation_analyse(l_base_pile);	liberation_analyse(s_etat_processus, l_base_pile);

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

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

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre;	registre;
Line 588 analyse_syntaxique(struct_processus *s_e	Line 591 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 601 analyse_syntaxique(struct_processus *s_e
return(d_erreur);	return(d_erreur);
}	}

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

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

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

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

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

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

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

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

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

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

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

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

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

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 756 analyse_syntaxique(struct_processus *s_e	Line 759 analyse_syntaxique(struct_processus *s_e
}	}
else if (strcmp(instruction, "START") == 0)	else if (strcmp(instruction, "START") == 0)
{	{
if ((l_nouvelle_base_pile = empilement_analyse(l_base_pile,	if ((l_nouvelle_base_pile = empilement_analyse(s_etat_processus,
AN_START)) == NULL)	l_base_pile, AN_START)) == NULL)
{	{
liberation_analyse(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 772 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 789 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 799 analyse_syntaxique(struct_processus *s_e
return(d_erreur);	return(d_erreur);
}	}

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

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

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

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

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

(*s_etat_processus).autorisation_empilement_programme = registre;	(*s_etat_processus).autorisation_empilement_programme = registre;
(*s_etat_processus).erreur_compilation = d_ec_source_incoherent;	(*s_etat_processus).erreur_compilation = d_ec_source_incoherent;
Line 839 analyse_syntaxique(struct_processus *s_e	Line 842 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 892 swap(void variable_1, void variable_2,
logical1	logical1
recherche_instruction_suivante(struct_processus *s_etat_processus)	recherche_instruction_suivante(struct_processus *s_etat_processus)
{	{
	return(recherche_instruction_suivante_recursive(s_etat_processus, 0));
	}

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

logical1 drapeau_fin_objet;	logical1 drapeau_fin_objet;
logical1 erreur;	logical1 erreur;

Line 1024 recherche_instruction_suivante(struct_pr	Line 908 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 985 recherche_instruction_suivante(struct_pr
while(((*pointeur_caractere_courant) != d_code_espace) &&	while(((*pointeur_caractere_courant) != d_code_espace) &&
((*pointeur_caractere_courant) != d_code_fin_chaine) &&	((*pointeur_caractere_courant) != d_code_fin_chaine) &&
(drapeau_fin_objet == d_faux) &&	(drapeau_fin_objet == d_faux) &&
(erreur_analyse == d_ex) &&	(erreur_analyse == d_ex) && (erreur_format == d_ex))
(erreur_format == d_ex))
{	{
switch(*pointeur_caractere_courant++)	switch(*pointeur_caractere_courant++)
{	{
Line 1294 recherche_instruction_suivante(struct_pr	Line 1204 recherche_instruction_suivante(struct_pr
pointeur_caractere_courant++;	pointeur_caractere_courant++;

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

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

while((niveau != 0) && ((*pointeur_caractere_courant) !=	while((niveau != 0) && ((*pointeur_caractere_courant) !=
d_code_fin_chaine))	d_code_fin_chaine))
Line 1427 recherche_instruction_suivante(struct_pr	Line 1337 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 1468 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)
{	{
if ((*s_etat_processus).instruction_courante	if ((*(++pointeur_caractere_courant)) == '>')
!= NULL)
{	{
free((*s_etat_processus).instruction_courante);	drapeau_fin_objet = d_vrai;
	}
	else
	{
	erreur_analyse = d_ex_syntaxe;
}	}

return(d_erreur);	pointeur_caractere_courant++;
	break;
}	}

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;

free((*s_etat_processus).instruction_courante);	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) == '[')	else if ((*pointeur_caractere_courant) == '[')
{ // Cas <[ ]>	{ // Cas <[ ]>
Line 1713 recherche_instruction_suivante(struct_pr	Line 1582 recherche_instruction_suivante(struct_pr
pointeur_caractere_courant	pointeur_caractere_courant
- (*s_etat_processus).definitions_chainees;	- (*s_etat_processus).definitions_chainees;

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

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

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

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

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

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

pointeur_fin_instruction = pointeur_caractere_courant;	pointeur_fin_instruction = pointeur_caractere_courant;

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

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

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

(s_etat_processus).instruction_courante = (unsigned char )	(s_etat_processus).instruction_courante = (unsigned char )
malloc((((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 1788 recherche_instruction_suivante(struct_pr	Line 1704 recherche_instruction_suivante(struct_pr

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

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

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.61
changed lines
	Added in v.1.72