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

version 1.70, 2015/01/05 13:12:29	version 1.76, 2015/01/29 09:33:41
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.19	RPL/2 (R) version 4.1.20
Copyright (C) 1989-2015 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 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 1605 recherche_instruction_suivante_recursive	Line 1489 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))
{	{
if ((*(++pointeur_caractere_courant)) == '>')	pointeur_caractere_courant++;
{
	if ((*pointeur_caractere_courant) == '>')
	{ // Cas de '>>'
drapeau_fin_objet = d_vrai;	drapeau_fin_objet = d_vrai;
	pointeur_caractere_courant++;
	break;
}	}
else	else if ((*pointeur_caractere_courant) !=
{	d_code_espace)
	{ // Tous les cas différents de '>'
erreur_analyse = d_ex_syntaxe;	erreur_analyse = d_ex_syntaxe;
	break;
}	}

pointeur_caractere_courant++;	pointeur_caractere_courant--;
break;
}	}

if ((erreur_format == d_absence_erreur) &&	if ((erreur_format == d_absence_erreur) &&
Line 1785 recherche_instruction_suivante_recursive	Line 1676 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 1843 recherche_instruction_suivante_recursive	Line 1734 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.76