Annotation of rpl/src/analyse_notation_algebrique.c, revision 1.1
1.1 ! bertrand 1: /*
! 2: ================================================================================
! 3: RPL/2 (R) version 4.0.9
! 4: Copyright (C) 1989-2010 Dr. BERTRAND Joël
! 5:
! 6: This file is part of RPL/2.
! 7:
! 8: RPL/2 is free software; you can redistribute it and/or modify it
! 9: under the terms of the CeCILL V2 License as published by the french
! 10: CEA, CNRS and INRIA.
! 11:
! 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT
! 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
! 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License
! 15: for more details.
! 16:
! 17: You should have received a copy of the CeCILL License
! 18: along with RPL/2. If not, write to info@cecill.info.
! 19: ================================================================================
! 20: */
! 21:
! 22:
! 23: #include "rpl.conv.h"
! 24:
! 25:
! 26: /*
! 27: ================================================================================
! 28: Analyseur syntaxique d'une expression algébrique
! 29: ================================================================================
! 30: Entrées : chaîne de caractères comprenant l'expression algébrique
! 31: --------------------------------------------------------------------------------
! 32: Sorties : chaîne de caractères contenant l'expression convertie en
! 33: notation polonaise inverse et liste chaînée contenant les diverses
! 34: fonctions.
! 35: --------------------------------------------------------------------------------
! 36: Effets de bord : néant
! 37: ================================================================================
! 38: */
! 39:
! 40: unsigned char *
! 41: analyse_algebrique(struct_processus *s_etat_processus,
! 42: unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste)
! 43: {
! 44: struct_fonction *s_fonction;
! 45:
! 46: struct_liste_chainee *l_element_courant;
! 47:
! 48: logical1 chaine_invalide;
! 49: logical1 drapeau_debut_zone_valide;
! 50: logical1 drapeau_elimination_parentheses;
! 51: logical1 drapeau_fin_boucle;
! 52: logical1 drapeau_fin_zone_valide;
! 53: logical1 drapeau_modification;
! 54: logical1 drapeau_priorite_entierement_traitee;
! 55: logical1 fin_boucle_extraction;
! 56: logical1 presence_chaine;
! 57: logical1 presence_fonction;
! 58: logical1 presence_liste;
! 59:
! 60: long k;
! 61:
! 62: unsigned char *chaine_arguments;
! 63: unsigned char *chaine_centrale;
! 64: unsigned char *chaine_droite;
! 65: unsigned char *chaine_fonction;
! 66: unsigned char *chaine_gauche;
! 67: unsigned char *chaine_travail;
! 68: unsigned char *epilogue;
! 69: unsigned char instruction_test[6];
! 70: unsigned char *instruction_majuscule;
! 71: unsigned char *prologue;
! 72: unsigned char *ptr1;
! 73: unsigned char *ptr2;
! 74: unsigned char *registre_instruction_courante;
! 75: unsigned char registre_instruction_valide;
! 76: unsigned char registre_test;
! 77: unsigned char *sous_chaine_droite;
! 78: unsigned char *sous_chaine_gauche;
! 79: unsigned char t0;
! 80: unsigned char t1;
! 81: unsigned char t2;
! 82: unsigned char t3;
! 83: unsigned char t4;
! 84: unsigned char *tampon;
! 85:
! 86: unsigned long debut_zone_algebrique;
! 87: unsigned long fin_zone_algebrique;
! 88: unsigned long i;
! 89: unsigned long j;
! 90: unsigned long longueur_chaine;
! 91: unsigned long longueur_tampon;
! 92: unsigned long niveau;
! 93: unsigned long niveau_liste;
! 94: unsigned long nombre_apostrophes;
! 95: unsigned long nombre_arguments;
! 96: unsigned long priorite;
! 97:
! 98: (*l_base_liste) = NULL;
! 99:
! 100: /*
! 101: * Vérification de la chaîne. Celle-ci doit comporter au moins un
! 102: * caractère entre les délimiteurs ''.
! 103: */
! 104:
! 105: presence_chaine = d_faux;
! 106: presence_liste = d_faux;
! 107: niveau_liste = 0;
! 108:
! 109: for(i = 1, chaine_invalide = d_vrai; i < strlen(chaine_algebrique) - 1; i++)
! 110: {
! 111: if (chaine_algebrique[i] != ' ')
! 112: {
! 113: chaine_invalide = d_faux;
! 114: }
! 115:
! 116: if (chaine_algebrique[i] == '"')
! 117: {
! 118: presence_chaine = (presence_chaine == d_faux) ? d_vrai : d_faux;
! 119: }
! 120: else if (presence_chaine == d_faux)
! 121: {
! 122: if (chaine_algebrique[i] == '{')
! 123: {
! 124: presence_liste = d_vrai;
! 125: niveau_liste++;
! 126: }
! 127: else if (chaine_algebrique[i] == '}')
! 128: {
! 129: presence_liste = d_vrai;
! 130: niveau_liste--;
! 131: }
! 132: }
! 133: }
! 134:
! 135: if ((chaine_invalide == d_vrai) || (presence_chaine == d_vrai) ||
! 136: (niveau_liste != 0) || (presence_liste == d_vrai))
! 137: {
! 138: (*s_etat_processus).erreur_execution = d_ex_expression_invalide;
! 139: return(NULL);
! 140: }
! 141:
! 142: /*
! 143: * Transformation des "**" en "^ "
! 144: */
! 145:
! 146: for(i = 1; i < strlen(chaine_algebrique) - 1; i++)
! 147: {
! 148: if (chaine_algebrique[i] == '*')
! 149: {
! 150: if (chaine_algebrique[i + 1] == '*')
! 151: {
! 152: chaine_algebrique[i++] = '^';
! 153: chaine_algebrique[i] = ' ';
! 154: }
! 155: }
! 156: }
! 157:
! 158: if ((chaine_travail = (unsigned char *) malloc((strlen(chaine_algebrique) +
! 159: 1) * sizeof(unsigned char))) == NULL)
! 160: {
! 161: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 162: return(NULL);
! 163: }
! 164:
! 165: strcpy(chaine_travail, chaine_algebrique);
! 166:
! 167: /*
! 168: * Retrait des espaces dans l'expression algébrique
! 169: */
! 170:
! 171: ptr1 = chaine_travail;
! 172: ptr2 = chaine_travail;
! 173: presence_chaine = d_faux;
! 174:
! 175: while((*ptr1) != d_code_fin_chaine)
! 176: {
! 177: if ((*ptr1) == '"')
! 178: {
! 179: if (presence_chaine == d_faux)
! 180: {
! 181: presence_chaine = d_vrai;
! 182: }
! 183: else
! 184: {
! 185: presence_chaine = d_faux;
! 186: }
! 187: }
! 188:
! 189: if (presence_chaine == d_faux)
! 190: {
! 191: if ((*ptr1) != ' ')
! 192: {
! 193: (*(ptr2++)) = (*ptr1);
! 194: }
! 195: else
! 196: {
! 197: instruction_test[5] = d_code_fin_chaine;
! 198:
! 199: instruction_majuscule = conversion_majuscule(strncpy(
! 200: instruction_test, ptr1, 5));
! 201:
! 202: if (instruction_majuscule == NULL)
! 203: {
! 204: (*s_etat_processus).erreur_systeme =
! 205: d_es_allocation_memoire;
! 206: return(NULL);
! 207: }
! 208:
! 209: /*
! 210: * Repérer le premier espace ou la fin de la chaîne.
! 211: */
! 212:
! 213: if (strcmp(instruction_majuscule, " AND ") == 0)
! 214: {
! 215: for(i = 0; i < 4; (*(ptr2++)) = (*(ptr1++)), i++);
! 216: (*(ptr2++)) = (*ptr1);
! 217: }
! 218: else if (strcmp(instruction_majuscule, " XOR ") == 0)
! 219: {
! 220: for(i = 0; i < 4; (*(ptr2++)) = (*(ptr1++)), i++);
! 221: (*(ptr2++)) = (*ptr1);
! 222: }
! 223: else if ((strncmp(instruction_majuscule, " OR ", 4) == 0) &&
! 224: (strlen(instruction_majuscule) == 4))
! 225: {
! 226: for(i = 0; i < 3; (*(ptr2++)) = (*(ptr1++)), i++);
! 227: (*(ptr2++)) = (*ptr1);
! 228: }
! 229:
! 230: free(instruction_majuscule);
! 231: }
! 232:
! 233: ptr1++;
! 234: }
! 235: else
! 236: {
! 237: (*(ptr2++)) = (*(ptr1++));
! 238: }
! 239: }
! 240:
! 241: (*ptr2) = d_code_fin_chaine;
! 242:
! 243: do
! 244: {
! 245: i = 0;
! 246: drapeau_modification = d_faux;
! 247:
! 248: do
! 249: {
! 250: presence_chaine = d_faux;
! 251: drapeau_debut_zone_valide = d_faux;
! 252: debut_zone_algebrique = 0;
! 253: drapeau_fin_boucle = d_faux;
! 254:
! 255: do
! 256: {
! 257: if (chaine_travail[i] == d_code_fin_chaine)
! 258: {
! 259: drapeau_fin_boucle = d_vrai;
! 260: }
! 261: else if ((chaine_travail[i] == '\'') &&
! 262: (presence_chaine == d_faux))
! 263: {
! 264: drapeau_fin_boucle = d_vrai;
! 265: debut_zone_algebrique = i;
! 266: drapeau_debut_zone_valide = d_vrai;
! 267: }
! 268: else if (chaine_travail[i] == '"')
! 269: {
! 270: presence_chaine = (presence_chaine == d_vrai)
! 271: ? d_faux : d_vrai;
! 272: }
! 273:
! 274: i++;
! 275: } while(drapeau_fin_boucle == d_faux);
! 276:
! 277: presence_chaine = 0;
! 278: drapeau_fin_zone_valide = d_faux;
! 279:
! 280: if (drapeau_debut_zone_valide == d_vrai)
! 281: {
! 282: j = debut_zone_algebrique + 1;
! 283: }
! 284: else
! 285: {
! 286: j = 0;
! 287: }
! 288:
! 289: fin_zone_algebrique = 0;
! 290: drapeau_fin_boucle = d_faux;
! 291:
! 292: do
! 293: {
! 294: if (chaine_travail[j] == 0)
! 295: {
! 296: drapeau_fin_boucle = d_vrai;
! 297: }
! 298:
! 299: if ((chaine_travail[j] == '\'') && (presence_chaine == d_faux))
! 300: {
! 301: drapeau_fin_boucle = d_vrai;
! 302: fin_zone_algebrique = j;
! 303: drapeau_fin_zone_valide = d_vrai;
! 304: }
! 305:
! 306: if (chaine_travail[j] == '"')
! 307: {
! 308: presence_chaine = (presence_chaine == d_vrai)
! 309: ? d_faux : d_vrai;
! 310: }
! 311:
! 312: j++;
! 313: } while(drapeau_fin_boucle == d_faux);
! 314:
! 315: if ((drapeau_debut_zone_valide == d_vrai) &&
! 316: (drapeau_fin_zone_valide == d_vrai))
! 317: {
! 318: chaine_gauche = purification_chaine(
! 319: extraction_chaine(chaine_travail,
! 320: 1, debut_zone_algebrique));
! 321: chaine_centrale = purification_chaine(
! 322: extraction_chaine(chaine_travail,
! 323: debut_zone_algebrique + 1, fin_zone_algebrique + 1));
! 324: chaine_droite = purification_chaine(
! 325: extraction_chaine(chaine_travail,
! 326: fin_zone_algebrique + 2, strlen(chaine_travail)));
! 327:
! 328: free(chaine_travail);
! 329:
! 330: if ((chaine_gauche == NULL) || (chaine_centrale == NULL) ||
! 331: (chaine_droite == NULL))
! 332: {
! 333: (*s_etat_processus).erreur_systeme =
! 334: d_es_allocation_memoire;
! 335: return(NULL);
! 336: }
! 337:
! 338: if ((strcmp(chaine_centrale, "''") == 0) ||
! 339: (strcmp(chaine_centrale, "'()'") == 0))
! 340: {
! 341: free(chaine_gauche);
! 342: free(chaine_centrale);
! 343: free(chaine_droite);
! 344:
! 345: (*s_etat_processus).erreur_execution =
! 346: d_ex_expression_invalide;
! 347: return(NULL);
! 348: }
! 349:
! 350: i = 1;
! 351: niveau = 0;
! 352: drapeau_elimination_parentheses = d_vrai;
! 353: presence_chaine = d_faux;
! 354:
! 355: while(i < (strlen(chaine_centrale) - 1))
! 356: {
! 357: if (chaine_centrale[i] == '"')
! 358: {
! 359: presence_chaine = (presence_chaine == d_faux)
! 360: ? d_vrai : d_faux;
! 361:
! 362: if (i == 1)
! 363: {
! 364: drapeau_elimination_parentheses = d_faux;
! 365: }
! 366: }
! 367: else if (presence_chaine == d_faux)
! 368: {
! 369: if (chaine_centrale[i] == '(')
! 370: {
! 371: niveau++;
! 372: }
! 373:
! 374: if ((niveau == 0) || ((((test_cfsf(s_etat_processus,
! 375: 48) == d_vrai) && (chaine_centrale[i] ==
! 376: '.')) || ((test_cfsf(s_etat_processus, 48)
! 377: == d_faux) && (chaine_centrale[i] == ',')))
! 378: && (niveau == 1)))
! 379: {
! 380: drapeau_elimination_parentheses = d_faux;
! 381: }
! 382:
! 383: if (chaine_centrale[i] == ')')
! 384: {
! 385: niveau--;
! 386: }
! 387: }
! 388:
! 389: i++;
! 390: }
! 391:
! 392: if (drapeau_elimination_parentheses == d_vrai)
! 393: {
! 394: tampon = chaine_centrale;
! 395:
! 396: if ((chaine_centrale = (unsigned char *) malloc(
! 397: (strlen(tampon) - 1) * sizeof(unsigned char)))
! 398: == NULL)
! 399: {
! 400: (*s_etat_processus).erreur_systeme =
! 401: d_es_allocation_memoire;
! 402: return(NULL);
! 403: }
! 404:
! 405: tampon[strlen(tampon) - 2] = d_code_fin_chaine;
! 406:
! 407: sprintf(chaine_centrale, "'%s'", &(tampon[2]));
! 408: free(tampon);
! 409:
! 410: fin_zone_algebrique -= 2;
! 411: drapeau_modification = d_vrai;
! 412: }
! 413:
! 414: if ((test_expression_rpn(chaine_centrale) == d_vrai) &&
! 415: (fin_zone_algebrique - debut_zone_algebrique > 0))
! 416: {
! 417: if ((tampon = purification_chaine(
! 418: extraction_chaine(chaine_centrale, 2,
! 419: strlen(chaine_centrale) - 1))) == NULL)
! 420: {
! 421: (*s_etat_processus).erreur_systeme =
! 422: d_es_allocation_memoire;
! 423: return(NULL);
! 424: }
! 425:
! 426: /*
! 427: * Si on tombe sur une fonction intrinsèque ou
! 428: * extrinsèque, il doit y avoir des arguments passés
! 429: * entre parenthèses et on ne doit pas passer par ici !
! 430: */
! 431:
! 432: registre_instruction_courante = (*s_etat_processus)
! 433: .instruction_courante;
! 434: registre_test = (*s_etat_processus).test_instruction;
! 435: registre_instruction_valide = (*s_etat_processus)
! 436: .instruction_valide;
! 437:
! 438: (*s_etat_processus).test_instruction = 'Y';
! 439: (*s_etat_processus).instruction_courante = tampon;
! 440:
! 441: analyse(s_etat_processus, NULL);
! 442:
! 443: (*s_etat_processus).test_instruction = registre_test;
! 444: (*s_etat_processus).instruction_courante =
! 445: registre_instruction_courante;
! 446:
! 447: if (((*s_etat_processus).instruction_valide == 'Y') &&
! 448: ((*s_etat_processus).constante_symbolique == 'N'))
! 449: {
! 450: free(chaine_gauche);
! 451: free(chaine_centrale);
! 452: free(chaine_droite);
! 453: free(tampon);
! 454:
! 455: (*s_etat_processus).instruction_valide =
! 456: registre_instruction_valide;
! 457:
! 458: (*s_etat_processus).erreur_execution =
! 459: d_ex_expression_invalide;
! 460: return(NULL);
! 461: }
! 462:
! 463: (*s_etat_processus).instruction_valide =
! 464: registre_instruction_valide;
! 465:
! 466: free(chaine_centrale);
! 467: chaine_centrale = tampon;
! 468:
! 469: fin_zone_algebrique--;
! 470: drapeau_modification = d_vrai;
! 471: }
! 472: else if ((test_fonction(chaine_centrale) == d_vrai) &&
! 473: (fin_zone_algebrique - debut_zone_algebrique > 0))
! 474: {
! 475: i = 1;
! 476: while((i < (strlen(chaine_centrale) - 1)) &&
! 477: (chaine_centrale[i] != '('))
! 478: {
! 479: i++;
! 480: }
! 481:
! 482: j = strlen(chaine_centrale) - 1;
! 483: while(chaine_centrale[j] != ')')
! 484: {
! 485: j--;
! 486: }
! 487:
! 488: chaine_fonction = purification_chaine(
! 489: extraction_chaine(chaine_centrale, 2, i));
! 490: chaine_arguments = purification_chaine(
! 491: extraction_chaine(chaine_centrale, i + 2, j));
! 492:
! 493: i = 0;
! 494: niveau = 0;
! 495: nombre_arguments = 1;
! 496:
! 497: while(chaine_arguments[i] != d_code_fin_chaine)
! 498: {
! 499: if (chaine_arguments[i] == '(')
! 500: {
! 501: niveau++;
! 502: }
! 503:
! 504: if (chaine_arguments[i] == ')')
! 505: {
! 506: niveau--;
! 507: }
! 508:
! 509: if ((chaine_arguments[i] == ',') && (niveau == 0))
! 510: {
! 511: sous_chaine_gauche = purification_chaine(
! 512: extraction_chaine(chaine_arguments, 1, i));
! 513: sous_chaine_droite = purification_chaine(
! 514: extraction_chaine(chaine_arguments, i + 2,
! 515: strlen(chaine_arguments)));
! 516:
! 517: free(chaine_arguments);
! 518:
! 519: if ((chaine_arguments = (unsigned char *) malloc(
! 520: (strlen(sous_chaine_gauche) + strlen(
! 521: sous_chaine_droite) + 3 + 1) * sizeof(
! 522: unsigned char))) == NULL)
! 523: {
! 524: (*s_etat_processus).erreur_systeme =
! 525: d_es_allocation_memoire;
! 526: return(NULL);
! 527: }
! 528:
! 529: sprintf(chaine_arguments, "%s' '%s",
! 530: sous_chaine_gauche, sous_chaine_droite);
! 531: i += 2;
! 532:
! 533: free(sous_chaine_gauche);
! 534: free(sous_chaine_droite);
! 535:
! 536: nombre_arguments++;
! 537: }
! 538:
! 539: i++;
! 540: }
! 541:
! 542: free(chaine_centrale);
! 543:
! 544: l_element_courant = (*l_base_liste);
! 545: presence_fonction = d_faux;
! 546:
! 547: while((l_element_courant != NULL) &&
! 548: (presence_fonction == d_faux))
! 549: {
! 550: if (strcmp((*((struct_fonction *) ((*l_element_courant)
! 551: .donnee))).nom_fonction, chaine_fonction) == 0)
! 552: {
! 553: presence_fonction = d_vrai;
! 554: }
! 555: else
! 556: {
! 557: l_element_courant = (*l_element_courant).suivant;
! 558: }
! 559: }
! 560:
! 561: if (presence_fonction == d_vrai)
! 562: {
! 563: if ((*((struct_fonction *)
! 564: ((*l_element_courant).donnee)))
! 565: .nombre_arguments != nombre_arguments)
! 566: {
! 567: (*s_etat_processus).erreur_execution =
! 568: d_ex_nombre_arguments;
! 569:
! 570: free(chaine_arguments);
! 571: free(chaine_fonction);
! 572: free(chaine_gauche);
! 573: free(chaine_droite);
! 574:
! 575: return(NULL);
! 576: }
! 577: }
! 578: else
! 579: {
! 580: registre_instruction_courante = (*s_etat_processus)
! 581: .instruction_courante;
! 582: registre_test = (*s_etat_processus).test_instruction;
! 583: registre_instruction_valide = (*s_etat_processus)
! 584: .instruction_valide;
! 585:
! 586: (*s_etat_processus).test_instruction = 'Y';
! 587: (*s_etat_processus).instruction_courante =
! 588: chaine_fonction;
! 589:
! 590: analyse(s_etat_processus, NULL);
! 591:
! 592: (*s_etat_processus).test_instruction = registre_test;
! 593: (*s_etat_processus).instruction_courante =
! 594: registre_instruction_courante;
! 595: (*s_etat_processus).instruction_valide =
! 596: registre_instruction_valide;
! 597:
! 598: if (((unsigned long) (*s_etat_processus)
! 599: .nombre_arguments != nombre_arguments) &&
! 600: ((*s_etat_processus).nombre_arguments != -2))
! 601: {
! 602: (*s_etat_processus).erreur_execution =
! 603: d_ex_nombre_arguments_fonction;
! 604:
! 605: free(chaine_arguments);
! 606: free(chaine_fonction);
! 607: free(chaine_gauche);
! 608: free(chaine_droite);
! 609:
! 610: return(NULL);
! 611: }
! 612:
! 613: if ((l_element_courant = (struct_liste_chainee *)
! 614: malloc(sizeof(struct_liste_chainee))) == NULL)
! 615: {
! 616: (*s_etat_processus).erreur_systeme =
! 617: d_es_allocation_memoire;
! 618: return(NULL);
! 619: }
! 620:
! 621: (*l_element_courant).suivant = (*l_base_liste);
! 622: (*l_base_liste) = l_element_courant;
! 623:
! 624: if ((s_fonction = allocation(s_etat_processus, FCT))
! 625: == NULL)
! 626: {
! 627: (*s_etat_processus).erreur_systeme =
! 628: d_es_allocation_memoire;
! 629: return(NULL);
! 630: }
! 631:
! 632: if (((*s_fonction).nom_fonction = (unsigned char *)
! 633: malloc((strlen(chaine_fonction) + 1) *
! 634: sizeof(unsigned char))) == NULL)
! 635: {
! 636: (*s_etat_processus).erreur_systeme =
! 637: d_es_allocation_memoire;
! 638: return(NULL);
! 639: }
! 640:
! 641: strcpy((*s_fonction).nom_fonction, chaine_fonction);
! 642: (*s_fonction).nombre_arguments = nombre_arguments;
! 643:
! 644: (*(*l_base_liste)).donnee = (void *) s_fonction;
! 645: }
! 646:
! 647: if ((chaine_centrale = (unsigned char *) malloc((strlen(
! 648: chaine_arguments) + 1 + strlen(chaine_fonction)
! 649: + 1 + 2) * sizeof(unsigned char))) == NULL)
! 650: {
! 651: (*s_etat_processus).erreur_systeme =
! 652: d_es_allocation_memoire;
! 653: return(NULL);
! 654: }
! 655:
! 656: sprintf(chaine_centrale, "'%s' %s", chaine_arguments,
! 657: chaine_fonction);
! 658: drapeau_modification = d_vrai;
! 659:
! 660: free(chaine_arguments);
! 661: free(chaine_fonction);
! 662: }
! 663: else if ((chaine_centrale[1] == '+') ||
! 664: (chaine_centrale[1] == '-'))
! 665: {
! 666: if (chaine_centrale[1] == '-')
! 667: {
! 668: tampon = chaine_centrale;
! 669:
! 670: if ((chaine_centrale = (unsigned char *) malloc(
! 671: (strlen(tampon) + 5) * sizeof(unsigned char)))
! 672: == NULL)
! 673: {
! 674: (*s_etat_processus).erreur_systeme =
! 675: d_es_allocation_memoire;
! 676: return(NULL);
! 677: }
! 678:
! 679: tampon[strlen(tampon) - 1] = d_code_fin_chaine;
! 680: sprintf(chaine_centrale, "'NEG(%s)'", &(tampon[2]));
! 681: fin_zone_algebrique += 5;
! 682: drapeau_modification = d_vrai;
! 683:
! 684: free(tampon);
! 685: }
! 686: else
! 687: {
! 688: tampon = chaine_centrale;
! 689:
! 690: if ((chaine_centrale = (unsigned char *) malloc(
! 691: (strlen(tampon) + 7) * sizeof(unsigned char)))
! 692: == NULL)
! 693: {
! 694: (*s_etat_processus).erreur_systeme =
! 695: d_es_allocation_memoire;
! 696: return(NULL);
! 697: }
! 698:
! 699: tampon[strlen(tampon) - 1] = d_code_fin_chaine;
! 700: sprintf(chaine_centrale, "'RELAX(%s)'", &(tampon[2]));
! 701: fin_zone_algebrique += 7;
! 702: drapeau_modification = d_vrai;
! 703:
! 704: free(tampon);
! 705: }
! 706: }
! 707:
! 708: if ((chaine_travail = (unsigned char *) malloc(
! 709: (strlen(chaine_gauche) + strlen(chaine_centrale) +
! 710: strlen(chaine_droite) + 1 + 2) * sizeof(unsigned char)))
! 711: == NULL)
! 712: {
! 713: (*s_etat_processus).erreur_systeme =
! 714: d_es_allocation_memoire;
! 715: return(NULL);
! 716: }
! 717:
! 718: sprintf(chaine_travail, "%s %s %s", chaine_gauche,
! 719: chaine_centrale, chaine_droite);
! 720:
! 721: free(chaine_gauche);
! 722: free(chaine_centrale);
! 723: free(chaine_droite);
! 724: }
! 725:
! 726: i = fin_zone_algebrique + 1;
! 727: } while((drapeau_debut_zone_valide == d_vrai)
! 728: && (drapeau_fin_zone_valide == d_vrai));
! 729:
! 730: for(longueur_chaine = strlen(chaine_travail),
! 731: i = nombre_apostrophes = 0; i < longueur_chaine;
! 732: nombre_apostrophes += (chaine_travail[i++] == '\'') ? 1 : 0);
! 733:
! 734: if (nombre_apostrophes != 0)
! 735: {
! 736: priorite = 1;
! 737:
! 738: do
! 739: {
! 740: drapeau_priorite_entierement_traitee = d_vrai;
! 741:
! 742: i = 0;
! 743: while((chaine_travail[i] != '\'') && (chaine_travail[i] != 0))
! 744: {
! 745: i++;
! 746: }
! 747:
! 748: if (chaine_travail[i] == 0)
! 749: {
! 750: i = 0;
! 751: }
! 752:
! 753: j = i + 1;
! 754: while((chaine_travail[j] != '\'') && (chaine_travail[j] != 0))
! 755: {
! 756: j++;
! 757: }
! 758:
! 759: if (chaine_travail[j] == 0)
! 760: {
! 761: j = 0;
! 762: }
! 763:
! 764: if ((chaine_travail[i] != 0) && (j != 0))
! 765: {
! 766: chaine_gauche = purification_chaine(
! 767: extraction_chaine(chaine_travail, 1, i));
! 768: chaine_centrale = purification_chaine(
! 769: extraction_chaine(chaine_travail,
! 770: i + 1, j + 1));
! 771: chaine_droite = purification_chaine(
! 772: extraction_chaine(chaine_travail, j + 2,
! 773: strlen(chaine_travail)));
! 774:
! 775: if ((chaine_gauche == NULL) || (chaine_centrale == NULL) ||
! 776: (chaine_droite == NULL))
! 777: {
! 778: (*s_etat_processus).erreur_systeme =
! 779: d_es_allocation_memoire;
! 780: return(NULL);
! 781: }
! 782:
! 783: drapeau_elimination_parentheses = d_vrai;
! 784:
! 785: if ((longueur_tampon = strlen(chaine_centrale)) != 0)
! 786: {
! 787: niveau = 0;
! 788:
! 789: for(i = 1; i < longueur_tampon - 1; i++)
! 790: {
! 791: if (chaine_centrale[i] == '(')
! 792: {
! 793: niveau++;
! 794: }
! 795:
! 796: if ((niveau == 0) || ((((test_cfsf(s_etat_processus,
! 797: 48) == d_vrai) && (chaine_centrale[i] ==
! 798: '.')) || ((test_cfsf(s_etat_processus, 48)
! 799: == d_faux) && (chaine_centrale[i] == ',')))
! 800: && (niveau == 1)))
! 801: {
! 802: drapeau_elimination_parentheses = d_faux;
! 803: }
! 804:
! 805: if (chaine_centrale[i] == ')')
! 806: {
! 807: niveau--;
! 808: }
! 809: }
! 810:
! 811: if (drapeau_elimination_parentheses == d_vrai)
! 812: {
! 813: if ((tampon = (unsigned char *) malloc(
! 814: ((longueur_tampon = strlen(
! 815: chaine_centrale)) + 1) * sizeof(
! 816: unsigned char))) == NULL)
! 817: {
! 818: (*s_etat_processus).erreur_systeme =
! 819: d_es_allocation_memoire;
! 820: return(NULL);
! 821: }
! 822:
! 823: chaine_centrale[longueur_tampon - 2] =
! 824: d_code_fin_chaine;
! 825: sprintf(tampon, "'%s'", &(chaine_centrale[2]));
! 826: free(chaine_centrale);
! 827: chaine_centrale = tampon;
! 828: drapeau_modification = d_vrai;
! 829: }
! 830: }
! 831:
! 832: if ((tampon = (unsigned char *) malloc(sizeof(
! 833: unsigned char))) == NULL)
! 834: {
! 835: (*s_etat_processus).erreur_systeme =
! 836: d_es_allocation_memoire;
! 837: return(NULL);
! 838: }
! 839:
! 840: tampon[0] = d_code_fin_chaine;
! 841: longueur_chaine = strlen(chaine_centrale);
! 842: niveau = 0;
! 843: k = strlen(chaine_centrale) - 1;
! 844: fin_boucle_extraction = d_faux;
! 845:
! 846: while((k >= 0) && (fin_boucle_extraction ==
! 847: d_faux))
! 848: {
! 849: t0 = ((size_t) k < strlen(chaine_centrale))
! 850: ? chaine_centrale[k + 1] : ' ';
! 851: t1 = chaine_centrale[k];
! 852: t2 = (k < 1) ? ' ' : chaine_centrale[k - 1];
! 853: t3 = (k < 2) ? ' ' : chaine_centrale[k - 2];
! 854: t4 = (k < 3) ? ' ' : chaine_centrale[k - 3];
! 855:
! 856: if ((t0 >= 'a') && (t0 <= 'z'))
! 857: {
! 858: t0 = t0 + ('A' - 'a');
! 859: }
! 860:
! 861: if ((t1 >= 'a') && (t1 <= 'z'))
! 862: {
! 863: t1 = t1 + ('A' - 'a');
! 864: }
! 865:
! 866: if ((t2 >= 'a') && (t2 <= 'z'))
! 867: {
! 868: t2 = t2 + ('A' - 'a');
! 869: }
! 870:
! 871: if ((t3 >= 'a') && (t3 <= 'z'))
! 872: {
! 873: t3 = t3 + ('A' - 'a');
! 874: }
! 875:
! 876: if ((t4 >= 'a') && (t4 <= 'z'))
! 877: {
! 878: t4 = t4 + ('A' - 'a');
! 879: }
! 880:
! 881: if (t1 == '(')
! 882: {
! 883: niveau++;
! 884: }
! 885:
! 886: if (niveau == 0)
! 887: {
! 888: prologue = purification_chaine(
! 889: extraction_chaine(chaine_centrale, 1, k));
! 890: epilogue = purification_chaine(
! 891: extraction_chaine(chaine_centrale,
! 892: k + 2, longueur_chaine));
! 893:
! 894: if ((prologue == NULL) || (epilogue == NULL))
! 895: {
! 896: (*s_etat_processus).erreur_systeme =
! 897: d_es_allocation_memoire;
! 898: return(NULL);
! 899: }
! 900:
! 901: /*
! 902: * Priorité = 1 : traitement des fonctions les plus prioritaires
! 903: */
! 904:
! 905: if (((priorite == 4) && (((t1 == '<') && (t0 != '=')
! 906: && (t2 != '=')) || ((t1 == '>') &&
! 907: (t0 != '=') && (t2 != '=')) ||
! 908: ((t1 == '=') && (t0 != '=') && (t0 != '<')
! 909: && (t0 != '>') && (t2 != '<') && (t2 != '>')
! 910: && (t2 != '=')))) ||
! 911: ((t1 == '+') && (priorite == 5) &&
! 912: (t2 != '\'') && (!(((t2 == '(')
! 913: || (t2 == '\'') || (t2 == 'e')
! 914: || (t2 == 'E')) && (((t3 >= '0')
! 915: && (t3 <= '9')) || (t3 == '.'))))) ||
! 916: ((t1 == '-') && (priorite == 6) &&
! 917: (t2 != '\'') && (!(((t2 == '(')
! 918: || (t2 == '\'') || (t2 == 'e')
! 919: || (t2 == 'E')) && (((t3 >= '0')
! 920: && (t3 <= '9')) || (t3 == '.')))))
! 921: || ((t1 == '*') && (priorite == 7))
! 922: || ((t1 == '/') && (priorite == 8)) ||
! 923: ((t1 == '^') && (priorite == 9)))
! 924: {
! 925: drapeau_priorite_entierement_traitee = d_faux;
! 926: fin_boucle_extraction = d_vrai;
! 927:
! 928: free(tampon);
! 929:
! 930: if ((tampon = (unsigned char *)
! 931: malloc((strlen(prologue) +
! 932: strlen(epilogue) + 6) *
! 933: sizeof(unsigned char))) == NULL)
! 934: {
! 935: (*s_etat_processus).erreur_systeme =
! 936: d_es_allocation_memoire;
! 937: return(NULL);
! 938: }
! 939:
! 940: sprintf(tampon, "%s' '%s %c",
! 941: prologue, epilogue, t1);
! 942: drapeau_modification = d_vrai;
! 943: }
! 944: else if (((priorite == 4) && (((t1 == '<') &&
! 945: (t2 == '=')) || ((t1 == '=') &&
! 946: (t2 == '<')) || ((t1 == '>') &&
! 947: (t2 == '<')) || (((t1 == '>') &&
! 948: (t2 == '=')) || ((t1 == '=') &&
! 949: (t2 == '>')) || ((t1 == '=') &&
! 950: (t2 == '='))))) || ((priorite == 1) &&
! 951: (t1 == 'R') && (t2 == 'O') && (t3 == ' ')
! 952: && (t0 == ' ')))
! 953: {
! 954: drapeau_priorite_entierement_traitee = d_faux;
! 955: fin_boucle_extraction = d_vrai;
! 956:
! 957: free(tampon);
! 958:
! 959: if ((tampon = (unsigned char *)
! 960: malloc((strlen(prologue) +
! 961: strlen(epilogue) + 6) *
! 962: sizeof(unsigned char))) == NULL)
! 963: {
! 964: (*s_etat_processus).erreur_systeme =
! 965: d_es_allocation_memoire;
! 966: return(NULL);
! 967: }
! 968:
! 969: prologue[strlen(prologue) - 1] =
! 970: d_code_fin_chaine;
! 971:
! 972: sprintf(tampon, "%s' '%s %c%c", prologue,
! 973: epilogue, t2, t1);
! 974: drapeau_modification = d_vrai;
! 975: }
! 976: else if (((priorite == 1) && (t4 == ' ') &&
! 977: (t3 == 'X') && (t2 == 'O') && (t1 == 'R')
! 978: && (t0 == ' ')) || ((priorite == 2) &&
! 979: (t4 == ' ') && (t3 == 'A') && (t2 == 'N')
! 980: && (t1 == 'D') && (t0 == ' ')))
! 981: {
! 982: drapeau_priorite_entierement_traitee = d_faux;
! 983: fin_boucle_extraction = d_vrai;
! 984:
! 985: free(tampon);
! 986:
! 987: if ((tampon = (unsigned char *)
! 988: malloc((strlen(prologue) +
! 989: strlen(epilogue) + 5) *
! 990: sizeof(unsigned char))) == NULL)
! 991: {
! 992: (*s_etat_processus).erreur_systeme =
! 993: d_es_allocation_memoire;
! 994: return(NULL);
! 995: }
! 996:
! 997: prologue[strlen(prologue) - 3] =
! 998: d_code_fin_chaine;
! 999:
! 1000: sprintf(tampon, "%s' '%s %c%c%c", prologue,
! 1001: epilogue, t3, t2, t1);
! 1002: drapeau_modification = d_vrai;
! 1003: }
! 1004:
! 1005: free(prologue);
! 1006: free(epilogue);
! 1007: }
! 1008:
! 1009: if (t1 == ')')
! 1010: {
! 1011: niveau--;
! 1012: }
! 1013:
! 1014: k--;
! 1015: }
! 1016:
! 1017: if (drapeau_priorite_entierement_traitee == d_vrai)
! 1018: {
! 1019: free(tampon);
! 1020:
! 1021: if ((tampon = (unsigned char *) malloc(
! 1022: (strlen(chaine_centrale) + 1) *
! 1023: sizeof(unsigned char))) == NULL)
! 1024: {
! 1025: (*s_etat_processus).erreur_systeme =
! 1026: d_es_allocation_memoire;
! 1027: return(NULL);
! 1028: }
! 1029:
! 1030: strcpy(tampon, chaine_centrale);
! 1031: }
! 1032:
! 1033: free(chaine_centrale);
! 1034: free(chaine_travail);
! 1035:
! 1036: if ((chaine_travail = (unsigned char *) malloc(
! 1037: (strlen(chaine_gauche) + strlen(tampon)
! 1038: + strlen(chaine_droite) + 1 + 2)
! 1039: * sizeof(unsigned char))) == NULL)
! 1040: {
! 1041: (*s_etat_processus).erreur_systeme =
! 1042: d_es_allocation_memoire;
! 1043: return(NULL);
! 1044: }
! 1045:
! 1046: sprintf(chaine_travail, "%s %s %s", chaine_gauche,
! 1047: tampon, chaine_droite);
! 1048:
! 1049: free(chaine_gauche);
! 1050: free(tampon);
! 1051: free(chaine_droite);
! 1052: }
! 1053:
! 1054: if (drapeau_priorite_entierement_traitee == d_vrai)
! 1055: {
! 1056: priorite++;
! 1057: }
! 1058: else
! 1059: {
! 1060: priorite = 1;
! 1061: }
! 1062: } while(priorite < 10);
! 1063:
! 1064: /*
! 1065: * Aucune modification n'a pu être faite sur l'expression
! 1066: * algébrique.
! 1067: */
! 1068:
! 1069: if (drapeau_modification == d_faux)
! 1070: {
! 1071: free(chaine_travail);
! 1072:
! 1073: (*s_etat_processus).erreur_execution = d_ex_syntaxe;
! 1074: return(NULL);
! 1075: }
! 1076: }
! 1077: } while(nombre_apostrophes != 0);
! 1078:
! 1079: tampon = chaine_travail;
! 1080:
! 1081: if ((chaine_travail = (unsigned char *) malloc((strlen(tampon) + 1 + 6) *
! 1082: sizeof(unsigned char))) == NULL)
! 1083: {
! 1084: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1085: return(NULL);
! 1086: }
! 1087:
! 1088: sprintf(chaine_travail, "<< %s >>", tampon);
! 1089: free(tampon);
! 1090:
! 1091: return(chaine_travail);
! 1092: }
! 1093:
! 1094:
! 1095: unsigned char *
! 1096: purification_chaine(unsigned char *chaine)
! 1097: {
! 1098: long i;
! 1099: long j;
! 1100:
! 1101: unsigned char *chaine_purifiee;
! 1102:
! 1103: i = 0;
! 1104: j = strlen(chaine) - 1;
! 1105:
! 1106: while(chaine[i] == ' ')
! 1107: {
! 1108: if ((i++) > j)
! 1109: {
! 1110: i = j;
! 1111: break;
! 1112: }
! 1113: }
! 1114:
! 1115: if (j >= 0)
! 1116: {
! 1117: while(chaine[j] == ' ')
! 1118: {
! 1119: if ((--j) < 0)
! 1120: {
! 1121: j = 0;
! 1122: break;
! 1123: }
! 1124: }
! 1125: }
! 1126:
! 1127: chaine_purifiee = extraction_chaine(chaine, i + 1, j + 1);
! 1128: free(chaine);
! 1129:
! 1130: return(chaine_purifiee);
! 1131: }
! 1132:
! 1133:
! 1134: logical1
! 1135: test_expression_rpn(unsigned char *chaine)
! 1136: {
! 1137: long j;
! 1138:
! 1139: unsigned char t;
! 1140: unsigned char t0;
! 1141: unsigned char t1;
! 1142: unsigned char t2;
! 1143: unsigned char t3;
! 1144: unsigned char t4;
! 1145:
! 1146: unsigned long compteur;
! 1147: unsigned long longueur_chaine;
! 1148: unsigned long i;
! 1149: unsigned long niveau;
! 1150:
! 1151: /*
! 1152: * On teste d'abord la chaîne pour vérifier qu'il n'y a pas de fonction
! 1153: * utilisant la notation infixe.
! 1154: */
! 1155:
! 1156: compteur = 0;
! 1157:
! 1158: for(longueur_chaine = strlen(chaine), i = 1; i < longueur_chaine; i++)
! 1159: {
! 1160: /*
! 1161: * On saute les chaînes de caractères
! 1162: */
! 1163:
! 1164: if (chaine[i - 1] == '"')
! 1165: {
! 1166: i++;
! 1167: while(chaine[i - 1] != '"')
! 1168: {
! 1169: i++;
! 1170: }
! 1171: }
! 1172:
! 1173: j = ((long) i) - 2;
! 1174: t0 = (i >= 2) ? chaine[i - 2] : '?';
! 1175: t1 = chaine[i - 1];
! 1176: t2 = chaine[i];
! 1177: t3 = ((i + 1) < strlen(chaine)) ? chaine[i + 1] : '?';
! 1178: t4 = ((i + 2) < strlen(chaine)) ? chaine[i + 2] : '?';
! 1179:
! 1180: /*
! 1181: * Ouverture d'une parenthèse signalant une fonction
! 1182: */
! 1183:
! 1184: if ((t1 != '+') && (t1 != '-') && (t1 != '*') && (t1 != '/')
! 1185: && (t1 != '\'') && (t2 == '('))
! 1186: {
! 1187: niveau = 0;
! 1188:
! 1189: do
! 1190: {
! 1191: if ((t = chaine[i++]) == '(')
! 1192: {
! 1193: niveau++;
! 1194: }
! 1195: else if (t == ')')
! 1196: {
! 1197: niveau--;
! 1198: }
! 1199: } while(((niveau != 0) || (t != ')')) && (i < longueur_chaine));
! 1200:
! 1201: if (i < longueur_chaine)
! 1202: {
! 1203: t2 = chaine[i];
! 1204: }
! 1205: else
! 1206: {
! 1207: t2 = ' ';
! 1208: }
! 1209: }
! 1210:
! 1211: /*
! 1212: * Signalement de l'une des quatre opérations et des fonctions
! 1213: * infixes traditionnelles
! 1214: */
! 1215:
! 1216: if ((t2 == '+') || (t2 == '-') || (t2 == '*') || (t2 == '/')
! 1217: || (t2 == '^') || (t2 == '<') || (t2 == '>') || (t2 == '=')
! 1218: || ((t0 == ' ') && ((t1 == 'A') || (t1 == 'a')) &&
! 1219: ((t2 == 'N') || (t2 == 'n')) && ((t3 == 'D') || (t3 == 'd'))
! 1220: && (t4 == ' ')) ||
! 1221: ((t0 == ' ') && ((t1 == 'O') || (t1 == 'o')) &&
! 1222: ((t2 == 'R') || (t2 == 'r')) && (t3 == ' ')) ||
! 1223: ((t0 == ' ') && ((t1 == 'X') || (t1 == 'x')) &&
! 1224: ((t2 == 'O') || (t2 == 'o')) && ((t3 == 'R') || (t3 == 'r'))
! 1225: && (t4 == ' ')))
! 1226: {
! 1227: compteur++;
! 1228: }
! 1229:
! 1230: /*
! 1231: * Signalement d'un nombre
! 1232: */
! 1233:
! 1234: if (((t2 == '+') || (t2 == '-')) && ((t1 == '(')
! 1235: || ((t1 == 'e') || (t1 == 'E') || (t1 == '\'')))
! 1236: && (((t0 >= '0') && (t0 <= '9')) || (t0 == '.')))
! 1237: {
! 1238: compteur--;
! 1239: }
! 1240: else if (((t2 == '+') || (t2 == '-')) && (t1 == '\'') && (j < 0)
! 1241: && (((t3 >= '0') && (t3 <= '9')) || (t3 == '.')))
! 1242: {
! 1243: compteur--;
! 1244: }
! 1245: }
! 1246:
! 1247: return(((compteur == 0) && (test_fonction(chaine) == d_faux))
! 1248: ? d_vrai : d_faux);
! 1249: }
! 1250:
! 1251:
! 1252: logical1
! 1253: test_fonction(unsigned char *chaine)
! 1254: {
! 1255: logical1 drapeau_fonction;
! 1256:
! 1257: unsigned char t;
! 1258:
! 1259: unsigned long compteur;
! 1260: unsigned long i;
! 1261: unsigned long longueur_chaine;
! 1262:
! 1263: longueur_chaine = strlen(chaine);
! 1264: i = 1;
! 1265:
! 1266: while(((t = chaine[i]) != '(') && (i < (longueur_chaine - 1)))
! 1267: {
! 1268: if ((t == '+') || (t == '-') || (t == '*') ||
! 1269: (t == '/') || (t == '^') || (t == '>') || (t == '<') ||
! 1270: (t == '='))
! 1271: {
! 1272: i = longueur_chaine - 1;
! 1273: }
! 1274: else
! 1275: {
! 1276: i++;
! 1277: }
! 1278: }
! 1279:
! 1280: compteur = 1;
! 1281: drapeau_fonction = ((i < (longueur_chaine - 1)) && (i != 1))
! 1282: ? d_vrai : d_faux;
! 1283:
! 1284: for(i++; i < (longueur_chaine - 2); i++)
! 1285: {
! 1286: if ((t = chaine[i]) == '(')
! 1287: {
! 1288: compteur++;
! 1289: }
! 1290: else if (t == ')')
! 1291: {
! 1292: compteur--;
! 1293: }
! 1294:
! 1295: if (compteur == 0)
! 1296: {
! 1297: drapeau_fonction = d_faux;
! 1298: }
! 1299: }
! 1300:
! 1301: return drapeau_fonction;
! 1302: }
! 1303:
! 1304:
! 1305: unsigned char *
! 1306: extraction_chaine(unsigned char *chaine, unsigned long position_1,
! 1307: unsigned long position_2)
! 1308: {
! 1309: long i;
! 1310:
! 1311: unsigned char *pointeur_ecriture;
! 1312: unsigned char *pointeur_lecture;
! 1313: unsigned char *sous_chaine;
! 1314:
! 1315: if ((position_1 < 1) || (position_2 < position_1) ||
! 1316: (position_2 > strlen(chaine)))
! 1317: {
! 1318: if ((sous_chaine = (unsigned char *) malloc(sizeof(unsigned char)))
! 1319: == NULL)
! 1320: {
! 1321: return(NULL);
! 1322: }
! 1323:
! 1324: (*sous_chaine) = d_code_fin_chaine;
! 1325: return(sous_chaine);
! 1326: }
! 1327:
! 1328: if ((sous_chaine = (unsigned char *)
! 1329: malloc((position_2 - position_1 + 2) * sizeof(unsigned char)))
! 1330: == NULL)
! 1331: {
! 1332: return(NULL);
! 1333: }
! 1334:
! 1335: pointeur_lecture = &(chaine[position_1 - 1]);
! 1336: pointeur_ecriture = sous_chaine;
! 1337:
! 1338: for(sous_chaine[i = position_2 - position_1 + 1] = 0; (--i) >= 0;
! 1339: *(pointeur_ecriture++) = *(pointeur_lecture++));
! 1340:
! 1341: return(sous_chaine);
! 1342: }
! 1343:
! 1344: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[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