|
version 1.17.2.1, 2011/04/11 13:02:12
|
version 1.48, 2013/04/01 15:29:33
|
|
Line 1
|
Line 1
|
| /* |
/* |
| ================================================================================ |
================================================================================ |
| RPL/2 (R) version 4.0.22 |
RPL/2 (R) version 4.1.14 |
| Copyright (C) 1989-2011 Dr. BERTRAND Joël |
Copyright (C) 1989-2013 Dr. BERTRAND Joël |
| |
|
| This file is part of RPL/2. |
This file is part of RPL/2. |
| |
|
|
Line 20
|
Line 20
|
| */ |
*/ |
| |
|
| |
|
| #include "rpl-conv.h"
|
#include "rpl-conv.h" |
|
|
|
|
|
|
| /*
|
/* |
| ================================================================================
|
================================================================================ |
| Analyseur syntaxique d'une expression algébrique
|
Analyseur syntaxique d'une expression algébrique |
| ================================================================================
|
================================================================================ |
| Entrées : chaîne de caractères comprenant l'expression algébrique
|
Entrées : chaîne de caractères comprenant l'expression algébrique |
| --------------------------------------------------------------------------------
|
-------------------------------------------------------------------------------- |
| Sorties : chaîne de caractères contenant l'expression convertie en
|
Sorties : chaîne de caractères contenant l'expression convertie en |
| notation polonaise inverse et liste chaînée contenant les diverses
|
notation polonaise inverse et liste chaînée contenant les diverses |
| fonctions.
|
fonctions. |
| --------------------------------------------------------------------------------
|
-------------------------------------------------------------------------------- |
| Effets de bord : néant
|
Effets de bord : néant |
| ================================================================================
|
================================================================================ |
| */
|
*/ |
|
|
|
| unsigned char *
|
unsigned char * |
| analyse_algebrique(struct_processus *s_etat_processus,
|
analyse_algebrique(struct_processus *s_etat_processus, |
| unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste)
|
unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste) |
| {
|
{ |
| struct_fonction *s_fonction;
|
struct_fonction *s_fonction; |
|
|
|
| struct_liste_chainee *l_element_courant;
|
struct_liste_chainee *l_element_courant; |
|
|
|
| logical1 chaine_invalide;
|
logical1 chaine_invalide; |
| logical1 drapeau_debut_zone_valide;
|
logical1 drapeau_debut_zone_valide; |
| logical1 drapeau_elimination_parentheses;
|
logical1 drapeau_elimination_parentheses; |
| logical1 drapeau_fin_boucle;
|
logical1 drapeau_fin_boucle; |
| logical1 drapeau_fin_zone_valide;
|
logical1 drapeau_fin_zone_valide; |
| logical1 drapeau_modification;
|
logical1 drapeau_modification; |
| logical1 drapeau_priorite_entierement_traitee;
|
logical1 drapeau_priorite_entierement_traitee; |
| logical1 fin_boucle_extraction;
|
logical1 fin_boucle_extraction; |
| logical1 presence_chaine;
|
logical1 presence_chaine; |
| logical1 presence_fonction;
|
logical1 presence_fonction; |
| logical1 presence_liste;
|
logical1 presence_liste; |
|
|
|
| long k;
|
unsigned char *chaine_arguments; |
|
|
unsigned char *chaine_centrale; |
| unsigned char *chaine_arguments;
|
unsigned char *chaine_droite; |
| unsigned char *chaine_centrale;
|
unsigned char *chaine_fonction; |
| unsigned char *chaine_droite;
|
unsigned char *chaine_gauche; |
| unsigned char *chaine_fonction;
|
unsigned char *chaine_travail; |
| unsigned char *chaine_gauche;
|
unsigned char *epilogue; |
| unsigned char *chaine_travail;
|
unsigned char instruction_test[6]; |
| unsigned char *epilogue;
|
unsigned char *instruction_majuscule; |
| unsigned char instruction_test[6];
|
unsigned char *prologue; |
| unsigned char *instruction_majuscule;
|
unsigned char *ptr1; |
| unsigned char *prologue;
|
unsigned char *ptr2; |
| unsigned char *ptr1;
|
unsigned char *registre_instruction_courante; |
| unsigned char *ptr2;
|
unsigned char registre_instruction_valide; |
| unsigned char *registre_instruction_courante;
|
unsigned char registre_test; |
| unsigned char registre_instruction_valide;
|
unsigned char *sous_chaine_droite; |
| unsigned char registre_test;
|
unsigned char *sous_chaine_gauche; |
| unsigned char *sous_chaine_droite;
|
unsigned char *tampon; |
| unsigned char *sous_chaine_gauche;
|
|
| unsigned char t0;
|
int t0; |
| unsigned char t1;
|
int t1; |
| unsigned char t2;
|
int t2; |
| unsigned char t3;
|
int t3; |
| unsigned char t4;
|
int t4; |
| unsigned char *tampon;
|
|
|
|
integer8 debut_zone_algebrique; |
| unsigned long debut_zone_algebrique;
|
integer8 fin_zone_algebrique; |
| unsigned long fin_zone_algebrique;
|
integer8 i; |
| unsigned long i;
|
integer8 j; |
| unsigned long j;
|
integer8 k; |
| unsigned long longueur_chaine;
|
integer8 longueur_chaine; |
| unsigned long longueur_tampon;
|
integer8 longueur_tampon; |
| unsigned long niveau;
|
integer8 niveau; |
| unsigned long niveau_liste;
|
integer8 niveau_liste; |
| unsigned long nombre_apostrophes;
|
integer8 nombre_apostrophes; |
| unsigned long nombre_arguments;
|
integer8 nombre_arguments; |
| unsigned long priorite;
|
integer8 priorite; |
|
|
|
| (*l_base_liste) = NULL;
|
(*l_base_liste) = NULL; |
|
|
|
| /*
|
/* |
| * Vérification de la chaîne. Celle-ci doit comporter au moins un
|
* Vérification de la chaîne. Celle-ci doit comporter au moins un |
| * caractère entre les délimiteurs ''.
|
* caractère entre les délimiteurs ''. |
| */
|
*/ |
|
|
|
| presence_chaine = d_faux;
|
presence_chaine = d_faux; |
| presence_liste = d_faux;
|
presence_liste = d_faux; |
| niveau_liste = 0;
|
niveau_liste = 0; |
|
|
|
| for(i = 1, chaine_invalide = d_vrai; i < strlen(chaine_algebrique) - 1; i++)
|
for(i = 1, chaine_invalide = d_vrai; i < ((integer8) |
| {
|
strlen(chaine_algebrique)) - 1; i++) |
| if (chaine_algebrique[i] != ' ')
|
{ |
| {
|
if (chaine_algebrique[i] != ' ') |
| chaine_invalide = d_faux;
|
{ |
| }
|
chaine_invalide = d_faux; |
|
|
} |
| if (chaine_algebrique[i] == '"')
|
|
| {
|
if (chaine_algebrique[i] == '"') |
| presence_chaine = (presence_chaine == d_faux) ? d_vrai : d_faux;
|
{ |
| }
|
if (chaine_algebrique[i - 1] != '\\') |
| else if (presence_chaine == d_faux)
|
{ |
| {
|
presence_chaine = (presence_chaine == d_faux) ? d_vrai : d_faux; |
| if (chaine_algebrique[i] == '{')
|
} |
| {
|
} |
| presence_liste = d_vrai;
|
else if (presence_chaine == d_faux) |
| niveau_liste++;
|
{ |
| }
|
if (chaine_algebrique[i] == '{') |
| else if (chaine_algebrique[i] == '}')
|
{ |
| {
|
presence_liste = d_vrai; |
| presence_liste = d_vrai;
|
niveau_liste++; |
| niveau_liste--;
|
} |
| }
|
else if (chaine_algebrique[i] == '}') |
| }
|
{ |
| }
|
presence_liste = d_vrai; |
|
|
niveau_liste--; |
| if ((chaine_invalide == d_vrai) || (presence_chaine == d_vrai) ||
|
} |
| (niveau_liste != 0) || (presence_liste == d_vrai))
|
} |
| {
|
} |
| (*s_etat_processus).erreur_execution = d_ex_expression_invalide;
|
|
| return(NULL);
|
if ((chaine_invalide == d_vrai) || (presence_chaine == d_vrai) || |
| }
|
(niveau_liste != 0) || (presence_liste == d_vrai)) |
|
|
{ |
| /*
|
(*s_etat_processus).erreur_execution = d_ex_expression_invalide; |
| * Transformation des "**" en "^ "
|
return(NULL); |
| */
|
} |
|
|
|
| for(i = 1; i < strlen(chaine_algebrique) - 1; i++)
|
/* |
| {
|
* Transformation des "**" en "^ " |
| if (chaine_algebrique[i] == '*')
|
*/ |
| {
|
|
| if (chaine_algebrique[i + 1] == '*')
|
for(i = 1; i < ((integer8) strlen(chaine_algebrique)) - 1; i++) |
| {
|
{ |
| chaine_algebrique[i++] = '^';
|
if (chaine_algebrique[i] == '*') |
| chaine_algebrique[i] = ' ';
|
{ |
| }
|
if (chaine_algebrique[i + 1] == '*') |
| }
|
{ |
| }
|
chaine_algebrique[i++] = '^'; |
|
|
chaine_algebrique[i] = ' '; |
| if ((chaine_travail = (unsigned char *) malloc((strlen(chaine_algebrique) +
|
} |
| 1) * sizeof(unsigned char))) == NULL)
|
} |
| {
|
} |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
|
|
| return(NULL);
|
if ((chaine_travail = (unsigned char *) malloc((strlen(chaine_algebrique) + |
| }
|
1) * sizeof(unsigned char))) == NULL) |
|
|
{ |
| strcpy(chaine_travail, chaine_algebrique);
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
|
return(NULL); |
| /*
|
} |
| * Retrait des espaces dans l'expression algébrique
|
|
| */
|
strcpy(chaine_travail, chaine_algebrique); |
|
|
|
| ptr1 = chaine_travail;
|
/* |
| ptr2 = chaine_travail;
|
* Retrait des espaces dans l'expression algébrique |
| presence_chaine = d_faux;
|
*/ |
|
|
|
| while((*ptr1) != d_code_fin_chaine)
|
ptr1 = chaine_travail; |
| {
|
ptr2 = chaine_travail; |
| if ((*ptr1) == '"')
|
presence_chaine = d_faux; |
| {
|
|
| if (presence_chaine == d_faux)
|
while((*ptr1) != d_code_fin_chaine) |
| {
|
{ |
| presence_chaine = d_vrai;
|
if ((*ptr1) == '"') |
| }
|
{ |
| else
|
if (ptr1 != chaine_travail) |
| {
|
{ // Il existe un caractère précédent. |
| presence_chaine = d_faux;
|
if ((*(ptr1 - 1)) != '\\') |
| }
|
{ |
| }
|
if (presence_chaine == d_faux) |
|
|
{ |
| if (presence_chaine == d_faux)
|
presence_chaine = d_vrai; |
| {
|
} |
| if ((*ptr1) != ' ')
|
else |
| {
|
{ |
| (*(ptr2++)) = (*ptr1);
|
presence_chaine = d_faux; |
| }
|
} |
| else
|
} |
| {
|
} |
| instruction_test[5] = d_code_fin_chaine;
|
else |
|
|
{ // Il n'existe pas de caractère précédent. |
| instruction_majuscule = conversion_majuscule(strncpy(
|
if (presence_chaine == d_faux) |
| instruction_test, ptr1, 5));
|
{ |
|
|
presence_chaine = d_vrai; |
| if (instruction_majuscule == NULL)
|
} |
| {
|
else |
| (*s_etat_processus).erreur_systeme =
|
{ |
| d_es_allocation_memoire;
|
presence_chaine = d_faux; |
| return(NULL);
|
} |
| }
|
} |
|
|
} |
| /*
|
|
| * Repérer le premier espace ou la fin de la chaîne.
|
if (presence_chaine == d_faux) |
| */
|
{ |
|
|
if ((*ptr1) != ' ') |
| if (strcmp(instruction_majuscule, " AND ") == 0)
|
{ |
| {
|
(*(ptr2++)) = (*ptr1); |
| for(i = 0; i < 4; (*(ptr2++)) = (*(ptr1++)), i++);
|
} |
| (*(ptr2++)) = (*ptr1);
|
else |
| }
|
{ |
| else if (strcmp(instruction_majuscule, " XOR ") == 0)
|
instruction_test[5] = d_code_fin_chaine; |
| {
|
|
| for(i = 0; i < 4; (*(ptr2++)) = (*(ptr1++)), i++);
|
instruction_majuscule = conversion_majuscule(strncpy( |
| (*(ptr2++)) = (*ptr1);
|
instruction_test, ptr1, 5)); |
| }
|
|
| else if ((strncmp(instruction_majuscule, " OR ", 4) == 0) &&
|
if (instruction_majuscule == NULL) |
| (strlen(instruction_majuscule) == 4))
|
{ |
| {
|
(*s_etat_processus).erreur_systeme = |
| for(i = 0; i < 3; (*(ptr2++)) = (*(ptr1++)), i++);
|
d_es_allocation_memoire; |
| (*(ptr2++)) = (*ptr1);
|
return(NULL); |
| }
|
} |
|
|
|
| free(instruction_majuscule);
|
/* |
| }
|
* Repérer le premier espace ou la fin de la chaîne. |
|
|
*/ |
| ptr1++;
|
|
| }
|
if (strcmp(instruction_majuscule, " AND ") == 0) |
| else
|
{ |
| {
|
for(i = 0; i < 4; (*(ptr2++)) = (*(ptr1++)), i++); |
| (*(ptr2++)) = (*(ptr1++));
|
(*(ptr2++)) = (*ptr1); |
| }
|
} |
| }
|
else if (strcmp(instruction_majuscule, " XOR ") == 0) |
|
|
{ |
| (*ptr2) = d_code_fin_chaine;
|
for(i = 0; i < 4; (*(ptr2++)) = (*(ptr1++)), i++); |
|
|
(*(ptr2++)) = (*ptr1); |
| do
|
} |
| {
|
else if ((strncmp(instruction_majuscule, " OR ", 4) == 0) && |
| i = 0;
|
(strlen(instruction_majuscule) == 4)) |
| drapeau_modification = d_faux;
|
{ |
|
|
for(i = 0; i < 3; (*(ptr2++)) = (*(ptr1++)), i++); |
| do
|
(*(ptr2++)) = (*ptr1); |
| {
|
} |
| presence_chaine = d_faux;
|
|
| drapeau_debut_zone_valide = d_faux;
|
free(instruction_majuscule); |
| debut_zone_algebrique = 0;
|
} |
| drapeau_fin_boucle = d_faux;
|
|
|
|
ptr1++; |
| do
|
} |
| {
|
else |
| if (chaine_travail[i] == d_code_fin_chaine)
|
{ |
| {
|
(*(ptr2++)) = (*(ptr1++)); |
| drapeau_fin_boucle = d_vrai;
|
} |
| }
|
} |
| else if ((chaine_travail[i] == '\'') &&
|
|
| (presence_chaine == d_faux))
|
(*ptr2) = d_code_fin_chaine; |
| {
|
|
| drapeau_fin_boucle = d_vrai;
|
do |
| debut_zone_algebrique = i;
|
{ |
| drapeau_debut_zone_valide = d_vrai;
|
i = 0; |
| }
|
drapeau_modification = d_faux; |
| else if (chaine_travail[i] == '"')
|
|
| {
|
do |
| presence_chaine = (presence_chaine == d_vrai)
|
{ |
| ? d_faux : d_vrai;
|
presence_chaine = d_faux; |
| }
|
drapeau_debut_zone_valide = d_faux; |
|
|
debut_zone_algebrique = 0; |
| i++;
|
drapeau_fin_boucle = d_faux; |
| } while(drapeau_fin_boucle == d_faux);
|
|
|
|
do |
| presence_chaine = 0;
|
{ |
| drapeau_fin_zone_valide = d_faux;
|
if (chaine_travail[i] == d_code_fin_chaine) |
|
|
{ |
| if (drapeau_debut_zone_valide == d_vrai)
|
drapeau_fin_boucle = d_vrai; |
| {
|
} |
| j = debut_zone_algebrique + 1;
|
else if ((chaine_travail[i] == '\'') && |
| }
|
(presence_chaine == d_faux)) |
| else
|
{ |
| {
|
drapeau_fin_boucle = d_vrai; |
| j = 0;
|
debut_zone_algebrique = i; |
| }
|
drapeau_debut_zone_valide = d_vrai; |
|
|
} |
| fin_zone_algebrique = 0;
|
else if (chaine_travail[i] == '"') |
| drapeau_fin_boucle = d_faux;
|
{ |
|
|
if (i > 0) |
| do
|
{ |
| {
|
if (chaine_travail[i - 1] != '\\') |
| if (chaine_travail[j] == 0)
|
{ |
| {
|
presence_chaine = (presence_chaine == d_vrai) |
| drapeau_fin_boucle = d_vrai;
|
? d_faux : d_vrai; |
| }
|
} |
|
|
} |
| if ((chaine_travail[j] == '\'') && (presence_chaine == d_faux))
|
else |
| {
|
{ |
| drapeau_fin_boucle = d_vrai;
|
presence_chaine = (presence_chaine == d_vrai) |
| fin_zone_algebrique = j;
|
? d_faux : d_vrai; |
| drapeau_fin_zone_valide = d_vrai;
|
} |
| }
|
} |
|
|
|
| if (chaine_travail[j] == '"')
|
i++; |
| {
|
} while(drapeau_fin_boucle == d_faux); |
| presence_chaine = (presence_chaine == d_vrai)
|
|
| ? d_faux : d_vrai;
|
presence_chaine = 0; |
| }
|
drapeau_fin_zone_valide = d_faux; |
|
|
|
| j++;
|
if (drapeau_debut_zone_valide == d_vrai) |
| } while(drapeau_fin_boucle == d_faux);
|
{ |
|
|
j = debut_zone_algebrique + 1; |
| if ((drapeau_debut_zone_valide == d_vrai) &&
|
} |
| (drapeau_fin_zone_valide == d_vrai))
|
else |
| {
|
{ |
| chaine_gauche = purification_chaine(
|
j = 0; |
| extraction_chaine(chaine_travail,
|
} |
| 1, debut_zone_algebrique));
|
|
| chaine_centrale = purification_chaine(
|
fin_zone_algebrique = 0; |
| extraction_chaine(chaine_travail,
|
drapeau_fin_boucle = d_faux; |
| debut_zone_algebrique + 1, fin_zone_algebrique + 1));
|
|
| chaine_droite = purification_chaine(
|
do |
| extraction_chaine(chaine_travail,
|
{ |
| fin_zone_algebrique + 2, strlen(chaine_travail)));
|
if (chaine_travail[j] == 0) |
|
|
{ |
| free(chaine_travail);
|
drapeau_fin_boucle = d_vrai; |
|
|
} |
| if ((chaine_gauche == NULL) || (chaine_centrale == NULL) ||
|
|
| (chaine_droite == NULL))
|
if ((chaine_travail[j] == '\'') && (presence_chaine == d_faux)) |
| {
|
{ |
| (*s_etat_processus).erreur_systeme =
|
drapeau_fin_boucle = d_vrai; |
| d_es_allocation_memoire;
|
fin_zone_algebrique = j; |
| return(NULL);
|
drapeau_fin_zone_valide = d_vrai; |
| }
|
} |
|
|
|
| if ((strcmp(chaine_centrale, "''") == 0) ||
|
if (chaine_travail[j] == '"') |
| (strcmp(chaine_centrale, "'()'") == 0))
|
{ |
| {
|
if (j > 0) |
| free(chaine_gauche);
|
{ |
| free(chaine_centrale);
|
if (chaine_travail[j - 1] != '\\') |
| free(chaine_droite);
|
{ |
|
|
presence_chaine = (presence_chaine == d_vrai) |
| (*s_etat_processus).erreur_execution =
|
? d_faux : d_vrai; |
| d_ex_expression_invalide;
|
} |
| return(NULL);
|
} |
| }
|
else |
|
|
{ |
| i = 1;
|
presence_chaine = (presence_chaine == d_vrai) |
| niveau = 0;
|
? d_faux : d_vrai; |
| drapeau_elimination_parentheses = d_vrai;
|
} |
| presence_chaine = d_faux;
|
} |
|
|
|
| while(i < (strlen(chaine_centrale) - 1))
|
j++; |
| {
|
} while(drapeau_fin_boucle == d_faux); |
| if (chaine_centrale[i] == '"')
|
|
| {
|
if ((drapeau_debut_zone_valide == d_vrai) && |
| presence_chaine = (presence_chaine == d_faux)
|
(drapeau_fin_zone_valide == d_vrai)) |
| ? d_vrai : d_faux;
|
{ |
|
|
chaine_gauche = purification_chaine( |
| if (i == 1)
|
extraction_chaine(chaine_travail, |
| {
|
1, debut_zone_algebrique)); |
| drapeau_elimination_parentheses = d_faux;
|
chaine_centrale = purification_chaine( |
| }
|
extraction_chaine(chaine_travail, |
| }
|
debut_zone_algebrique + 1, fin_zone_algebrique + 1)); |
| else if (presence_chaine == d_faux)
|
chaine_droite = purification_chaine( |
| {
|
extraction_chaine(chaine_travail, |
| if (chaine_centrale[i] == '(')
|
fin_zone_algebrique + 2, |
| {
|
(integer8) strlen(chaine_travail))); |
| niveau++;
|
|
| }
|
free(chaine_travail); |
|
|
|
| if ((niveau == 0) || ((((test_cfsf(s_etat_processus,
|
if ((chaine_gauche == NULL) || (chaine_centrale == NULL) || |
| 48) == d_vrai) && (chaine_centrale[i] ==
|
(chaine_droite == NULL)) |
| '.')) || ((test_cfsf(s_etat_processus, 48)
|
{ |
| == d_faux) && (chaine_centrale[i] == ',')))
|
(*s_etat_processus).erreur_systeme = |
| && (niveau == 1)))
|
d_es_allocation_memoire; |
| {
|
return(NULL); |
| drapeau_elimination_parentheses = d_faux;
|
} |
| }
|
|
|
|
if ((strcmp(chaine_centrale, "''") == 0) || |
| if (chaine_centrale[i] == ')')
|
(strcmp(chaine_centrale, "'()'") == 0)) |
| {
|
{ |
| niveau--;
|
free(chaine_gauche); |
| }
|
free(chaine_centrale); |
| }
|
free(chaine_droite); |
|
|
|
| i++;
|
(*s_etat_processus).erreur_execution = |
| }
|
d_ex_expression_invalide; |
|
|
return(NULL); |
| if (drapeau_elimination_parentheses == d_vrai)
|
} |
| {
|
|
| tampon = chaine_centrale;
|
i = 1; |
|
|
niveau = 0; |
| if ((chaine_centrale = (unsigned char *) malloc(
|
drapeau_elimination_parentheses = d_vrai; |
| (strlen(tampon) - 1) * sizeof(unsigned char)))
|
presence_chaine = d_faux; |
| == NULL)
|
|
| {
|
while(i < ((integer8) strlen(chaine_centrale)) - 1) |
| (*s_etat_processus).erreur_systeme =
|
{ |
| d_es_allocation_memoire;
|
if (chaine_centrale[i] == '"') |
| return(NULL);
|
{ |
| }
|
if (i > 0) |
|
|
{ |
| tampon[strlen(tampon) - 2] = d_code_fin_chaine;
|
if (chaine_centrale[i - 1] != '\\') |
|
|
{ |
| sprintf(chaine_centrale, "'%s'", &(tampon[2]));
|
presence_chaine = (presence_chaine == d_faux) |
| free(tampon);
|
? d_vrai : d_faux; |
|
|
} |
| fin_zone_algebrique -= 2;
|
} |
| drapeau_modification = d_vrai;
|
else |
| }
|
{ |
|
|
presence_chaine = (presence_chaine == d_faux) |
| if ((test_expression_rpn(chaine_centrale) == d_vrai) &&
|
? d_vrai : d_faux; |
| (fin_zone_algebrique - debut_zone_algebrique > 0))
|
} |
| {
|
|
| if ((tampon = purification_chaine(
|
if (i == 1) |
| extraction_chaine(chaine_centrale, 2,
|
{ |
| strlen(chaine_centrale) - 1))) == NULL)
|
drapeau_elimination_parentheses = d_faux; |
| {
|
} |
| (*s_etat_processus).erreur_systeme =
|
} |
| d_es_allocation_memoire;
|
else if (presence_chaine == d_faux) |
| return(NULL);
|
{ |
| }
|
if (chaine_centrale[i] == '(') |
|
|
{ |
| /*
|
niveau++; |
| * Si on tombe sur une fonction intrinsèque ou
|
} |
| * extrinsèque, il doit y avoir des arguments passés
|
|
| * entre parenthèses et on ne doit pas passer par ici !
|
if ((niveau == 0) || ((((test_cfsf(s_etat_processus, |
| */
|
48) == d_vrai) && (chaine_centrale[i] == |
|
|
'.')) || ((test_cfsf(s_etat_processus, 48) |
| registre_instruction_courante = (*s_etat_processus)
|
== d_faux) && (chaine_centrale[i] == ','))) |
| .instruction_courante;
|
&& (niveau == 1))) |
| registre_test = (*s_etat_processus).test_instruction;
|
{ |
| registre_instruction_valide = (*s_etat_processus)
|
drapeau_elimination_parentheses = d_faux; |
| .instruction_valide;
|
} |
|
|
|
| (*s_etat_processus).test_instruction = 'Y';
|
if (chaine_centrale[i] == ')') |
| (*s_etat_processus).instruction_courante = tampon;
|
{ |
|
|
niveau--; |
| analyse(s_etat_processus, NULL);
|
} |
|
|
} |
| (*s_etat_processus).test_instruction = registre_test;
|
|
| (*s_etat_processus).instruction_courante =
|
i++; |
| registre_instruction_courante;
|
} |
|
|
|
| if (((*s_etat_processus).instruction_valide == 'Y') &&
|
if (drapeau_elimination_parentheses == d_vrai) |
| ((*s_etat_processus).constante_symbolique == 'N'))
|
{ |
| {
|
tampon = chaine_centrale; |
| free(chaine_gauche);
|
|
| free(chaine_centrale);
|
if ((chaine_centrale = (unsigned char *) malloc( |
| free(chaine_droite);
|
(strlen(tampon) - 1) * sizeof(unsigned char))) |
| free(tampon);
|
== NULL) |
|
|
{ |
| (*s_etat_processus).instruction_valide =
|
(*s_etat_processus).erreur_systeme = |
| registre_instruction_valide;
|
d_es_allocation_memoire; |
|
|
return(NULL); |
| (*s_etat_processus).erreur_execution =
|
} |
| d_ex_expression_invalide;
|
|
| return(NULL);
|
tampon[strlen(tampon) - 2] = d_code_fin_chaine; |
| }
|
|
|
|
sprintf(chaine_centrale, "'%s'", &(tampon[2])); |
| (*s_etat_processus).instruction_valide =
|
free(tampon); |
| registre_instruction_valide;
|
|
|
|
fin_zone_algebrique -= 2; |
| free(chaine_centrale);
|
drapeau_modification = d_vrai; |
| chaine_centrale = tampon;
|
} |
|
|
|
| fin_zone_algebrique--;
|
if ((test_expression_rpn(chaine_centrale) == d_vrai) && |
| drapeau_modification = d_vrai;
|
(fin_zone_algebrique - debut_zone_algebrique > 0)) |
| }
|
{ |
| else if ((test_fonction(chaine_centrale) == d_vrai) &&
|
if ((tampon = purification_chaine( |
| (fin_zone_algebrique - debut_zone_algebrique > 0))
|
extraction_chaine(chaine_centrale, 2, |
| {
|
((integer8) strlen(chaine_centrale)) - 1))) == NULL) |
| i = 1;
|
{ |
| while((i < (strlen(chaine_centrale) - 1)) &&
|
(*s_etat_processus).erreur_systeme = |
| (chaine_centrale[i] != '('))
|
d_es_allocation_memoire; |
| {
|
return(NULL); |
| i++;
|
} |
| }
|
|
|
|
/* |
| j = strlen(chaine_centrale) - 1;
|
* Si on tombe sur une fonction intrinsèque ou |
| while(chaine_centrale[j] != ')')
|
* extrinsèque, il doit y avoir des arguments passés |
| {
|
* entre parenthèses et on ne doit pas passer par ici ! |
| j--;
|
*/ |
| }
|
|
|
|
registre_instruction_courante = (*s_etat_processus) |
| chaine_fonction = purification_chaine(
|
.instruction_courante; |
| extraction_chaine(chaine_centrale, 2, i));
|
registre_test = (*s_etat_processus).test_instruction; |
| chaine_arguments = purification_chaine(
|
registre_instruction_valide = (*s_etat_processus) |
| extraction_chaine(chaine_centrale, i + 2, j));
|
.instruction_valide; |
|
|
|
| i = 0;
|
(*s_etat_processus).test_instruction = 'Y'; |
| niveau = 0;
|
(*s_etat_processus).instruction_courante = tampon; |
| nombre_arguments = 1;
|
|
|
|
analyse(s_etat_processus, NULL); |
| while(chaine_arguments[i] != d_code_fin_chaine)
|
|
| {
|
(*s_etat_processus).test_instruction = registre_test; |
| if (chaine_arguments[i] == '(')
|
(*s_etat_processus).instruction_courante = |
| {
|
registre_instruction_courante; |
| niveau++;
|
|
| }
|
if (((*s_etat_processus).instruction_valide == 'Y') && |
|
|
((*s_etat_processus).constante_symbolique == 'N')) |
| if (chaine_arguments[i] == ')')
|
{ |
| {
|
free(chaine_gauche); |
| niveau--;
|
free(chaine_centrale); |
| }
|
free(chaine_droite); |
|
|
free(tampon); |
| if ((chaine_arguments[i] == ',') && (niveau == 0))
|
|
| {
|
(*s_etat_processus).instruction_valide = |
| sous_chaine_gauche = purification_chaine(
|
registre_instruction_valide; |
| extraction_chaine(chaine_arguments, 1, i));
|
|
| sous_chaine_droite = purification_chaine(
|
(*s_etat_processus).erreur_execution = |
| extraction_chaine(chaine_arguments, i + 2,
|
d_ex_expression_invalide; |
| strlen(chaine_arguments)));
|
return(NULL); |
|
|
} |
| free(chaine_arguments);
|
|
|
|
(*s_etat_processus).instruction_valide = |
| if ((chaine_arguments = (unsigned char *) malloc(
|
registre_instruction_valide; |
| (strlen(sous_chaine_gauche) + strlen(
|
|
| sous_chaine_droite) + 3 + 1) * sizeof(
|
free(chaine_centrale); |
| unsigned char))) == NULL)
|
chaine_centrale = tampon; |
| {
|
|
| (*s_etat_processus).erreur_systeme =
|
fin_zone_algebrique--; |
| d_es_allocation_memoire;
|
drapeau_modification = d_vrai; |
| return(NULL);
|
} |
| }
|
else if ((test_fonction(chaine_centrale) == d_vrai) && |
|
|
(fin_zone_algebrique - debut_zone_algebrique > 0)) |
| sprintf(chaine_arguments, "%s' '%s",
|
{ |
| sous_chaine_gauche, sous_chaine_droite);
|
i = 1; |
| i += 2;
|
while((i < ((integer8) strlen(chaine_centrale)) - 1) && |
|
|
(chaine_centrale[i] != '(')) |
| free(sous_chaine_gauche);
|
{ |
| free(sous_chaine_droite);
|
i++; |
|
|
} |
| nombre_arguments++;
|
|
| }
|
j = ((integer8) strlen(chaine_centrale)) - 1; |
|
|
while(chaine_centrale[j] != ')') |
| i++;
|
{ |
| }
|
j--; |
|
|
} |
| free(chaine_centrale);
|
|
|
|
chaine_fonction = purification_chaine( |
| l_element_courant = (*l_base_liste);
|
extraction_chaine(chaine_centrale, 2, i)); |
| presence_fonction = d_faux;
|
chaine_arguments = purification_chaine( |
|
|
extraction_chaine(chaine_centrale, i + 2, j)); |
| while((l_element_courant != NULL) &&
|
|
| (presence_fonction == d_faux))
|
i = 0; |
| {
|
niveau = 0; |
| if (strcmp((*((struct_fonction *) ((*l_element_courant)
|
nombre_arguments = 1; |
| .donnee))).nom_fonction, chaine_fonction) == 0)
|
|
| {
|
while(chaine_arguments[i] != d_code_fin_chaine) |
| presence_fonction = d_vrai;
|
{ |
| }
|
if (chaine_arguments[i] == '(') |
| else
|
{ |
| {
|
niveau++; |
| l_element_courant = (*l_element_courant).suivant;
|
} |
| }
|
|
| }
|
if (chaine_arguments[i] == ')') |
|
|
{ |
| if (presence_fonction == d_vrai)
|
niveau--; |
| {
|
} |
| if ((*((struct_fonction *)
|
|
| ((*l_element_courant).donnee)))
|
if ((chaine_arguments[i] == ',') && (niveau == 0)) |
| .nombre_arguments != nombre_arguments)
|
{ |
| {
|
sous_chaine_gauche = purification_chaine( |
| (*s_etat_processus).erreur_execution =
|
extraction_chaine(chaine_arguments, 1, i)); |
| d_ex_nombre_arguments;
|
sous_chaine_droite = purification_chaine( |
|
|
extraction_chaine(chaine_arguments, i + 2, |
| free(chaine_arguments);
|
((integer8) strlen(chaine_arguments)))); |
| free(chaine_fonction);
|
|
| free(chaine_gauche);
|
free(chaine_arguments); |
| free(chaine_droite);
|
|
|
|
if ((chaine_arguments = (unsigned char *) malloc( |
| return(NULL);
|
(strlen(sous_chaine_gauche) + strlen( |
| }
|
sous_chaine_droite) + 3 + 1) * sizeof( |
| }
|
unsigned char))) == NULL) |
| else
|
{ |
| {
|
(*s_etat_processus).erreur_systeme = |
| registre_instruction_courante = (*s_etat_processus)
|
d_es_allocation_memoire; |
| .instruction_courante;
|
return(NULL); |
| registre_test = (*s_etat_processus).test_instruction;
|
} |
| registre_instruction_valide = (*s_etat_processus)
|
|
| .instruction_valide;
|
sprintf(chaine_arguments, "%s' '%s", |
|
|
sous_chaine_gauche, sous_chaine_droite); |
| (*s_etat_processus).test_instruction = 'Y';
|
i += 2; |
| (*s_etat_processus).instruction_courante =
|
|
| chaine_fonction;
|
free(sous_chaine_gauche); |
|
|
free(sous_chaine_droite); |
| analyse(s_etat_processus, NULL);
|
|
|
|
nombre_arguments++; |
| (*s_etat_processus).test_instruction = registre_test;
|
} |
| (*s_etat_processus).instruction_courante =
|
|
| registre_instruction_courante;
|
i++; |
| (*s_etat_processus).instruction_valide =
|
} |
| registre_instruction_valide;
|
|
|
|
free(chaine_centrale); |
| if (((unsigned long) (*s_etat_processus)
|
|
| .nombre_arguments != nombre_arguments) &&
|
l_element_courant = (*l_base_liste); |
| ((*s_etat_processus).nombre_arguments != -2))
|
presence_fonction = d_faux; |
| {
|
|
| (*s_etat_processus).erreur_execution =
|
while((l_element_courant != NULL) && |
| d_ex_nombre_arguments_fonction;
|
(presence_fonction == d_faux)) |
|
|
{ |
| free(chaine_arguments);
|
if (strcmp((*((struct_fonction *) ((*l_element_courant) |
| free(chaine_fonction);
|
.donnee))).nom_fonction, chaine_fonction) == 0) |
| free(chaine_gauche);
|
{ |
| free(chaine_droite);
|
presence_fonction = d_vrai; |
|
|
} |
| return(NULL);
|
else |
| }
|
{ |
|
|
l_element_courant = (*l_element_courant).suivant; |
| if ((l_element_courant = (struct_liste_chainee *)
|
} |
| malloc(sizeof(struct_liste_chainee))) == NULL)
|
} |
| {
|
|
| (*s_etat_processus).erreur_systeme =
|
if (presence_fonction == d_vrai) |
| d_es_allocation_memoire;
|
{ |
| return(NULL);
|
if ((*((struct_fonction *) |
| }
|
((*l_element_courant).donnee))) |
|
|
.nombre_arguments != nombre_arguments) |
| (*l_element_courant).suivant = (*l_base_liste);
|
{ |
| (*l_base_liste) = l_element_courant;
|
(*s_etat_processus).erreur_execution = |
|
|
d_ex_nombre_arguments; |
| if ((s_fonction = malloc(sizeof(struct_fonction)))
|
|
| == NULL)
|
free(chaine_arguments); |
| {
|
free(chaine_fonction); |
| (*s_etat_processus).erreur_systeme =
|
free(chaine_gauche); |
| d_es_allocation_memoire;
|
free(chaine_droite); |
| return(NULL);
|
|
| }
|
return(NULL); |
|
|
} |
| if (((*s_fonction).nom_fonction = (unsigned char *)
|
} |
| malloc((strlen(chaine_fonction) + 1) *
|
else |
| sizeof(unsigned char))) == NULL)
|
{ |
| {
|
registre_instruction_courante = (*s_etat_processus) |
| (*s_etat_processus).erreur_systeme =
|
.instruction_courante; |
| d_es_allocation_memoire;
|
registre_test = (*s_etat_processus).test_instruction; |
| return(NULL);
|
registre_instruction_valide = (*s_etat_processus) |
| }
|
.instruction_valide; |
|
|
|
| strcpy((*s_fonction).nom_fonction, chaine_fonction);
|
(*s_etat_processus).test_instruction = 'Y'; |
| (*s_fonction).nombre_arguments = nombre_arguments;
|
(*s_etat_processus).instruction_courante = |
|
|
chaine_fonction; |
| (*(*l_base_liste)).donnee = (void *) s_fonction;
|
|
| }
|
analyse(s_etat_processus, NULL); |
|
|
|
| if ((chaine_centrale = (unsigned char *) malloc((strlen(
|
(*s_etat_processus).test_instruction = registre_test; |
| chaine_arguments) + 1 + strlen(chaine_fonction)
|
(*s_etat_processus).instruction_courante = |
| + 1 + 2) * sizeof(unsigned char))) == NULL)
|
registre_instruction_courante; |
| {
|
(*s_etat_processus).instruction_valide = |
| (*s_etat_processus).erreur_systeme =
|
registre_instruction_valide; |
| d_es_allocation_memoire;
|
|
| return(NULL);
|
if (((*s_etat_processus).nombre_arguments != |
| }
|
nombre_arguments) && |
|
|
((*s_etat_processus).nombre_arguments != -2)) |
| sprintf(chaine_centrale, "'%s' %s", chaine_arguments,
|
{ |
| chaine_fonction);
|
(*s_etat_processus).erreur_execution = |
| drapeau_modification = d_vrai;
|
d_ex_nombre_arguments_fonction; |
|
|
|
| free(chaine_arguments);
|
free(chaine_arguments); |
| free(chaine_fonction);
|
free(chaine_fonction); |
| }
|
free(chaine_gauche); |
| else if ((chaine_centrale[1] == '+') ||
|
free(chaine_droite); |
| (chaine_centrale[1] == '-'))
|
|
| {
|
return(NULL); |
| if (chaine_centrale[1] == '-')
|
} |
| {
|
|
| tampon = chaine_centrale;
|
if ((l_element_courant = (struct_liste_chainee *) |
|
|
malloc(sizeof(struct_liste_chainee))) == NULL) |
| if ((chaine_centrale = (unsigned char *) malloc(
|
{ |
| (strlen(tampon) + 5) * sizeof(unsigned char)))
|
(*s_etat_processus).erreur_systeme = |
| == NULL)
|
d_es_allocation_memoire; |
| {
|
return(NULL); |
| (*s_etat_processus).erreur_systeme =
|
} |
| d_es_allocation_memoire;
|
|
| return(NULL);
|
(*l_element_courant).suivant = (*l_base_liste); |
| }
|
(*l_base_liste) = l_element_courant; |
|
|
|
| tampon[strlen(tampon) - 1] = d_code_fin_chaine;
|
if ((s_fonction = malloc(sizeof(struct_fonction))) |
| sprintf(chaine_centrale, "'NEG(%s)'", &(tampon[2]));
|
== NULL) |
| fin_zone_algebrique += 5;
|
{ |
| drapeau_modification = d_vrai;
|
(*s_etat_processus).erreur_systeme = |
|
|
d_es_allocation_memoire; |
| free(tampon);
|
return(NULL); |
| }
|
} |
| else
|
|
| {
|
if (((*s_fonction).nom_fonction = (unsigned char *) |
| tampon = chaine_centrale;
|
malloc((strlen(chaine_fonction) + 1) * |
|
|
sizeof(unsigned char))) == NULL) |
| if ((chaine_centrale = (unsigned char *) malloc(
|
{ |
| (strlen(tampon) + 7) * sizeof(unsigned char)))
|
(*s_etat_processus).erreur_systeme = |
| == NULL)
|
d_es_allocation_memoire; |
| {
|
return(NULL); |
| (*s_etat_processus).erreur_systeme =
|
} |
| d_es_allocation_memoire;
|
|
| return(NULL);
|
strcpy((*s_fonction).nom_fonction, chaine_fonction); |
| }
|
(*s_fonction).nombre_arguments = nombre_arguments; |
|
|
|
| tampon[strlen(tampon) - 1] = d_code_fin_chaine;
|
(*(*l_base_liste)).donnee = (void *) s_fonction; |
| sprintf(chaine_centrale, "'RELAX(%s)'", &(tampon[2]));
|
} |
| fin_zone_algebrique += 7;
|
|
| drapeau_modification = d_vrai;
|
if ((chaine_centrale = (unsigned char *) malloc((strlen( |
|
|
chaine_arguments) + 1 + strlen(chaine_fonction) |
| free(tampon);
|
+ 1 + 2) * sizeof(unsigned char))) == NULL) |
| }
|
{ |
| }
|
(*s_etat_processus).erreur_systeme = |
|
|
d_es_allocation_memoire; |
| if ((chaine_travail = (unsigned char *) malloc(
|
return(NULL); |
| (strlen(chaine_gauche) + strlen(chaine_centrale) +
|
} |
| strlen(chaine_droite) + 1 + 2) * sizeof(unsigned char)))
|
|
| == NULL)
|
sprintf(chaine_centrale, "'%s' %s", chaine_arguments, |
| {
|
chaine_fonction); |
| (*s_etat_processus).erreur_systeme =
|
drapeau_modification = d_vrai; |
| d_es_allocation_memoire;
|
|
| return(NULL);
|
free(chaine_arguments); |
| }
|
free(chaine_fonction); |
|
|
} |
| sprintf(chaine_travail, "%s %s %s", chaine_gauche,
|
else if ((chaine_centrale[1] == '+') || |
| chaine_centrale, chaine_droite);
|
(chaine_centrale[1] == '-')) |
|
|
{ |
| free(chaine_gauche);
|
if (chaine_centrale[1] == '-') |
| free(chaine_centrale);
|
{ |
| free(chaine_droite);
|
tampon = chaine_centrale; |
| }
|
|
|
|
if ((chaine_centrale = (unsigned char *) malloc( |
| i = fin_zone_algebrique + 1;
|
(strlen(tampon) + 5) * sizeof(unsigned char))) |
| } while((drapeau_debut_zone_valide == d_vrai)
|
== NULL) |
| && (drapeau_fin_zone_valide == d_vrai));
|
{ |
|
|
(*s_etat_processus).erreur_systeme = |
| for(longueur_chaine = strlen(chaine_travail),
|
d_es_allocation_memoire; |
| i = nombre_apostrophes = 0; i < longueur_chaine;
|
return(NULL); |
| nombre_apostrophes += (chaine_travail[i++] == '\'') ? 1 : 0);
|
} |
|
|
|
| if (nombre_apostrophes != 0)
|
tampon[strlen(tampon) - 1] = d_code_fin_chaine; |
| {
|
sprintf(chaine_centrale, "'NEG(%s)'", &(tampon[2])); |
| priorite = 1;
|
fin_zone_algebrique += 5; |
|
|
drapeau_modification = d_vrai; |
| do
|
|
| {
|
free(tampon); |
| drapeau_priorite_entierement_traitee = d_vrai;
|
} |
|
|
else |
| i = 0;
|
{ |
| while((chaine_travail[i] != '\'') && (chaine_travail[i] != 0))
|
tampon = chaine_centrale; |
| {
|
|
| i++;
|
if ((chaine_centrale = (unsigned char *) malloc( |
| }
|
(strlen(tampon) + 7) * sizeof(unsigned char))) |
|
|
== NULL) |
| if (chaine_travail[i] == 0)
|
{ |
| {
|
(*s_etat_processus).erreur_systeme = |
| i = 0;
|
d_es_allocation_memoire; |
| }
|
return(NULL); |
|
|
} |
| j = i + 1;
|
|
| while((chaine_travail[j] != '\'') && (chaine_travail[j] != 0))
|
tampon[strlen(tampon) - 1] = d_code_fin_chaine; |
| {
|
sprintf(chaine_centrale, "'RELAX(%s)'", &(tampon[2])); |
| j++;
|
fin_zone_algebrique += 7; |
| }
|
drapeau_modification = d_vrai; |
|
|
|
| if (chaine_travail[j] == 0)
|
free(tampon); |
| {
|
} |
| j = 0;
|
} |
| }
|
|
|
|
if ((chaine_travail = (unsigned char *) malloc( |
| if ((chaine_travail[i] != 0) && (j != 0))
|
(strlen(chaine_gauche) + strlen(chaine_centrale) + |
| {
|
strlen(chaine_droite) + 1 + 2) * sizeof(unsigned char))) |
| chaine_gauche = purification_chaine(
|
== NULL) |
| extraction_chaine(chaine_travail, 1, i));
|
{ |
| chaine_centrale = purification_chaine(
|
(*s_etat_processus).erreur_systeme = |
| extraction_chaine(chaine_travail,
|
d_es_allocation_memoire; |
| i + 1, j + 1));
|
return(NULL); |
| chaine_droite = purification_chaine(
|
} |
| extraction_chaine(chaine_travail, j + 2,
|
|
| strlen(chaine_travail)));
|
sprintf(chaine_travail, "%s %s %s", chaine_gauche, |
|
|
chaine_centrale, chaine_droite); |
| if ((chaine_gauche == NULL) || (chaine_centrale == NULL) ||
|
|
| (chaine_droite == NULL))
|
free(chaine_gauche); |
| {
|
free(chaine_centrale); |
| (*s_etat_processus).erreur_systeme =
|
free(chaine_droite); |
| d_es_allocation_memoire;
|
} |
| return(NULL);
|
|
| }
|
i = fin_zone_algebrique + 1; |
|
|
} while((drapeau_debut_zone_valide == d_vrai) |
| drapeau_elimination_parentheses = d_vrai;
|
&& (drapeau_fin_zone_valide == d_vrai)); |
|
|
|
| if ((longueur_tampon = strlen(chaine_centrale)) != 0)
|
for(longueur_chaine = (integer8) strlen(chaine_travail), |
| {
|
i = nombre_apostrophes = 0; i < longueur_chaine; |
| niveau = 0;
|
nombre_apostrophes += (chaine_travail[i++] == '\'') ? 1 : 0); |
|
|
|
| for(i = 1; i < longueur_tampon - 1; i++)
|
if (nombre_apostrophes != 0) |
| {
|
{ |
| if (chaine_centrale[i] == '(')
|
priorite = 1; |
| {
|
|
| niveau++;
|
do |
| }
|
{ |
|
|
drapeau_priorite_entierement_traitee = d_vrai; |
| if ((niveau == 0) || ((((test_cfsf(s_etat_processus,
|
|
| 48) == d_vrai) && (chaine_centrale[i] ==
|
i = 0; |
| '.')) || ((test_cfsf(s_etat_processus, 48)
|
while((chaine_travail[i] != '\'') && (chaine_travail[i] != 0)) |
| == d_faux) && (chaine_centrale[i] == ',')))
|
{ |
| && (niveau == 1)))
|
i++; |
| {
|
} |
| drapeau_elimination_parentheses = d_faux;
|
|
| }
|
if (chaine_travail[i] == 0) |
|
|
{ |
| if (chaine_centrale[i] == ')')
|
i = 0; |
| {
|
} |
| niveau--;
|
|
| }
|
j = i + 1; |
| }
|
while((chaine_travail[j] != '\'') && (chaine_travail[j] != 0)) |
|
|
{ |
| if (drapeau_elimination_parentheses == d_vrai)
|
j++; |
| {
|
} |
| if ((tampon = (unsigned char *) malloc(
|
|
| ((longueur_tampon = strlen(
|
if (chaine_travail[j] == 0) |
| chaine_centrale)) + 1) * sizeof(
|
{ |
| unsigned char))) == NULL)
|
j = 0; |
| {
|
} |
| (*s_etat_processus).erreur_systeme =
|
|
| d_es_allocation_memoire;
|
if ((chaine_travail[i] != 0) && (j != 0)) |
| return(NULL);
|
{ |
| }
|
chaine_gauche = purification_chaine( |
|
|
extraction_chaine(chaine_travail, 1, i)); |
| chaine_centrale[longueur_tampon - 2] =
|
chaine_centrale = purification_chaine( |
| d_code_fin_chaine;
|
extraction_chaine(chaine_travail, |
| sprintf(tampon, "'%s'", &(chaine_centrale[2]));
|
i + 1, j + 1)); |
| free(chaine_centrale);
|
chaine_droite = purification_chaine( |
| chaine_centrale = tampon;
|
extraction_chaine(chaine_travail, j + 2, |
| drapeau_modification = d_vrai;
|
((integer8) strlen(chaine_travail)))); |
| }
|
|
| }
|
if ((chaine_gauche == NULL) || (chaine_centrale == NULL) || |
|
|
(chaine_droite == NULL)) |
| if ((tampon = (unsigned char *) malloc(sizeof(
|
{ |
| unsigned char))) == NULL)
|
(*s_etat_processus).erreur_systeme = |
| {
|
d_es_allocation_memoire; |
| (*s_etat_processus).erreur_systeme =
|
return(NULL); |
| d_es_allocation_memoire;
|
} |
| return(NULL);
|
|
| }
|
drapeau_elimination_parentheses = d_vrai; |
|
|
|
| tampon[0] = d_code_fin_chaine;
|
if ((longueur_tampon = ((integer8) strlen(chaine_centrale))) |
| longueur_chaine = strlen(chaine_centrale);
|
!= 0) |
| niveau = 0;
|
{ |
| k = strlen(chaine_centrale) - 1;
|
niveau = 0; |
| fin_boucle_extraction = d_faux;
|
|
|
|
for(i = 1; i < longueur_tampon - 1; i++) |
| while((k >= 0) && (fin_boucle_extraction ==
|
{ |
| d_faux))
|
if (chaine_centrale[i] == '(') |
| {
|
{ |
| t0 = ((size_t) k < strlen(chaine_centrale))
|
niveau++; |
| ? chaine_centrale[k + 1] : ' ';
|
} |
| t1 = chaine_centrale[k];
|
|
| t2 = (k < 1) ? ' ' : chaine_centrale[k - 1];
|
if ((niveau == 0) || ((((test_cfsf(s_etat_processus, |
| t3 = (k < 2) ? ' ' : chaine_centrale[k - 2];
|
48) == d_vrai) && (chaine_centrale[i] == |
| t4 = (k < 3) ? ' ' : chaine_centrale[k - 3];
|
'.')) || ((test_cfsf(s_etat_processus, 48) |
|
|
== d_faux) && (chaine_centrale[i] == ','))) |
| if ((t0 >= 'a') && (t0 <= 'z'))
|
&& (niveau == 1))) |
| {
|
{ |
| t0 = t0 + ('A' - 'a');
|
drapeau_elimination_parentheses = d_faux; |
| }
|
} |
|
|
|
| if ((t1 >= 'a') && (t1 <= 'z'))
|
if (chaine_centrale[i] == ')') |
| {
|
{ |
| t1 = t1 + ('A' - 'a');
|
niveau--; |
| }
|
} |
|
|
} |
| if ((t2 >= 'a') && (t2 <= 'z'))
|
|
| {
|
if (drapeau_elimination_parentheses == d_vrai) |
| t2 = t2 + ('A' - 'a');
|
{ |
| }
|
if ((tampon = (unsigned char *) malloc(((size_t) |
|
|
((longueur_tampon = (integer8) strlen( |
| if ((t3 >= 'a') && (t3 <= 'z'))
|
chaine_centrale)) + 1)) * sizeof( |
| {
|
unsigned char))) == NULL) |
| t3 = t3 + ('A' - 'a');
|
{ |
| }
|
(*s_etat_processus).erreur_systeme = |
|
|
d_es_allocation_memoire; |
| if ((t4 >= 'a') && (t4 <= 'z'))
|
return(NULL); |
| {
|
} |
| t4 = t4 + ('A' - 'a');
|
|
| }
|
chaine_centrale[longueur_tampon - 2] = |
|
|
d_code_fin_chaine; |
| if (t1 == '(')
|
sprintf(tampon, "'%s'", &(chaine_centrale[2])); |
| {
|
free(chaine_centrale); |
| niveau++;
|
chaine_centrale = tampon; |
| }
|
drapeau_modification = d_vrai; |
|
|
} |
| if (niveau == 0)
|
} |
| {
|
|
| prologue = purification_chaine(
|
if ((tampon = (unsigned char *) malloc(sizeof( |
| extraction_chaine(chaine_centrale, 1, k));
|
unsigned char))) == NULL) |
| epilogue = purification_chaine(
|
{ |
| extraction_chaine(chaine_centrale,
|
(*s_etat_processus).erreur_systeme = |
| k + 2, longueur_chaine));
|
d_es_allocation_memoire; |
|
|
return(NULL); |
| if ((prologue == NULL) || (epilogue == NULL))
|
} |
| {
|
|
| (*s_etat_processus).erreur_systeme =
|
tampon[0] = d_code_fin_chaine; |
| d_es_allocation_memoire;
|
longueur_chaine = (integer8) strlen(chaine_centrale); |
| return(NULL);
|
k = ((integer8) strlen(chaine_centrale)) - 1; |
| }
|
niveau = 0; |
|
|
fin_boucle_extraction = d_faux; |
| /*
|
|
| * Priorité = 1 : traitement des fonctions les plus prioritaires
|
while((k >= 0) && (fin_boucle_extraction == d_faux)) |
| */
|
{ |
|
|
t0 = (k < ((integer8) strlen(chaine_centrale))) |
| if (((priorite == 4) && (((t1 == '<') && (t0 != '=')
|
? chaine_centrale[k + 1] : ' '; |
| && (t2 != '=')) || ((t1 == '>') &&
|
t1 = chaine_centrale[k]; |
| (t0 != '=') && (t2 != '=')) ||
|
t2 = (k < 1) ? ' ' : chaine_centrale[k - 1]; |
| ((t1 == '=') && (t0 != '=') && (t0 != '<')
|
t3 = (k < 2) ? ' ' : chaine_centrale[k - 2]; |
| && (t0 != '>') && (t2 != '<') && (t2 != '>')
|
t4 = (k < 3) ? ' ' : chaine_centrale[k - 3]; |
| && (t2 != '=')))) ||
|
|
| ((t1 == '+') && (priorite == 5) &&
|
if ((t0 >= 'a') && (t0 <= 'z')) |
| (t2 != '\'') && (!(((t2 == '(')
|
{ |
| || (t2 == '\'') || (t2 == 'e')
|
t0 = t0 + ('A' - 'a'); |
| || (t2 == 'E')) && (((t3 >= '0')
|
} |
| && (t3 <= '9')) || (t3 == '.'))))) ||
|
|
| ((t1 == '-') && (priorite == 6) &&
|
if ((t1 >= 'a') && (t1 <= 'z')) |
| (t2 != '\'') && (!(((t2 == '(')
|
{ |
| || (t2 == '\'') || (t2 == 'e')
|
t1 = t1 + ('A' - 'a'); |
| || (t2 == 'E')) && (((t3 >= '0')
|
} |
| && (t3 <= '9')) || (t3 == '.')))))
|
|
| || ((t1 == '*') && (priorite == 7))
|
if ((t2 >= 'a') && (t2 <= 'z')) |
| || ((t1 == '/') && (priorite == 8)) ||
|
{ |
| ((t1 == '^') && (priorite == 9)))
|
t2 = t2 + ('A' - 'a'); |
| {
|
} |
| drapeau_priorite_entierement_traitee = d_faux;
|
|
| fin_boucle_extraction = d_vrai;
|
if ((t3 >= 'a') && (t3 <= 'z')) |
|
|
{ |
| free(tampon);
|
t3 = t3 + ('A' - 'a'); |
|
|
} |
| if ((tampon = (unsigned char *)
|
|
| malloc((strlen(prologue) +
|
if ((t4 >= 'a') && (t4 <= 'z')) |
| strlen(epilogue) + 6) *
|
{ |
| sizeof(unsigned char))) == NULL)
|
t4 = t4 + ('A' - 'a'); |
| {
|
} |
| (*s_etat_processus).erreur_systeme =
|
|
| d_es_allocation_memoire;
|
if (t1 == '(') |
| return(NULL);
|
{ |
| }
|
niveau++; |
|
|
} |
| sprintf(tampon, "%s' '%s %c",
|
|
| prologue, epilogue, t1);
|
if (niveau == 0) |
| drapeau_modification = d_vrai;
|
{ |
| }
|
prologue = purification_chaine( |
| else if (((priorite == 4) && (((t1 == '<') &&
|
extraction_chaine(chaine_centrale, 1, k)); |
| (t2 == '=')) || ((t1 == '=') &&
|
epilogue = purification_chaine( |
| (t2 == '<')) || ((t1 == '>') &&
|
extraction_chaine(chaine_centrale, |
| (t2 == '<')) || (((t1 == '>') &&
|
k + 2, longueur_chaine)); |
| (t2 == '=')) || ((t1 == '=') &&
|
|
| (t2 == '>')) || ((t1 == '=') &&
|
if ((prologue == NULL) || (epilogue == NULL)) |
| (t2 == '='))))) || ((priorite == 1) &&
|
{ |
| (t1 == 'R') && (t2 == 'O') && (t3 == ' ')
|
(*s_etat_processus).erreur_systeme = |
| && (t0 == ' ')))
|
d_es_allocation_memoire; |
| {
|
return(NULL); |
| drapeau_priorite_entierement_traitee = d_faux;
|
} |
| fin_boucle_extraction = d_vrai;
|
|
|
|
/* |
| free(tampon);
|
* Priorité = 1 : traitement des fonctions les plus prioritaires |
|
|
*/ |
| if ((tampon = (unsigned char *)
|
|
| malloc((strlen(prologue) +
|
if (((priorite == 4) && (((t1 == '<') && (t0 != '=') |
| strlen(epilogue) + 6) *
|
&& (t2 != '=')) || ((t1 == '>') && |
| sizeof(unsigned char))) == NULL)
|
(t0 != '=') && (t2 != '=')) || |
| {
|
((t1 == '=') && (t0 != '=') && (t0 != '<') |
| (*s_etat_processus).erreur_systeme =
|
&& (t0 != '>') && (t2 != '<') && (t2 != '>') |
| d_es_allocation_memoire;
|
&& (t2 != '=')))) || |
| return(NULL);
|
((t1 == '+') && (priorite == 5) && |
| }
|
(t2 != '\'') && (!(((t2 == '(') |
|
|
|| (t2 == '\'') || (t2 == 'e') |
| prologue[strlen(prologue) - 1] =
|
|| (t2 == 'E')) && (((t3 >= '0') |
| d_code_fin_chaine;
|
&& (t3 <= '9')) || (t3 == '.'))))) || |
|
|
((t1 == '-') && (priorite == 6) && |
| sprintf(tampon, "%s' '%s %c%c", prologue,
|
(t2 != '\'') && (!(((t2 == '(') |
| epilogue, t2, t1);
|
|| (t2 == '\'') || (t2 == 'e') |
| drapeau_modification = d_vrai;
|
|| (t2 == 'E')) && (((t3 >= '0') |
| }
|
&& (t3 <= '9')) || (t3 == '.'))))) |
| else if (((priorite == 1) && (t4 == ' ') &&
|
|| ((t1 == '*') && (priorite == 7)) |
| (t3 == 'X') && (t2 == 'O') && (t1 == 'R')
|
|| ((t1 == '/') && (priorite == 8)) || |
| && (t0 == ' ')) || ((priorite == 2) &&
|
((t1 == '^') && (priorite == 9))) |
| (t4 == ' ') && (t3 == 'A') && (t2 == 'N')
|
{ |
| && (t1 == 'D') && (t0 == ' ')))
|
drapeau_priorite_entierement_traitee = d_faux; |
| {
|
fin_boucle_extraction = d_vrai; |
| drapeau_priorite_entierement_traitee = d_faux;
|
|
| fin_boucle_extraction = d_vrai;
|
free(tampon); |
|
|
|
| free(tampon);
|
if ((tampon = (unsigned char *) |
|
|
malloc((strlen(prologue) + |
| if ((tampon = (unsigned char *)
|
strlen(epilogue) + 6) * |
| malloc((strlen(prologue) +
|
sizeof(unsigned char))) == NULL) |
| strlen(epilogue) + 5) *
|
{ |
| sizeof(unsigned char))) == NULL)
|
(*s_etat_processus).erreur_systeme = |
| {
|
d_es_allocation_memoire; |
| (*s_etat_processus).erreur_systeme =
|
return(NULL); |
| d_es_allocation_memoire;
|
} |
| return(NULL);
|
|
| }
|
sprintf(tampon, "%s' '%s %c", |
|
|
prologue, epilogue, t1); |
| prologue[strlen(prologue) - 3] =
|
drapeau_modification = d_vrai; |
| d_code_fin_chaine;
|
} |
|
|
else if (((priorite == 4) && (((t1 == '<') && |
| sprintf(tampon, "%s' '%s %c%c%c", prologue,
|
(t2 == '=')) || ((t1 == '=') && |
| epilogue, t3, t2, t1);
|
(t2 == '<')) || ((t1 == '>') && |
| drapeau_modification = d_vrai;
|
(t2 == '<')) || (((t1 == '>') && |
| }
|
(t2 == '=')) || ((t1 == '=') && |
|
|
(t2 == '>')) || ((t1 == '=') && |
| free(prologue);
|
(t2 == '='))))) || ((priorite == 1) && |
| free(epilogue);
|
(t1 == 'R') && (t2 == 'O') && (t3 == ' ') |
| }
|
&& (t0 == ' '))) |
|
|
{ |
| if (t1 == ')')
|
drapeau_priorite_entierement_traitee = d_faux; |
| {
|
fin_boucle_extraction = d_vrai; |
| niveau--;
|
|
| }
|
free(tampon); |
|
|
|
| k--;
|
if ((tampon = (unsigned char *) |
| }
|
malloc((strlen(prologue) + |
|
|
strlen(epilogue) + 6) * |
| if (drapeau_priorite_entierement_traitee == d_vrai)
|
sizeof(unsigned char))) == NULL) |
| {
|
{ |
| free(tampon);
|
(*s_etat_processus).erreur_systeme = |
|
|
d_es_allocation_memoire; |
| if ((tampon = (unsigned char *) malloc(
|
return(NULL); |
| (strlen(chaine_centrale) + 1) *
|
} |
| sizeof(unsigned char))) == NULL)
|
|
| {
|
prologue[strlen(prologue) - 1] = |
| (*s_etat_processus).erreur_systeme =
|
d_code_fin_chaine; |
| d_es_allocation_memoire;
|
|
| return(NULL);
|
sprintf(tampon, "%s' '%s %c%c", prologue, |
| }
|
epilogue, t2, t1); |
|
|
drapeau_modification = d_vrai; |
| strcpy(tampon, chaine_centrale);
|
} |
| }
|
else if (((priorite == 1) && (t4 == ' ') && |
|
|
(t3 == 'X') && (t2 == 'O') && (t1 == 'R') |
| free(chaine_centrale);
|
&& (t0 == ' ')) || ((priorite == 2) && |
| free(chaine_travail);
|
(t4 == ' ') && (t3 == 'A') && (t2 == 'N') |
|
|
&& (t1 == 'D') && (t0 == ' '))) |
| if ((chaine_travail = (unsigned char *) malloc(
|
{ |
| (strlen(chaine_gauche) + strlen(tampon)
|
drapeau_priorite_entierement_traitee = d_faux; |
| + strlen(chaine_droite) + 1 + 2)
|
fin_boucle_extraction = d_vrai; |
| * sizeof(unsigned char))) == NULL)
|
|
| {
|
free(tampon); |
| (*s_etat_processus).erreur_systeme =
|
|
| d_es_allocation_memoire;
|
if ((tampon = (unsigned char *) |
| return(NULL);
|
malloc((strlen(prologue) + |
| }
|
strlen(epilogue) + 5) * |
|
|
sizeof(unsigned char))) == NULL) |
| sprintf(chaine_travail, "%s %s %s", chaine_gauche,
|
{ |
| tampon, chaine_droite);
|
(*s_etat_processus).erreur_systeme = |
|
|
d_es_allocation_memoire; |
| free(chaine_gauche);
|
return(NULL); |
| free(tampon);
|
} |
| free(chaine_droite);
|
|
| }
|
prologue[strlen(prologue) - 3] = |
|
|
d_code_fin_chaine; |
| if (drapeau_priorite_entierement_traitee == d_vrai)
|
|
| {
|
sprintf(tampon, "%s' '%s %c%c%c", prologue, |
| priorite++;
|
epilogue, t3, t2, t1); |
| }
|
drapeau_modification = d_vrai; |
| else
|
} |
| {
|
|
| priorite = 1;
|
free(prologue); |
| }
|
free(epilogue); |
| } while(priorite < 10);
|
} |
|
|
|
| /*
|
if (t1 == ')') |
| * Aucune modification n'a pu être faite sur l'expression
|
{ |
| * algébrique.
|
niveau--; |
| */
|
} |
|
|
|
| if (drapeau_modification == d_faux)
|
k--; |
| {
|
} |
| free(chaine_travail);
|
|
|
|
if (drapeau_priorite_entierement_traitee == d_vrai) |
| (*s_etat_processus).erreur_execution = d_ex_syntaxe;
|
{ |
| return(NULL);
|
free(tampon); |
| }
|
|
| }
|
if ((tampon = (unsigned char *) malloc( |
| } while(nombre_apostrophes != 0);
|
(strlen(chaine_centrale) + 1) * |
|
|
sizeof(unsigned char))) == NULL) |
| tampon = chaine_travail;
|
{ |
|
|
(*s_etat_processus).erreur_systeme = |
| if ((chaine_travail = (unsigned char *) malloc((strlen(tampon) + 1 + 6) *
|
d_es_allocation_memoire; |
| sizeof(unsigned char))) == NULL)
|
return(NULL); |
| {
|
} |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
|
|
| return(NULL);
|
strcpy(tampon, chaine_centrale); |
| }
|
} |
|
|
|
| sprintf(chaine_travail, "<< %s >>", tampon);
|
free(chaine_centrale); |
| free(tampon);
|
free(chaine_travail); |
|
|
|
| return(chaine_travail);
|
if ((chaine_travail = (unsigned char *) malloc( |
| }
|
(strlen(chaine_gauche) + strlen(tampon) |
|
|
+ strlen(chaine_droite) + 1 + 2) |
|
|
* sizeof(unsigned char))) == NULL) |
| unsigned char *
|
{ |
| purification_chaine(unsigned char *chaine)
|
(*s_etat_processus).erreur_systeme = |
| {
|
d_es_allocation_memoire; |
| long i;
|
return(NULL); |
| long j;
|
} |
|
|
|
| unsigned char *chaine_purifiee;
|
sprintf(chaine_travail, "%s %s %s", chaine_gauche, |
|
|
tampon, chaine_droite); |
| i = 0;
|
|
| j = strlen(chaine) - 1;
|
free(chaine_gauche); |
|
|
free(tampon); |
| while(chaine[i] == ' ')
|
free(chaine_droite); |
| {
|
} |
| if ((i++) > j)
|
|
| {
|
if (drapeau_priorite_entierement_traitee == d_vrai) |
| i = j;
|
{ |
| break;
|
priorite++; |
| }
|
} |
| }
|
else |
|
|
{ |
| if (j >= 0)
|
priorite = 1; |
| {
|
} |
| while(chaine[j] == ' ')
|
} while(priorite < 10); |
| {
|
|
| if ((--j) < 0)
|
/* |
| {
|
* Aucune modification n'a pu être faite sur l'expression |
| j = 0;
|
* algébrique. |
| break;
|
*/ |
| }
|
|
| }
|
if (drapeau_modification == d_faux) |
| }
|
{ |
|
|
free(chaine_travail); |
| chaine_purifiee = extraction_chaine(chaine, i + 1, j + 1);
|
|
| free(chaine);
|
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
|
|
return(NULL); |
| return(chaine_purifiee);
|
} |
| }
|
} |
|
|
} while(nombre_apostrophes != 0); |
|
|
|
| logical1
|
tampon = chaine_travail; |
| test_expression_rpn(unsigned char *chaine)
|
|
| {
|
if ((chaine_travail = (unsigned char *) malloc((strlen(tampon) + 1 + 6) * |
| long j;
|
sizeof(unsigned char))) == NULL) |
|
|
{ |
| unsigned char t;
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| unsigned char t0;
|
return(NULL); |
| unsigned char t1;
|
} |
| unsigned char t2;
|
|
| unsigned char t3;
|
sprintf(chaine_travail, "<< %s >>", tampon); |
| unsigned char t4;
|
free(tampon); |
|
|
|
| unsigned long compteur;
|
return(chaine_travail); |
| unsigned long longueur_chaine;
|
} |
| unsigned long i;
|
|
| unsigned long niveau;
|
|
|
|
unsigned char * |
| /*
|
purification_chaine(unsigned char *chaine) |
| * On teste d'abord la chaîne pour vérifier qu'il n'y a pas de fonction
|
{ |
| * utilisant la notation infixe.
|
integer8 i; |
| */
|
integer8 j; |
|
|
|
| compteur = 0;
|
unsigned char *chaine_purifiee; |
|
|
|
| for(longueur_chaine = strlen(chaine), i = 1; i < longueur_chaine; i++)
|
i = 0; |
| {
|
j = ((integer8) strlen(chaine)) - 1; |
| /*
|
|
| * On saute les chaînes de caractères
|
while(chaine[i] == ' ') |
| */
|
{ |
|
|
if ((i++) > j) |
| if (chaine[i - 1] == '"')
|
{ |
| {
|
i = j; |
| i++;
|
break; |
| while(chaine[i - 1] != '"')
|
} |
| {
|
} |
| i++;
|
|
| }
|
if (j >= 0) |
| }
|
{ |
|
|
while(chaine[j] == ' ') |
| j = ((long) i) - 2;
|
{ |
| t0 = (i >= 2) ? chaine[i - 2] : '?';
|
if ((--j) < 0) |
| t1 = chaine[i - 1];
|
{ |
| t2 = chaine[i];
|
j = 0; |
| t3 = ((i + 1) < strlen(chaine)) ? chaine[i + 1] : '?';
|
break; |
| t4 = ((i + 2) < strlen(chaine)) ? chaine[i + 2] : '?';
|
} |
|
|
} |
| /*
|
} |
| * Ouverture d'une parenthèse signalant une fonction
|
|
| */
|
chaine_purifiee = extraction_chaine(chaine, i + 1, j + 1); |
|
|
free(chaine); |
| if ((t1 != '+') && (t1 != '-') && (t1 != '*') && (t1 != '/')
|
|
| && (t1 != '\'') && (t2 == '('))
|
return(chaine_purifiee); |
| {
|
} |
| niveau = 0;
|
|
|
|
|
| do
|
logical1 |
| {
|
test_expression_rpn(unsigned char *chaine) |
| if ((t = chaine[i++]) == '(')
|
{ |
| {
|
int t; |
| niveau++;
|
int t0; |
| }
|
int t1; |
| else if (t == ')')
|
int t2; |
| {
|
int t3; |
| niveau--;
|
int t4; |
| }
|
|
| } while(((niveau != 0) || (t != ')')) && (i < longueur_chaine));
|
integer8 compteur; |
|
|
integer8 longueur_chaine; |
| if (i < longueur_chaine)
|
integer8 i; |
| {
|
integer8 j; |
| t2 = chaine[i];
|
integer8 niveau; |
| }
|
|
| else
|
/* |
| {
|
* On teste d'abord la chaîne pour vérifier qu'il n'y a pas de fonction |
| t2 = ' ';
|
* utilisant la notation infixe. |
| }
|
*/ |
| }
|
|
|
|
compteur = 0; |
| /*
|
|
| * Signalement de l'une des quatre opérations et des fonctions
|
for(longueur_chaine = ((integer8) strlen(chaine)), i = 1; |
| * infixes traditionnelles
|
i < longueur_chaine; i++) |
| */
|
{ |
|
|
/* |
| if ((t2 == '+') || (t2 == '-') || (t2 == '*') || (t2 == '/')
|
* On saute les chaînes de caractères |
| || (t2 == '^') || (t2 == '<') || (t2 == '>') || (t2 == '=')
|
*/ |
| || ((t0 == ' ') && ((t1 == 'A') || (t1 == 'a')) &&
|
|
| ((t2 == 'N') || (t2 == 'n')) && ((t3 == 'D') || (t3 == 'd'))
|
if (chaine[i - 1] == '"') |
| && (t4 == ' ')) ||
|
{ |
| ((t0 == ' ') && ((t1 == 'O') || (t1 == 'o')) &&
|
i++; |
| ((t2 == 'R') || (t2 == 'r')) && (t3 == ' ')) ||
|
while(!((chaine[i - 1] == '"') && (chaine[i - 2] != '\\'))) |
| ((t0 == ' ') && ((t1 == 'X') || (t1 == 'x')) &&
|
{ |
| ((t2 == 'O') || (t2 == 'o')) && ((t3 == 'R') || (t3 == 'r'))
|
i++; |
| && (t4 == ' ')))
|
} |
| {
|
} |
| compteur++;
|
|
| }
|
j = i - 2; |
|
|
t0 = (i >= 2) ? chaine[i - 2] : '?'; |
| /*
|
t1 = chaine[i - 1]; |
| * Signalement d'un nombre
|
t2 = chaine[i]; |
| */
|
t3 = ((i + 1) < ((integer8) strlen(chaine))) ? chaine[i + 1] : '?'; |
|
|
t4 = ((i + 2) < ((integer8) strlen(chaine))) ? chaine[i + 2] : '?'; |
| if (((t2 == '+') || (t2 == '-')) && ((t1 == '(')
|
|
| || ((t1 == 'e') || (t1 == 'E') || (t1 == '\'')))
|
/* |
| && (((t0 >= '0') && (t0 <= '9')) || (t0 == '.')))
|
* Ouverture d'une parenthèse signalant une fonction |
| {
|
*/ |
| compteur--;
|
|
| }
|
if ((t1 != '+') && (t1 != '-') && (t1 != '*') && (t1 != '/') |
| else if (((t2 == '+') || (t2 == '-')) && (t1 == '\'') && (j < 0)
|
&& (t1 != '\'') && (t2 == '(')) |
| && (((t3 >= '0') && (t3 <= '9')) || (t3 == '.')))
|
{ |
| {
|
niveau = 0; |
| compteur--;
|
|
| }
|
do |
| }
|
{ |
|
|
if ((t = chaine[i++]) == '(') |
| return(((compteur == 0) && (test_fonction(chaine) == d_faux))
|
{ |
| ? d_vrai : d_faux);
|
niveau++; |
| }
|
} |
|
|
else if (t == ')') |
|
|
{ |
| logical1
|
niveau--; |
| test_fonction(unsigned char *chaine)
|
} |
| {
|
} while(((niveau != 0) || (t != ')')) && (i < longueur_chaine)); |
| logical1 drapeau_fonction;
|
|
|
|
if (i < longueur_chaine) |
| unsigned char t;
|
{ |
|
|
t2 = chaine[i]; |
| unsigned long compteur;
|
} |
| unsigned long i;
|
else |
| unsigned long longueur_chaine;
|
{ |
|
|
t2 = ' '; |
| longueur_chaine = strlen(chaine);
|
} |
| i = 1;
|
} |
|
|
|
| while(((t = chaine[i]) != '(') && (i < (longueur_chaine - 1)))
|
/* |
| {
|
* Signalement de l'une des quatre opérations et des fonctions |
| if ((t == '+') || (t == '-') || (t == '*') ||
|
* infixes traditionnelles |
| (t == '/') || (t == '^') || (t == '>') || (t == '<') ||
|
*/ |
| (t == '='))
|
|
| {
|
if ((t2 == '+') || (t2 == '-') || (t2 == '*') || (t2 == '/') |
| i = longueur_chaine - 1;
|
|| (t2 == '^') || (t2 == '<') || (t2 == '>') || (t2 == '=') |
| }
|
|| ((t0 == ' ') && ((t1 == 'A') || (t1 == 'a')) && |
| else
|
((t2 == 'N') || (t2 == 'n')) && ((t3 == 'D') || (t3 == 'd')) |
| {
|
&& (t4 == ' ')) || |
| i++;
|
((t0 == ' ') && ((t1 == 'O') || (t1 == 'o')) && |
| }
|
((t2 == 'R') || (t2 == 'r')) && (t3 == ' ')) || |
| }
|
((t0 == ' ') && ((t1 == 'X') || (t1 == 'x')) && |
|
|
((t2 == 'O') || (t2 == 'o')) && ((t3 == 'R') || (t3 == 'r')) |
| compteur = 1;
|
&& (t4 == ' '))) |
| drapeau_fonction = ((i < (longueur_chaine - 1)) && (i != 1))
|
{ |
| ? d_vrai : d_faux;
|
compteur++; |
|
|
} |
| for(i++; i < (longueur_chaine - 2); i++)
|
|
| {
|
/* |
| if ((t = chaine[i]) == '(')
|
* Signalement d'un nombre |
| {
|
*/ |
| compteur++;
|
|
| }
|
if (((t2 == '+') || (t2 == '-')) && ((t1 == '(') |
| else if (t == ')')
|
|| ((t1 == 'e') || (t1 == 'E') || (t1 == '\''))) |
| {
|
&& (((t0 >= '0') && (t0 <= '9')) || (t0 == '.'))) |
| compteur--;
|
{ |
| }
|
compteur--; |
|
|
} |
| if (compteur == 0)
|
else if (((t2 == '+') || (t2 == '-')) && (t1 == '\'') && (j < 0) |
| {
|
&& (((t3 >= '0') && (t3 <= '9')) || (t3 == '.'))) |
| drapeau_fonction = d_faux;
|
{ |
| }
|
compteur--; |
| }
|
} |
|
|
} |
| return drapeau_fonction;
|
|
| }
|
return(((compteur == 0) && (test_fonction(chaine) == d_faux)) |
|
|
? d_vrai : d_faux); |
|
|
} |
| unsigned char *
|
|
| extraction_chaine(unsigned char *chaine, unsigned long position_1,
|
|
| unsigned long position_2)
|
logical1 |
| {
|
test_fonction(unsigned char *chaine) |
| long i;
|
{ |
|
|
logical1 drapeau_fonction; |
| unsigned char *pointeur_ecriture;
|
|
| unsigned char *pointeur_lecture;
|
int t; |
| unsigned char *sous_chaine;
|
|
|
|
integer8 compteur; |
| if ((position_1 < 1) || (position_2 < position_1) ||
|
integer8 i; |
| (position_2 > strlen(chaine)))
|
integer8 longueur_chaine; |
| {
|
|
| if ((sous_chaine = (unsigned char *) malloc(sizeof(unsigned char)))
|
longueur_chaine = (integer8) strlen(chaine); |
| == NULL)
|
i = 1; |
| {
|
|
| return(NULL);
|
while(((t = chaine[i]) != '(') && (i < (longueur_chaine - 1))) |
| }
|
{ |
|
|
if ((t == '+') || (t == '-') || (t == '*') || |
| (*sous_chaine) = d_code_fin_chaine;
|
(t == '/') || (t == '^') || (t == '>') || (t == '<') || |
| return(sous_chaine);
|
(t == '=')) |
| }
|
{ |
|
|
i = longueur_chaine - 1; |
| if ((sous_chaine = (unsigned char *)
|
} |
| malloc((position_2 - position_1 + 2) * sizeof(unsigned char)))
|
else |
| == NULL)
|
{ |
| {
|
i++; |
| return(NULL);
|
} |
| }
|
} |
|
|
|
| pointeur_lecture = &(chaine[position_1 - 1]);
|
compteur = 1; |
| pointeur_ecriture = sous_chaine;
|
drapeau_fonction = ((i < (longueur_chaine - 1)) && (i != 1)) |
|
|
? d_vrai : d_faux; |
| for(sous_chaine[i = position_2 - position_1 + 1] = 0; (--i) >= 0;
|
|
| *(pointeur_ecriture++) = *(pointeur_lecture++));
|
for(i++; i < (longueur_chaine - 2); i++) |
|
|
{ |
| return(sous_chaine);
|
if ((t = chaine[i]) == '(') |
| }
|
{ |
|
|
compteur++; |
| // vim: ts=4
|
} |
| |
else if (t == ')') |
| |
{ |
| |
compteur--; |
| |
} |
| |
|
| |
if (compteur == 0) |
| |
{ |
| |
drapeau_fonction = d_faux; |
| |
} |
| |
} |
| |
|
| |
return drapeau_fonction; |
| |
} |
| |
|
| |
|
| |
unsigned char * |
| |
extraction_chaine(unsigned char *chaine, integer8 position_1, |
| |
integer8 position_2) |
| |
{ |
| |
integer8 i; |
| |
|
| |
unsigned char *pointeur_ecriture; |
| |
unsigned char *pointeur_lecture; |
| |
unsigned char *sous_chaine; |
| |
|
| |
if ((position_1 < 1) || (position_2 < position_1) || |
| |
(position_2 > ((integer8) strlen(chaine)))) |
| |
{ |
| |
if ((sous_chaine = (unsigned char *) malloc(sizeof(unsigned char))) |
| |
== NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
|
| |
(*sous_chaine) = d_code_fin_chaine; |
| |
return(sous_chaine); |
| |
} |
| |
|
| |
if ((sous_chaine = (unsigned char *) |
| |
malloc(((size_t) (position_2 - position_1 + 2)) * |
| |
sizeof(unsigned char))) == NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
|
| |
pointeur_lecture = &(chaine[position_1 - 1]); |
| |
pointeur_ecriture = sous_chaine; |
| |
|
| |
for(sous_chaine[i = position_2 - position_1 + 1] = 0; (--i) >= 0; |
| |
*(pointeur_ecriture++) = *(pointeur_lecture++)); |
| |
|
| |
return(sous_chaine); |
| |
} |
| |
|
| |
// vim: ts=4 |
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to analyse_notation_algebrique.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src