rpl/src/types.c - diff

Return to types.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/types.c between versions 1.27.2.1 and 1.96

version 1.27.2.1, 2011/04/11 13:02:29	version 1.96, 2019/10/31 15:40:25
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.22	RPL/2 (R) version 4.1.32
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2019 Dr. BERTRAND Joël

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

Line 38	Line 38
void	void
recherche_type(struct_processus *s_etat_processus)	recherche_type(struct_processus *s_etat_processus)
{	{
int nombre_elements_convertis;	integer8 i;
	integer8 j;
	integer8 niveau;
	integer8 niveau_maximal;
	integer8 nombre_colonnes;
	integer8 nombre_egalites;
	integer8 nombre_elements;
	integer8 nombre_elements_convertis;
	integer8 nombre_exposants;
	integer8 nombre_lignes;
	integer8 nombre_lignes_a_supprimer;
	integer8 nombre_points;
	integer8 nombre_virgules;
	integer8 position_courante;
	integer8 profondeur_finale;
	integer8 profondeur_initiale;
	integer8 sauvegarde_niveau_courant;
	integer8 sauvegarde_longueur_definitions_chainees;
	integer8 (__type_new)(struct_processus , void **);

struct_liste_chainee *l_base_liste_fonctions;	struct_liste_chainee *l_base_liste_fonctions;
struct_liste_chainee *l_base_liste_decomposition;	struct_liste_chainee *l_base_liste_decomposition;
Line 49 recherche_type(struct_processus *s_etat_	Line 67 recherche_type(struct_processus *s_etat_
struct_liste_pile_systeme *s_sauvegarde_pile;	struct_liste_pile_systeme *s_sauvegarde_pile;

struct_objet *s_objet;	struct_objet *s_objet;
	struct_objet *s_objet_registre;
struct_objet *s_sous_objet;	struct_objet *s_sous_objet;

logical1 drapeau_chaine;	logical1 drapeau_chaine;
Line 59 recherche_type(struct_processus *s_etat_	Line 78 recherche_type(struct_processus *s_etat_
logical1 drapeau_valeur_reelle;	logical1 drapeau_valeur_reelle;
logical1 erreur;	logical1 erreur;
logical1 erreur_lecture_binaire;	logical1 erreur_lecture_binaire;
	logical1 tri_acheve;

logical8 ancienne_valeur_base;	logical8 ancienne_valeur_base;
logical8 valeur_base;	logical8 valeur_base;
Line 79 recherche_type(struct_processus *s_etat_	Line 99 recherche_type(struct_processus *s_etat_
unsigned char registre_test;	unsigned char registre_test;
unsigned char registre_test_bis;	unsigned char registre_test_bis;
unsigned char *tampon;	unsigned char *tampon;
	unsigned char variable_implicite;
unsigned long i;
unsigned long j;
unsigned long niveau;
unsigned long niveau_maximal;
unsigned long nombre_colonnes;
unsigned long nombre_egalites;
unsigned long nombre_elements;
unsigned long nombre_exposants;
unsigned long nombre_lignes;
unsigned long nombre_lignes_a_supprimer;
unsigned long nombre_points;
unsigned long nombre_virgules;
unsigned long position_courante;
unsigned long profondeur_finale;
unsigned long profondeur_initiale;
unsigned long sauvegarde_niveau_courant;
unsigned long sauvegarde_longueur_definitions_chainees;

void *element;	void *element;

s_objet = (struct_objet *) malloc(sizeof(struct_objet));	if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
element = NULL;
nombre_egalites = 0;
i = 0;

if (s_objet == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

initialisation_objet(s_objet);	element = NULL;
	nombre_egalites = 0;
	i = 0;

registre_test = (*s_etat_processus).test_instruction;	registre_test = (*s_etat_processus).test_instruction;
registre_instruction_valide = (*s_etat_processus).instruction_valide;	registre_instruction_valide = (*s_etat_processus).instruction_valide;
registre_interruption = (*s_etat_processus).traitement_interruptible;	registre_interruption = (*s_etat_processus).traitement_interruptible;
Line 144 recherche_type(struct_processus *s_etat_	Line 145 recherche_type(struct_processus *s_etat_
*/	*/

if (((((struct_fonction ) element)).nom_fonction =	if (((((struct_fonction ) element)).nom_fonction =
conversion_majuscule((*s_etat_processus)	conversion_majuscule(s_etat_processus,
.instruction_courante)) == NULL)	(*s_etat_processus).instruction_courante)) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 192 recherche_type(struct_processus *s_etat_	Line 193 recherche_type(struct_processus *s_etat_
}	}
else	else
{	{
if ((instruction_majuscule = conversion_majuscule(	if ((instruction_majuscule = conversion_majuscule(s_etat_processus,
(*s_etat_processus).instruction_courante)) == NULL)	(*s_etat_processus).instruction_courante)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 207 recherche_type(struct_processus *s_etat_	Line 208 recherche_type(struct_processus *s_etat_
(*s_etat_processus).test_instruction = 'N';	(*s_etat_processus).test_instruction = 'N';
analyse(s_etat_processus, NULL);	analyse(s_etat_processus, NULL);
(*s_etat_processus).test_instruction = registre_test_bis;	(*s_etat_processus).test_instruction = registre_test_bis;
free(s_objet);	liberation(s_etat_processus, s_objet);
}	}
else	else
{	{
Line 261 recherche_type(struct_processus *s_etat_	Line 262 recherche_type(struct_processus *s_etat_

(*s_etat_processus).instruction_valide = registre_instruction_valide;	(*s_etat_processus).instruction_valide = registre_instruction_valide;

	/*
	--------------------------------------------------------------------------------
	Types externes
	--------------------------------------------------------------------------------
	*/

	l_element_courant = (*s_etat_processus).s_bibliotheques;

	while(l_element_courant != NULL)
	{
	if ((__type_new = dlsym((((struct_bibliotheque )
	(*l_element_courant).donnee)).descripteur, "__type_new"))
	!= NULL)
	{
	if (((*s_objet).extension_type = __type_new(s_etat_processus,
	&element)) != 0)
	{
	// Le type peut être converti.

	(*s_objet).objet = element;
	(*s_objet).type = EXT;
	(*s_objet).descripteur_bibliotheque =
	(((struct_bibliotheque )
	(*l_element_courant).donnee)).descripteur;

	if (empilement(s_etat_processus,
	&((*s_etat_processus).l_base_pile), s_objet)
	== d_erreur)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	return;
	}

	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	return;
	}
	}

	l_element_courant = (*l_element_courant).suivant;
	}

	/*
	--------------------------------------------------------------------------------
	Types internes
	--------------------------------------------------------------------------------
	*/

switch(((s_etat_processus).instruction_courante))	switch(((s_etat_processus).instruction_courante))
{	{

Line 272 recherche_type(struct_processus *s_etat_	Line 324 recherche_type(struct_processus *s_etat_

case '(' :	case '(' :
{	{
(*s_objet).type = CPL;

element = (void ) ((struct_complexe16 ) malloc(	element = (void ) ((struct_complexe16 ) malloc(
sizeof(struct_complexe16)));	sizeof(struct_complexe16)));

Line 291 recherche_type(struct_processus *s_etat_	Line 341 recherche_type(struct_processus *s_etat_
sauvegarde_longueur_definitions_chainees =	sauvegarde_longueur_definitions_chainees =
(*s_etat_processus).longueur_definitions_chainees;	(*s_etat_processus).longueur_definitions_chainees;

tampon = (unsigned char *) malloc(	tampon = (unsigned char *) malloc(((size_t)
(((*s_etat_processus).longueur_definitions_chainees	(((*s_etat_processus).longueur_definitions_chainees
= strlen((*s_etat_processus).instruction_courante)	= (integer8) strlen((*s_etat_processus)
+ 4) + 1) * sizeof(unsigned char));	.instruction_courante) + 4) + 1)) * sizeof(unsigned char));

if (tampon == NULL)	if (tampon == NULL)
{	{
Line 396 recherche_type(struct_processus *s_etat_	Line 446 recherche_type(struct_processus *s_etat_
sauvegarde_longueur_definitions_chainees;	sauvegarde_longueur_definitions_chainees;

free(element);	free(element);
free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
registre_interruption;	registre_interruption;
Line 431 recherche_type(struct_processus *s_etat_	Line 481 recherche_type(struct_processus *s_etat_
{	{
(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;

free(s_objet);	liberation(s_etat_processus, s_objet);
free(element);	free(element);

for(i = 0; i < (unsigned long) nombre_elements_convertis; i++)	for(i = 0; i < nombre_elements_convertis; i++)
{	{
if (depilement(s_etat_processus, &((*s_etat_processus)	if (depilement(s_etat_processus, &((*s_etat_processus)
.l_base_pile), &s_sous_objet) == d_erreur)	.l_base_pile), &s_sous_objet) == d_erreur)
Line 460 recherche_type(struct_processus *s_etat_	Line 510 recherche_type(struct_processus *s_etat_
if ((*s_sous_objet).type == INT)	if ((*s_sous_objet).type == INT)
{	{
(((struct_complexe16 ) element)).partie_imaginaire =	(((struct_complexe16 ) element)).partie_imaginaire =
(((integer8 ) (*s_sous_objet).objet));	(real8) (((integer8 ) (*s_sous_objet).objet));
}	}
else if ((*s_sous_objet).type == REL)	else if ((*s_sous_objet).type == REL)
{	{
Line 472 recherche_type(struct_processus *s_etat_	Line 522 recherche_type(struct_processus *s_etat_
(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;

free(element);	free(element);
free(s_objet);	liberation(s_etat_processus, s_objet);

liberation(s_etat_processus, s_sous_objet);	liberation(s_etat_processus, s_sous_objet);

Line 490 recherche_type(struct_processus *s_etat_	Line 540 recherche_type(struct_processus *s_etat_
if ((*s_sous_objet).type == INT)	if ((*s_sous_objet).type == INT)
{	{
(((struct_complexe16 ) element)).partie_reelle =	(((struct_complexe16 ) element)).partie_reelle =
(((integer8 ) (*s_sous_objet).objet));	(real8) (((integer8 )
	(*s_sous_objet).objet));
}	}
else if ((*s_sous_objet).type == REL)	else if ((*s_sous_objet).type == REL)
{	{
Line 502 recherche_type(struct_processus *s_etat_	Line 553 recherche_type(struct_processus *s_etat_
(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;

free(element);	free(element);
free(s_objet);	liberation(s_etat_processus, s_objet);

liberation(s_etat_processus, s_sous_objet);	liberation(s_etat_processus, s_sous_objet);

Line 516 recherche_type(struct_processus *s_etat_	Line 567 recherche_type(struct_processus *s_etat_
}	}
}	}

	(*s_objet).type = CPL;
break;	break;
}	}

Line 527 recherche_type(struct_processus *s_etat_	Line 579 recherche_type(struct_processus *s_etat_

case '#' :	case '#' :
{	{
(*s_objet).type = BIN;

element = (void ) ((logical8 ) malloc(	element = (void ) ((logical8 ) malloc(
sizeof(logical8)));	sizeof(logical8)));

Line 547 recherche_type(struct_processus *s_etat_	Line 597 recherche_type(struct_processus *s_etat_
{	{
case 'b' :	case 'b' :
{	{
i = strlen((*s_etat_processus).instruction_courante) - 2;	i = ((integer8) strlen((*s_etat_processus)
	.instruction_courante)) - 2;
valeur_base = 1;	valeur_base = 1;

(((logical8 ) element)) = 0;	(((logical8 ) element)) = 0;
Line 579 recherche_type(struct_processus *s_etat_	Line 630 recherche_type(struct_processus *s_etat_
if (i != 0)	if (i != 0)
{	{
free(element);	free(element);
free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_syntaxe;	d_ex_syntaxe;
Line 621 recherche_type(struct_processus *s_etat_	Line 672 recherche_type(struct_processus *s_etat_

case 'o' :	case 'o' :
{	{
i = strlen((*s_etat_processus).instruction_courante) - 2;	i = ((integer8) strlen((*s_etat_processus)
	.instruction_courante)) - 2;
valeur_base = 1;	valeur_base = 1;

(((logical8 ) element)) = 0;	(((logical8 ) element)) = 0;
Line 683 recherche_type(struct_processus *s_etat_	Line 735 recherche_type(struct_processus *s_etat_
if (i != 0)	if (i != 0)
{	{
free(element);	free(element);
free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_syntaxe;	d_ex_syntaxe;
Line 725 recherche_type(struct_processus *s_etat_	Line 777 recherche_type(struct_processus *s_etat_

case 'd' :	case 'd' :
{	{
i = strlen((*s_etat_processus).instruction_courante) - 2;	i = ((integer8) strlen((*s_etat_processus)
	.instruction_courante)) - 2;
valeur_base = 1;	valeur_base = 1;

(((logical8 ) element)) = 0;	(((logical8 ) element)) = 0;
Line 797 recherche_type(struct_processus *s_etat_	Line 850 recherche_type(struct_processus *s_etat_
if (i != 0)	if (i != 0)
{	{
free(element);	free(element);
free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_syntaxe;	d_ex_syntaxe;
Line 839 recherche_type(struct_processus *s_etat_	Line 892 recherche_type(struct_processus *s_etat_

case 'h' :	case 'h' :
{	{
i = strlen((*s_etat_processus).instruction_courante) - 2;	i = ((integer8) strlen((*s_etat_processus)
	.instruction_courante)) - 2;
valeur_base = 1;	valeur_base = 1;

(((logical8 ) element)) = 0;	(((logical8 ) element)) = 0;
Line 941 recherche_type(struct_processus *s_etat_	Line 995 recherche_type(struct_processus *s_etat_
if (i != 0)	if (i != 0)
{	{
free(element);	free(element);
free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_syntaxe;	d_ex_syntaxe;
Line 992 recherche_type(struct_processus *s_etat_	Line 1046 recherche_type(struct_processus *s_etat_
(erreur_lecture_binaire == d_vrai))	(erreur_lecture_binaire == d_vrai))
{	{
free(element);	free(element);
free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 1000 recherche_type(struct_processus *s_etat_	Line 1054 recherche_type(struct_processus *s_etat_
return;	return;
}	}

	(*s_objet).type = BIN;
break;	break;
}	}

Line 1060 recherche_type(struct_processus *s_etat_	Line 1115 recherche_type(struct_processus *s_etat_

if (niveau != 0)	if (niveau != 0)
{	{
free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 1091 recherche_type(struct_processus *s_etat_	Line 1146 recherche_type(struct_processus *s_etat_
sauvegarde_longueur_definitions_chainees =	sauvegarde_longueur_definitions_chainees =
(*s_etat_processus).longueur_definitions_chainees;	(*s_etat_processus).longueur_definitions_chainees;

tampon = (unsigned char *) malloc(	tampon = (unsigned char *) malloc(((size_t)
(((*s_etat_processus).longueur_definitions_chainees	(((*s_etat_processus).longueur_definitions_chainees
= strlen((*s_etat_processus).instruction_courante)	= (integer8) strlen((*s_etat_processus)
+ 4) + 1) * sizeof(unsigned char));	.instruction_courante) + 4) + 1)) *
	sizeof(unsigned char));

if (tampon == NULL)	if (tampon == NULL)
{	{
Line 1216 recherche_type(struct_processus *s_etat_	Line 1272 recherche_type(struct_processus *s_etat_
(*s_etat_processus).longueur_definitions_chainees =	(*s_etat_processus).longueur_definitions_chainees =
sauvegarde_longueur_definitions_chainees;	sauvegarde_longueur_definitions_chainees;

free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 1267 recherche_type(struct_processus *s_etat_	Line 1323 recherche_type(struct_processus *s_etat_
(*s_etat_processus).longueur_definitions_chainees =	(*s_etat_processus).longueur_definitions_chainees =
sauvegarde_longueur_definitions_chainees;	sauvegarde_longueur_definitions_chainees;

free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 1315 recherche_type(struct_processus *s_etat_	Line 1371 recherche_type(struct_processus *s_etat_
if (drapeau_complexe == d_vrai)	if (drapeau_complexe == d_vrai)
{	{
(((struct_vecteur ) element)).tableau = (void *)	(((struct_vecteur ) element)).tableau = (void *)
((struct_complexe16 ) malloc(nombre_colonnes	((struct_complexe16 *) malloc(((size_t)
	nombre_colonnes) *
sizeof(struct_complexe16)));	sizeof(struct_complexe16)));
(((struct_vecteur ) element)).type = 'C';	(((struct_vecteur ) element)).type = 'C';
}	}
else if (drapeau_reel == d_vrai)	else if (drapeau_reel == d_vrai)
{	{
(((struct_vecteur ) element)).tableau = (void *)	(((struct_vecteur ) element)).tableau = (void *)
((real8 ) malloc(nombre_colonnes	((real8 ) malloc(((size_t) nombre_colonnes)
sizeof(real8)));	sizeof(real8)));
(((struct_vecteur ) element)).type = 'R';	(((struct_vecteur ) element)).type = 'R';
}	}
else	else
{	{
(((struct_vecteur ) element)).tableau = (void *)	(((struct_vecteur ) element)).tableau = (void *)
((integer8 ) malloc(nombre_colonnes	((integer8 *) malloc(((size_t) nombre_colonnes)
sizeof(integer8)));	* sizeof(integer8)));
(((struct_vecteur ) element)).type = 'I';	(((struct_vecteur ) element)).type = 'I';
}	}

Line 1344 recherche_type(struct_processus *s_etat_	Line 1401 recherche_type(struct_processus *s_etat_
}	}

erreur = d_absence_erreur;	erreur = d_absence_erreur;
free(s_objet);	s_objet_registre = s_objet;

for(i = 0; (i < nombre_colonnes) &&	for(i = 0; (i < nombre_colonnes) &&
(erreur == d_absence_erreur); i++)	(erreur == d_absence_erreur); i++)
Line 1441 recherche_type(struct_processus *s_etat_	Line 1498 recherche_type(struct_processus *s_etat_
(*s_etat_processus)	(*s_etat_processus)
.traitement_interruptible =	.traitement_interruptible =
registre_interruption;	registre_interruption;
	liberation(s_etat_processus,
	s_objet_registre);
return;	return;
}	}

Line 1453 recherche_type(struct_processus *s_etat_	Line 1512 recherche_type(struct_processus *s_etat_
free((((struct_vecteur ) element)).tableau);	free((((struct_vecteur ) element)).tableau);
free(element);	free(element);

	liberation(s_etat_processus, s_objet_registre);
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
registre_interruption;	registre_interruption;
return;	return;
Line 1460 recherche_type(struct_processus *s_etat_	Line 1520 recherche_type(struct_processus *s_etat_
}	}
else	else
{	{
	liberation(s_etat_processus, s_objet_registre);

(*s_etat_processus).erreur_systeme = d_es_pile_vide;	(*s_etat_processus).erreur_systeme = d_es_pile_vide;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
registre_interruption;	registre_interruption;
Line 1467 recherche_type(struct_processus *s_etat_	Line 1529 recherche_type(struct_processus *s_etat_
}	}
}	}

s_objet = (struct_objet *) malloc(sizeof(struct_objet));	s_objet = s_objet_registre;

if (s_objet == NULL)
{
(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;
(*s_etat_processus).traitement_interruptible =
registre_interruption;
return;
}

initialisation_objet(s_objet);

if (drapeau_complexe == d_vrai)	if (drapeau_complexe == d_vrai)
{	{
Line 1509 recherche_type(struct_processus *s_etat_	Line 1560 recherche_type(struct_processus *s_etat_
sauvegarde_longueur_definitions_chainees =	sauvegarde_longueur_definitions_chainees =
(*s_etat_processus).longueur_definitions_chainees;	(*s_etat_processus).longueur_definitions_chainees;

tampon = (unsigned char *) malloc(	tampon = (unsigned char *) malloc(((size_t)
(((*s_etat_processus).longueur_definitions_chainees	(((*s_etat_processus).longueur_definitions_chainees
= strlen((*s_etat_processus).instruction_courante)	= (integer8) strlen((*s_etat_processus)
+ 4) + 1) * sizeof(unsigned char));	.instruction_courante) + 4) + 1)) *
	sizeof(unsigned char));

if (tampon == NULL)	if (tampon == NULL)
{	{
Line 1635 recherche_type(struct_processus *s_etat_	Line 1687 recherche_type(struct_processus *s_etat_
(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
position_courante;	position_courante;

free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 1687 recherche_type(struct_processus *s_etat_	Line 1739 recherche_type(struct_processus *s_etat_
(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
position_courante;	position_courante;

free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 1770 recherche_type(struct_processus *s_etat_	Line 1822 recherche_type(struct_processus *s_etat_
}	}

free(element);	free(element);
free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
registre_interruption;	registre_interruption;
Line 1791 recherche_type(struct_processus *s_etat_	Line 1843 recherche_type(struct_processus *s_etat_
l_element_courant = (*l_element_courant).suivant;	l_element_courant = (*l_element_courant).suivant;
}	}

free(s_objet);	s_objet_registre = s_objet;

if ((*s_etat_processus).erreur_execution == d_ex)	if ((*s_etat_processus).erreur_execution == d_ex)
{	{
Line 1799 recherche_type(struct_processus *s_etat_	Line 1851 recherche_type(struct_processus *s_etat_
{	{
if (((((struct_matrice ) element)).tableau =	if (((((struct_matrice ) element)).tableau =
(void ) ((struct_complexe16 )	(void ) ((struct_complexe16 )
malloc(nombre_lignes * sizeof(	malloc(((size_t) nombre_lignes) * sizeof(
struct_complexe16 *)))) == NULL)	struct_complexe16 *)))) == NULL)
{	{
	liberation(s_etat_processus, s_objet_registre);

(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 1816 recherche_type(struct_processus *s_etat_	Line 1870 recherche_type(struct_processus *s_etat_
if ((((((struct_matrice )	if ((((((struct_matrice )
element)).tableau)[i] = (void *)	element)).tableau)[i] = (void *)
((struct_complexe16 *)	((struct_complexe16 *)
malloc(nombre_colonnes * sizeof(	malloc(((size_t) nombre_colonnes) *
struct_complexe16)))) == NULL)	sizeof(struct_complexe16)))) == NULL)
{	{
	liberation(s_etat_processus,
	s_objet_registre);

(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
(*s_etat_processus)	(*s_etat_processus)
Line 1831 recherche_type(struct_processus *s_etat_	Line 1888 recherche_type(struct_processus *s_etat_
else if (drapeau_reel == d_vrai)	else if (drapeau_reel == d_vrai)
{	{
if (((((struct_matrice ) element)).tableau =	if (((((struct_matrice ) element)).tableau =
(void ) ((real8 )	(void ) ((real8 ) malloc(((size_t)
malloc(nombre_lignes * sizeof(real8 *))))	nombre_lignes) * sizeof(real8 *))))
== NULL)	== NULL)
{	{
	liberation(s_etat_processus, s_objet_registre);

(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 1848 recherche_type(struct_processus *s_etat_	Line 1907 recherche_type(struct_processus *s_etat_
{	{
if ((((((struct_matrice )element)).tableau)[i]	if ((((((struct_matrice )element)).tableau)[i]
= (void ) ((real8 )	= (void ) ((real8 )
malloc(nombre_colonnes *	malloc(((size_t) nombre_colonnes) *
sizeof(real8)))) == NULL)	sizeof(real8)))) == NULL)
{	{
	liberation(s_etat_processus,
	s_objet_registre);

(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
(*s_etat_processus)	(*s_etat_processus)
Line 1864 recherche_type(struct_processus *s_etat_	Line 1926 recherche_type(struct_processus *s_etat_
{	{
if (((((struct_matrice ) element)).tableau =	if (((((struct_matrice ) element)).tableau =
(void ) ((integer8 )	(void ) ((integer8 )
malloc(nombre_lignes *	malloc(((size_t) nombre_lignes) *
sizeof(integer8 *)))) == NULL)	sizeof(integer8 *)))) == NULL)
{	{
	liberation(s_etat_processus, s_objet_registre);

(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 1881 recherche_type(struct_processus *s_etat_	Line 1945 recherche_type(struct_processus *s_etat_
if ((((((struct_matrice )	if ((((((struct_matrice )
element)).tableau)[i] = (void *)	element)).tableau)[i] = (void *)
((integer8 *)	((integer8 *)
malloc(nombre_colonnes *	malloc(((size_t) nombre_colonnes) *
sizeof(integer8)))) == NULL)	sizeof(integer8)))) == NULL)
{	{
	liberation(s_etat_processus,
	s_objet_registre);

(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
(*s_etat_processus)	(*s_etat_processus)
Line 2026 recherche_type(struct_processus *s_etat_	Line 2093 recherche_type(struct_processus *s_etat_
.l_base_pile), &s_objet)	.l_base_pile), &s_objet)
== d_erreur)	== d_erreur)
{	{
	liberation(s_etat_processus,
	s_objet_registre);

(*s_etat_processus)	(*s_etat_processus)
.traitement_interruptible =	.traitement_interruptible =
registre_interruption;	registre_interruption;
Line 2049 recherche_type(struct_processus *s_etat_	Line 2119 recherche_type(struct_processus *s_etat_
.tableau);	.tableau);
free(element);	free(element);

	liberation(s_etat_processus,
	s_objet_registre);

(*s_etat_processus)	(*s_etat_processus)
.traitement_interruptible =	.traitement_interruptible =
registre_interruption;	registre_interruption;
Line 2057 recherche_type(struct_processus *s_etat_	Line 2130 recherche_type(struct_processus *s_etat_
}	}
else	else
{	{
	liberation(s_etat_processus,
	s_objet_registre);

(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_pile_vide;	d_es_pile_vide;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 2065 recherche_type(struct_processus *s_etat_	Line 2141 recherche_type(struct_processus *s_etat_
}	}
}	}

s_objet = (struct_objet *) malloc(sizeof(struct_objet));	s_objet = s_objet_registre;

if (s_objet == NULL)
{
(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;
(*s_etat_processus).traitement_interruptible =
registre_interruption;
return;
}

initialisation_objet(s_objet);

if (drapeau_complexe == d_vrai)	if (drapeau_complexe == d_vrai)
{	{
Line 2127 recherche_type(struct_processus *s_etat_	Line 2192 recherche_type(struct_processus *s_etat_
sauvegarde_longueur_definitions_chainees =	sauvegarde_longueur_definitions_chainees =
(*s_etat_processus).longueur_definitions_chainees;	(*s_etat_processus).longueur_definitions_chainees;

tampon = (unsigned char *) malloc(	tampon = (unsigned char *) malloc(((size_t)
(((*s_etat_processus).longueur_definitions_chainees =	(((*s_etat_processus).longueur_definitions_chainees =
strlen((*s_etat_processus).instruction_courante) + 4) + 1)	(integer8) strlen((*s_etat_processus)
* sizeof(unsigned char));	.instruction_courante) + 4) + 1)) * sizeof(unsigned char));

if (tampon == NULL)	if (tampon == NULL)
{	{
Line 2217 recherche_type(struct_processus *s_etat_	Line 2282 recherche_type(struct_processus *s_etat_
if ((*s_etat_processus).definitions_chainees	if ((*s_etat_processus).definitions_chainees
[(*s_etat_processus).position_courante] == '"')	[(*s_etat_processus).position_courante] == '"')
{	{
if (drapeau_chaine == d_faux)	if ((*s_etat_processus).position_courante > 0)
{	{
drapeau_chaine = d_vrai;	if ((*s_etat_processus).definitions_chainees
	[(*s_etat_processus).position_courante - 1]
	!= '\\')
	{
	if (drapeau_chaine == d_faux)
	{
	drapeau_chaine = d_vrai;
	}
	else
	{
	drapeau_chaine = d_faux;
	}
	}
}	}
else	else
{	{
drapeau_chaine = d_faux;	if (drapeau_chaine == d_faux)
	{
	drapeau_chaine = d_vrai;
	}
	else
	{
	drapeau_chaine = d_faux;
	}
}	}
}	}
else if (drapeau_chaine == d_faux)	else if (drapeau_chaine == d_faux)
Line 2286 recherche_type(struct_processus *s_etat_	Line 2370 recherche_type(struct_processus *s_etat_
(*s_etat_processus).niveau_courant = sauvegarde_niveau_courant;	(*s_etat_processus).niveau_courant = sauvegarde_niveau_courant;

free((*s_etat_processus).definitions_chainees);	free((*s_etat_processus).definitions_chainees);
free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).definitions_chainees =	(*s_etat_processus).definitions_chainees =
definitions_chainees_precedentes;	definitions_chainees_precedentes;
Line 2318 recherche_type(struct_processus *s_etat_	Line 2402 recherche_type(struct_processus *s_etat_
}	}
}	}

	variable_implicite = (*s_etat_processus).autorisation_nom_implicite;
registre_recherche_type = (*s_etat_processus).recherche_type;	registre_recherche_type = (*s_etat_processus).recherche_type;
(*s_etat_processus).recherche_type = 'Y';	(*s_etat_processus).recherche_type = 'Y';
	(*s_etat_processus).autorisation_nom_implicite = 'Y';

if (sequenceur(s_etat_processus) == d_erreur)	if (sequenceur(s_etat_processus) == d_erreur)
{	{
	(*s_etat_processus).autorisation_nom_implicite =
	variable_implicite;
(*s_etat_processus).recherche_type = registre_recherche_type;	(*s_etat_processus).recherche_type = registre_recherche_type;
(*s_etat_processus).mode_execution_programme =	(*s_etat_processus).mode_execution_programme =
registre_mode_execution_programme;	registre_mode_execution_programme;
(*s_etat_processus).erreur_execution = d_ex_syntaxe;
	if ((*s_etat_processus).erreur_execution !=
	d_ex_nom_implicite)
	{
	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
	}

nombre_lignes_a_supprimer =	nombre_lignes_a_supprimer =
(*s_etat_processus).hauteur_pile_operationnelle	(*s_etat_processus).hauteur_pile_operationnelle
Line 2358 recherche_type(struct_processus *s_etat_	Line 2451 recherche_type(struct_processus *s_etat_
(*s_etat_processus).niveau_courant = sauvegarde_niveau_courant;	(*s_etat_processus).niveau_courant = sauvegarde_niveau_courant;

free((*s_etat_processus).definitions_chainees);	free((*s_etat_processus).definitions_chainees);
free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).definitions_chainees =	(*s_etat_processus).definitions_chainees =
definitions_chainees_precedentes;	definitions_chainees_precedentes;
Line 2372 recherche_type(struct_processus *s_etat_	Line 2465 recherche_type(struct_processus *s_etat_
return;	return;
}	}

	(*s_etat_processus).autorisation_nom_implicite = variable_implicite;
(*s_etat_processus).recherche_type = registre_recherche_type;	(*s_etat_processus).recherche_type = registre_recherche_type;
(*s_etat_processus).mode_execution_programme =	(*s_etat_processus).mode_execution_programme =
registre_mode_execution_programme;	registre_mode_execution_programme;
Line 2408 recherche_type(struct_processus *s_etat_	Line 2502 recherche_type(struct_processus *s_etat_
(*s_etat_processus).niveau_courant = sauvegarde_niveau_courant;	(*s_etat_processus).niveau_courant = sauvegarde_niveau_courant;

free((*s_etat_processus).definitions_chainees);	free((*s_etat_processus).definitions_chainees);
free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).definitions_chainees =	(*s_etat_processus).definitions_chainees =
definitions_chainees_precedentes;	definitions_chainees_precedentes;
Line 2448 recherche_type(struct_processus *s_etat_	Line 2542 recherche_type(struct_processus *s_etat_
profondeur_finale = (*s_etat_processus).hauteur_pile_operationnelle;	profondeur_finale = (*s_etat_processus).hauteur_pile_operationnelle;

l_element_courant = NULL;	l_element_courant = NULL;
	s_objet_registre = s_objet;
free(s_objet);

for(i = 0; i < (profondeur_finale - profondeur_initiale); i++)	for(i = 0; i < (profondeur_finale - profondeur_initiale); i++)
{	{
Line 2457 recherche_type(struct_processus *s_etat_	Line 2550 recherche_type(struct_processus *s_etat_
&((*s_etat_processus).l_base_pile),	&((*s_etat_processus).l_base_pile),
&s_objet) == d_erreur)	&s_objet) == d_erreur)
{	{
	liberation(s_etat_processus, s_objet_registre);
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
registre_interruption;	registre_interruption;
return;	return;
Line 2465 recherche_type(struct_processus *s_etat_	Line 2559 recherche_type(struct_processus *s_etat_
if (empilement(s_etat_processus, &l_element_courant,	if (empilement(s_etat_processus, &l_element_courant,
s_objet) == d_erreur)	s_objet) == d_erreur)
{	{
	liberation(s_etat_processus, s_objet_registre);
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
registre_interruption;	registre_interruption;
return;	return;
}	}
}	}

s_objet = (struct_objet *) malloc(sizeof(struct_objet));	s_objet = s_objet_registre;

if (s_objet == NULL)
{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
(*s_etat_processus).traitement_interruptible =
registre_interruption;
return;
}

initialisation_objet(s_objet);
(*s_objet).type = LST;	(*s_objet).type = LST;
element = (void *) l_element_courant;	element = (void *) l_element_courant;

Line 2517 recherche_type(struct_processus *s_etat_	Line 2602 recherche_type(struct_processus *s_etat_
free(l_element_courant_fonctions);	free(l_element_courant_fonctions);
}	}

free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
registre_interruption;	registre_interruption;
Line 2556 recherche_type(struct_processus *s_etat_	Line 2641 recherche_type(struct_processus *s_etat_
* puis on renvoie une erreur.	* puis on renvoie une erreur.
*/	*/

free(s_objet);	(*s_objet).type = NON;
	liberation(s_etat_processus, s_objet);

l_element_courant = l_base_liste_decomposition;	l_element_courant = l_base_liste_decomposition;

Line 2633 recherche_type(struct_processus *s_etat_	Line 2719 recherche_type(struct_processus *s_etat_
* elle est convertie en majuscules.	* elle est convertie en majuscules.
*/	*/

tampon = conversion_majuscule((((struct_fonction )	tampon = conversion_majuscule(s_etat_processus,
	(((struct_fonction )
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
.nom_fonction);	.nom_fonction);

Line 2671 recherche_type(struct_processus *s_etat_	Line 2758 recherche_type(struct_processus *s_etat_
{	{
if ((fonction_majuscule =	if ((fonction_majuscule =
conversion_majuscule(	conversion_majuscule(
	s_etat_processus,
(((struct_fonction )	(((struct_fonction )
((*l_element_courant_fonctions)	((*l_element_courant_fonctions)
.donnee))).nom_fonction)) == NULL)	.donnee))).nom_fonction)) == NULL)
Line 2822 recherche_type(struct_processus *s_etat_	Line 2910 recherche_type(struct_processus *s_etat_
free(l_element_courant_fonctions);	free(l_element_courant_fonctions);
}	}

	(*s_etat_processus).autorisation_empilement_programme = 'Y';
break;	break;
}	}

Line 2857 recherche_type(struct_processus *s_etat_	Line 2946 recherche_type(struct_processus *s_etat_

(*(--ptr_ecriture)) = d_code_fin_chaine;	(*(--ptr_ecriture)) = d_code_fin_chaine;

	if (validation_chaine((unsigned char *) element) == d_faux)
	{
	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;

	free(element);
	return;
	}

break;	break;
}	}

Line 2872 recherche_type(struct_processus *s_etat_	Line 2971 recherche_type(struct_processus *s_etat_
{	{
// Tableau	// Tableau

	(*s_etat_processus).type_en_cours = TBL;
sauvegarde_longueur_definitions_chainees =	sauvegarde_longueur_definitions_chainees =
(*s_etat_processus).longueur_definitions_chainees;	(*s_etat_processus).longueur_definitions_chainees;

tampon = (unsigned char *) malloc(	tampon = (unsigned char *) malloc(((size_t)
(((*s_etat_processus).longueur_definitions_chainees	(((*s_etat_processus).longueur_definitions_chainees
= strlen((*s_etat_processus).instruction_courante)	= (integer8) strlen((*s_etat_processus)
+ 2) + 1) * sizeof(unsigned char));	.instruction_courante) + 2) + 1)) *
	sizeof(unsigned char));

if (tampon == NULL)	if (tampon == NULL)
{	{
Line 2932 recherche_type(struct_processus *s_etat_	Line 3033 recherche_type(struct_processus *s_etat_

((s_etat_processus).l_base_pile_systeme)	((s_etat_processus).l_base_pile_systeme)
.retour_definition = 'Y';	.retour_definition = 'Y';
	((s_etat_processus).l_base_pile_systeme)
	.origine_routine_evaluation = 'N';
(*s_etat_processus).niveau_courant = 0;	(*s_etat_processus).niveau_courant = 0;
(*s_etat_processus).autorisation_empilement_programme = 'N';	(*s_etat_processus).autorisation_empilement_programme = 'N';

	tampon = (*s_etat_processus).instruction_courante;
	autorisation_evaluation_nom = (*s_etat_processus)
	.autorisation_evaluation_nom;
	(*s_etat_processus).autorisation_evaluation_nom = 'N';

registre_mode_execution_programme =	registre_mode_execution_programme =
(*s_etat_processus).mode_execution_programme;	(*s_etat_processus).mode_execution_programme;
(*s_etat_processus).mode_execution_programme = 'Y';	(*s_etat_processus).mode_execution_programme = 'Y';
(*s_etat_processus).erreur_scrutation = d_faux;	(*s_etat_processus).erreur_scrutation = d_faux;

tampon = (*s_etat_processus).instruction_courante;
nombre_lignes_a_supprimer =	nombre_lignes_a_supprimer =
(*s_etat_processus).hauteur_pile_operationnelle;	(*s_etat_processus).hauteur_pile_operationnelle;

Line 2956 recherche_type(struct_processus *s_etat_	Line 3064 recherche_type(struct_processus *s_etat_
registre_recherche_type = (*s_etat_processus).recherche_type;	registre_recherche_type = (*s_etat_processus).recherche_type;
(*s_etat_processus).recherche_type = 'Y';	(*s_etat_processus).recherche_type = 'Y';

	variable_implicite =
	(*s_etat_processus).autorisation_nom_implicite;
	(*s_etat_processus).autorisation_nom_implicite = 'Y';

if (sequenceur(s_etat_processus) == d_erreur)	if (sequenceur(s_etat_processus) == d_erreur)
{	{
	(*s_etat_processus).autorisation_nom_implicite =
	variable_implicite;
(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
(*s_etat_processus).recherche_type =	(*s_etat_processus).recherche_type =
registre_recherche_type;	registre_recherche_type;
Line 2982 recherche_type(struct_processus *s_etat_	Line 3096 recherche_type(struct_processus *s_etat_
}	}

(*s_etat_processus).instruction_courante = tampon;	(*s_etat_processus).instruction_courante = tampon;
	(*s_etat_processus).autorisation_evaluation_nom =
	autorisation_evaluation_nom;

effacement_pile_systeme(s_etat_processus);	effacement_pile_systeme(s_etat_processus);
(*s_etat_processus).l_base_pile_systeme =	(*s_etat_processus).l_base_pile_systeme =
Line 3000 recherche_type(struct_processus *s_etat_	Line 3116 recherche_type(struct_processus *s_etat_
(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
position_courante;	position_courante;

free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 3008 recherche_type(struct_processus *s_etat_	Line 3124 recherche_type(struct_processus *s_etat_
return;	return;
}	}

	(*s_etat_processus).autorisation_nom_implicite =
	variable_implicite;
(*s_etat_processus).recherche_type = registre_recherche_type;	(*s_etat_processus).recherche_type = registre_recherche_type;
(*s_etat_processus).mode_execution_programme =	(*s_etat_processus).mode_execution_programme =
registre_mode_execution_programme;	registre_mode_execution_programme;
Line 3033 recherche_type(struct_processus *s_etat_	Line 3151 recherche_type(struct_processus *s_etat_
}	}

(*s_etat_processus).instruction_courante = tampon;	(*s_etat_processus).instruction_courante = tampon;
	(*s_etat_processus).autorisation_evaluation_nom =
	autorisation_evaluation_nom;

effacement_pile_systeme(s_etat_processus);	effacement_pile_systeme(s_etat_processus);
(*s_etat_processus).l_base_pile_systeme =	(*s_etat_processus).l_base_pile_systeme =
Line 3051 recherche_type(struct_processus *s_etat_	Line 3171 recherche_type(struct_processus *s_etat_
(*s_etat_processus).position_courante =	(*s_etat_processus).position_courante =
position_courante;	position_courante;

free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 3060 recherche_type(struct_processus *s_etat_	Line 3180 recherche_type(struct_processus *s_etat_
}	}

(*s_etat_processus).instruction_courante = tampon;	(*s_etat_processus).instruction_courante = tampon;
	(*s_etat_processus).autorisation_evaluation_nom =
	autorisation_evaluation_nom;

(*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;	(*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
(*s_etat_processus).niveau_courant =	(*s_etat_processus).niveau_courant =
Line 3097 recherche_type(struct_processus *s_etat_	Line 3219 recherche_type(struct_processus *s_etat_
(((struct_tableau ) element)).nombre_elements = nombre_lignes;	(((struct_tableau ) element)).nombre_elements = nombre_lignes;

if (((((struct_tableau ) element)).elements =	if (((((struct_tableau ) element)).elements =
malloc(nombre_lignes * sizeof(struct_objet *))) == NULL)	malloc(((size_t) nombre_lignes) *
	sizeof(struct_objet *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 3130 recherche_type(struct_processus *s_etat_	Line 3253 recherche_type(struct_processus *s_etat_
{	{
// Définition	// Définition

	(*s_etat_processus).type_en_cours = RPN;

if (strlen((*s_etat_processus).instruction_courante) < 5)	if (strlen((*s_etat_processus).instruction_courante) < 5)
{	{
free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 3144 recherche_type(struct_processus *s_etat_	Line 3269 recherche_type(struct_processus *s_etat_
!= 0) && (strcmp((*s_etat_processus)	!= 0) && (strcmp((*s_etat_processus)
.instruction_courante, "<<") != 0))	.instruction_courante, "<<") != 0))
{	{
free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
Line 3165 recherche_type(struct_processus *s_etat_	Line 3290 recherche_type(struct_processus *s_etat_
d_es_allocation_memoire;	d_es_allocation_memoire;
}	}

free(s_objet);	liberation(s_etat_processus, s_objet);

(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
registre_interruption;	registre_interruption;
Line 3194 recherche_type(struct_processus *s_etat_	Line 3319 recherche_type(struct_processus *s_etat_

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
	Enregistrement
	--------------------------------------------------------------------------------
	*/

	case '\|' :
	{
	if ((*s_etat_processus).instruction_courante[1] == '[')
	{
	(*s_etat_processus).type_en_cours = REC;
	sauvegarde_longueur_definitions_chainees =
	(*s_etat_processus).longueur_definitions_chainees;

	tampon = (unsigned char *) malloc(((size_t)
	(((*s_etat_processus).longueur_definitions_chainees
	= (integer8) strlen((*s_etat_processus)
	.instruction_courante) + 2) + 1)) *
	sizeof(unsigned char));

	if (tampon == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	return;
	}

	strcpy(tampon, "<< ");
	ptr_ecriture = tampon + 3;
	ptr_lecture = (*s_etat_processus).instruction_courante + 2;

	while((*ptr_lecture) != d_code_fin_chaine)
	{
	ptr_ecriture++ = ptr_lecture++;
	}

	ptr_ecriture -= 2;
	(*ptr_ecriture) = d_code_fin_chaine;
	strcat(ptr_ecriture, " >>");

	position_courante = (*s_etat_processus).position_courante;
	(*s_etat_processus).position_courante = 0;

	profondeur_initiale = (*s_etat_processus)
	.hauteur_pile_operationnelle;

	/*
	-- On met les éléments du tableau dans la pile opérationnelle ------------------
	*/

	(*s_etat_processus).niveau_recursivite++;
	definitions_chainees_precedentes = (*s_etat_processus)
	.definitions_chainees;
	(*s_etat_processus).definitions_chainees = tampon;

	s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme;
	sauvegarde_niveau_courant = (*s_etat_processus).niveau_courant;

	(*s_etat_processus).l_base_pile_systeme = NULL;
	empilement_pile_systeme(s_etat_processus);

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	return;
	}

	((s_etat_processus).l_base_pile_systeme)
	.retour_definition = 'Y';
	((s_etat_processus).l_base_pile_systeme)
	.origine_routine_evaluation = 'N';
	(*s_etat_processus).niveau_courant = 0;
	(*s_etat_processus).autorisation_empilement_programme = 'N';

	tampon = (*s_etat_processus).instruction_courante;
	autorisation_evaluation_nom = (*s_etat_processus)
	.autorisation_evaluation_nom;
	(*s_etat_processus).autorisation_evaluation_nom = 'N';

	registre_mode_execution_programme =
	(*s_etat_processus).mode_execution_programme;
	(*s_etat_processus).mode_execution_programme = 'Y';
	(*s_etat_processus).erreur_scrutation = d_faux;

	nombre_lignes_a_supprimer =
	(*s_etat_processus).hauteur_pile_operationnelle;

	if ((*s_etat_processus).profilage == d_vrai)
	{
	profilage(s_etat_processus, "RPL/2 internals");

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
	return;
	}
	}

	registre_recherche_type = (*s_etat_processus).recherche_type;
	(*s_etat_processus).recherche_type = 'Y';

	variable_implicite =
	(*s_etat_processus).autorisation_nom_implicite;
	(*s_etat_processus).autorisation_nom_implicite = 'Y';

	if (sequenceur(s_etat_processus) == d_erreur)
	{
	(*s_etat_processus).autorisation_nom_implicite =
	variable_implicite;
	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
	(*s_etat_processus).recherche_type =
	registre_recherche_type;
	(*s_etat_processus).mode_execution_programme =
	registre_mode_execution_programme;
	nombre_lignes_a_supprimer =
	(*s_etat_processus).hauteur_pile_operationnelle
	- nombre_lignes_a_supprimer;

	for(i = 0; i < nombre_lignes_a_supprimer; i++)
	{
	if (depilement(s_etat_processus,
	&((*s_etat_processus).l_base_pile),
	&s_sous_objet) == d_erreur)
	{
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	return;
	}

	liberation(s_etat_processus, s_sous_objet);
	}

	(*s_etat_processus).instruction_courante = tampon;
	(*s_etat_processus).autorisation_evaluation_nom =
	autorisation_evaluation_nom;

	effacement_pile_systeme(s_etat_processus);
	(*s_etat_processus).l_base_pile_systeme =
	s_sauvegarde_pile;
	(*s_etat_processus).niveau_courant =
	sauvegarde_niveau_courant;

	free((*s_etat_processus).definitions_chainees);
	(*s_etat_processus).niveau_recursivite--;

	(*s_etat_processus).definitions_chainees =
	definitions_chainees_precedentes;
	(*s_etat_processus).longueur_definitions_chainees =
	sauvegarde_longueur_definitions_chainees;

	(*s_etat_processus).position_courante =
	position_courante;

	liberation(s_etat_processus, s_objet);

	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	return;
	}

	(*s_etat_processus).autorisation_nom_implicite =
	variable_implicite;
	(*s_etat_processus).recherche_type = registre_recherche_type;
	(*s_etat_processus).mode_execution_programme =
	registre_mode_execution_programme;

	if ((*s_etat_processus).erreur_scrutation == d_vrai)
	{
	nombre_lignes_a_supprimer =
	(*s_etat_processus).hauteur_pile_operationnelle
	- nombre_lignes_a_supprimer;

	for(i = 0; i < nombre_lignes_a_supprimer; i++)
	{
	if (depilement(s_etat_processus,
	&((*s_etat_processus).l_base_pile),
	&s_sous_objet) == d_erreur)
	{
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	return;
	}

	liberation(s_etat_processus, s_sous_objet);
	}

	(*s_etat_processus).instruction_courante = tampon;
	(*s_etat_processus).autorisation_evaluation_nom =
	autorisation_evaluation_nom;

	effacement_pile_systeme(s_etat_processus);
	(*s_etat_processus).l_base_pile_systeme =
	s_sauvegarde_pile;
	(*s_etat_processus).niveau_courant =
	sauvegarde_niveau_courant;

	free((*s_etat_processus).definitions_chainees);
	(*s_etat_processus).niveau_recursivite--;

	(*s_etat_processus).definitions_chainees =
	definitions_chainees_precedentes;
	(*s_etat_processus).longueur_definitions_chainees =
	sauvegarde_longueur_definitions_chainees;

	(*s_etat_processus).position_courante =
	position_courante;

	liberation(s_etat_processus, s_objet);

	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	return;
	}

	(*s_etat_processus).instruction_courante = tampon;
	(*s_etat_processus).autorisation_evaluation_nom =
	autorisation_evaluation_nom;

	(*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
	(*s_etat_processus).niveau_courant =
	sauvegarde_niveau_courant;

	free((*s_etat_processus).definitions_chainees);
	(*s_etat_processus).definitions_chainees =
	definitions_chainees_precedentes;
	(*s_etat_processus).longueur_definitions_chainees =
	sauvegarde_longueur_definitions_chainees;

	(*s_etat_processus).niveau_recursivite--;

	(*s_etat_processus).position_courante = position_courante;

	/*
	-- On relit la pile qui contient des sous-objets contenant les -----------------
	-- éléments du tableau ---------------------------------------------------------
	*/

	profondeur_finale = (*s_etat_processus)
	.hauteur_pile_operationnelle;

	nombre_lignes = profondeur_finale - profondeur_initiale;

	// Il ne peut y avoir que deux lignes.

	if (nombre_lignes != 2)
	{
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	(*s_etat_processus).erreur_execution =
	d_ex_dimensions_invalides;
	return;
	}

	if ((element = malloc(sizeof(struct_record))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	return;
	}

	if (depilement(s_etat_processus,
	&((*s_etat_processus).l_base_pile),
	&((((struct_record ) element)).donnees))
	== d_erreur)
	{
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	return;
	}

	if (depilement(s_etat_processus,
	&((*s_etat_processus).l_base_pile),
	&((((struct_record ) element)).noms))
	== d_erreur)
	{
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	return;
	}

	(*s_objet).type = REC;
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;

	// Vérification des types.

	if ((((((struct_record *) element)).donnees).type != TBL)
	\|\| (((((struct_record *) element)).noms).type != TBL))
	{
	(*s_objet).objet = element;
	liberation(s_etat_processus, s_objet);

	(*s_etat_processus).erreur_execution =
	d_ex_erreur_type_argument;
	return;
	}

	for(i = 0; i < (((struct_tableau ) ((((struct_record *)
	element)).noms).objet)).nombre_elements; i++)
	{
	if (((((struct_tableau ) ((((struct_record ) element))
	.noms).objet)).elements[i]).type != CHN)
	{
	(*s_objet).objet = element;
	liberation(s_etat_processus, s_objet);

	(*s_etat_processus).erreur_execution =
	d_ex_erreur_type_argument;
	return;
	}
	}

	// Vérification des dimensions

	if ((((struct_tableau ) ((((struct_record *) element))
	.donnees).objet)).nombre_elements !=
	(((struct_tableau ) ((((struct_record *) element))
	.noms).objet)).nombre_elements)
	{
	(*s_objet).objet = element;
	liberation(s_etat_processus, s_objet);

	(*s_etat_processus).erreur_execution =
	d_ex_dimensions_invalides;
	return;
	}

	// Tri de l'enregistrement (tri bull)

	tri_acheve = d_faux;

	while(tri_acheve == d_faux)
	{
	tri_acheve = d_vrai;

	for(i = 0; i < (((struct_tableau ) ((((struct_record *)
	element)).noms).objet)).nombre_elements - 1; i++)
	{
	if (strcmp((unsigned char ) ((((struct_tableau )
	((((struct_record *) element)).noms).objet))
	.elements[i]).objet, (unsigned char *)
	((((struct_tableau ) ((((struct_record )
	element)).noms).objet)).elements[i + 1]).objet)
	> 0)
	{
	tri_acheve = d_faux;

	tampon = (unsigned char ) ((((struct_tableau )
	((((struct_record *) element)).noms)
	.objet)).elements[i + 1]).objet;
	((((struct_tableau ) ((((struct_record )
	element)).noms).objet)).elements[i + 1])
	.objet = ((((struct_tableau *)
	((((struct_record *) element)).noms)
	.objet)).elements[i]).objet;
	((((struct_tableau ) ((((struct_record )
	element)).noms).objet)).elements[i]).objet =
	tampon;

	s_objet_registre = (((struct_tableau )
	((((struct_record *) element)).donnees)
	.objet)).elements[i + 1];
	(((struct_tableau ) ((((struct_record *)
	element)).donnees).objet)).elements[i + 1] =
	(((struct_tableau ) ((((struct_record *)
	element)).donnees).objet)).elements[i];
	(((struct_tableau ) ((((struct_record *)
	element)).donnees).objet)).elements[i] =
	s_objet_registre;
	}
	}
	}

	// Vérification de l'unicité des noms

	for(i = 0; i < (((struct_tableau ) ((((struct_record *)
	element)).noms).objet)).nombre_elements - 1; i++)
	{
	if (strcmp((unsigned char ) ((((struct_tableau )
	((((struct_record *) element)).noms).objet))
	.elements[i]).objet, (unsigned char *)
	((((struct_tableau ) ((((struct_record )
	element)).noms).objet)) .elements[i + 1]).objet)
	== 0)
	{
	(*s_objet).objet = element;
	liberation(s_etat_processus, s_objet);

	(*s_etat_processus).erreur_execution =
	d_ex_argument_invalide;
	return;
	}
	}
	}

	break;
	}

	/*
	--------------------------------------------------------------------------------
Entier ou réel	Entier ou réel
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/
Line 3418 recherche_type(struct_processus *s_etat_	Line 3947 recherche_type(struct_processus *s_etat_

while((*ptr) != d_code_fin_chaine)	while((*ptr) != d_code_fin_chaine)
{	{
if ((isalnum((*ptr)) == 0) &&	if (isalnum(*ptr) != 0)
((*ptr) != '_') &&
((*ptr) != '$'))
{	{
free(s_objet);	ptr++;
	}
	else if (((ptr) == '_') \|\| ((ptr == '$')))
	{
	ptr++;
	}
	else
	{
	liberation(s_etat_processus, s_objet);

(*s_etat_processus).erreur_execution = d_ex_syntaxe;	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
(*s_etat_processus).traitement_interruptible =	(*s_etat_processus).traitement_interruptible =
registre_interruption;	registre_interruption;

return;	return;
}	}

ptr++;
}	}

(*s_objet).type = NOM;	(*s_objet).type = NOM;
Line 3493 recherche_type(struct_processus *s_etat_	Line 4025 recherche_type(struct_processus *s_etat_
}	}
else	else
{	{
(*s_objet).type = INT;	// Le format ressemble à un entier mais il peut y avoir
	// un dépassement de capacité lors de la conversion.
	// On convertit donc en entier et en réel. Si les
	// deux conversions donnent le même résultat, on
	// considère que la conversion en entier est bonne. Dans
	// le cas contraire, on garde la conversion en réel.

element = (void ) ((integer8 ) malloc(	integer8 conversion_entiere;
sizeof(integer8)));	real8 conversion_reelle;

if (element == NULL)	if (sscanf((*s_etat_processus).instruction_courante, "%lld",
	&conversion_entiere) != 1)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
d_es_allocation_memoire;
(*s_etat_processus).traitement_interruptible =
registre_interruption;
return;
}	}

nombre_elements_convertis = sscanf(	if (errno != ERANGE)
(*s_etat_processus).instruction_courante, "%lld",	{
(integer8 *) element);	(*s_objet).type = INT;

if (nombre_elements_convertis != 1)	element = malloc(sizeof(integer8));

	if (element == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	return;
	}

	(((integer8 ) element)) = conversion_entiere;
	}
	else
{	{
(*s_etat_processus).erreur_execution = d_ex_syntaxe;	if (sscanf((*s_etat_processus).instruction_courante,
	"%lg", &conversion_reelle) != 1)
	{
	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
	}

	(*s_objet).type = REL;

	element = malloc(sizeof(real8));

	if (element == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	(*s_etat_processus).traitement_interruptible =
	registre_interruption;
	return;
	}

	(((real8 ) element)) = conversion_reelle;
}	}
}	}
}	}

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.27.2.1
changed lines
	Added in v.1.96