![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 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: Fonction 'derivation' 29: ================================================================================ 30: Entrées : pointeur sur une structure struct_processus 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: derivation(struct_processus *s_etat_processus, struct_objet **s_expression) 40: { 41: /* 42: * Faire le calcul directement sur l'expression RPN. Mettre les 43: * pointeurs dans une pile pour pouvoir circuler dans l'autre sens. 44: * << 2 X * >> -> << 2 X * X DER >> 45: * -> << 2 X DER X * 2 X X DER * + >> -> << 0 X * 2 1 * + >> 46: * -> << 2 >> 47: * 48: * << X 2 * 3 + COS >> -> << X 2 * 3 + COS X DER >> 49: * -> << X 2 * 3 + SIN NEG X 2 * 3 + X DER * >> 50: * 51: * Prévoir la simplification des expressions faite par une évaluation 52: * symbolique ('E'). 53: */ 54: 55: integer8 derivee; 56: 57: logical1 derivee_fonction_disponible; 58: logical1 drapeau; 59: logical1 fin_boucle; 60: 61: static unsigned char *fonctions[] = 62: { 63: "ABS", "1", NULL, 64: "FCT", "SIGN", "1", 65: NULL, 66: 67: "ARG", "1", NULL, 68: "FCT", "INV", "1", 69: "FCT", "DUP", "1", 70: "FCT", "CONJ", "1", 71: "FCT", "-", "0", 72: "INT", "2", "0", 73: "NOM", "i", "0", 74: "FCT", "*", "0", 75: "FCT", "/", "0", 76: NULL, 77: 78: "ACOS", "1", NULL, 79: "INT", "1", "0", 80: "FCT", "SWAP", "2", 81: "FCT", "SQ", "1", 82: "FCT", "-", "0", 83: "FCT", "SQRT", "1", 84: "FCT", "INV", "1", 85: "FCT", "NEG", "1", 86: NULL, 87: 88: "ACOSH", "1", NULL, 89: "FCT", "DUP", "1", 90: "INT", "1", "0", 91: "FCT", "-", "0", 92: "FCT", "SQRT", "1", 93: "FCT", "SWAP", "1", 94: "INT", "1", "0", 95: "FCT", "+", "0", 96: "FCT", "SQRT", "1", 97: "FCT", "*", "0", 98: "FCT", "INV", "1", 99: NULL, 100: 101: "ALOG", "1", NULL, 102: "FCT", "ALOG", "1", 103: "INT", "10", "0", 104: "FCT", "LN", "1", 105: "FCT", "*", "0", 106: NULL, 107: 108: "ASIN", "1", NULL, 109: "INT", "1", "0", 110: "FCT", "SWAP", "2", 111: "FCT", "SQ", "1", 112: "FCT", "-", "0", 113: "FCT", "SQRT", "1", 114: "FCT", "INV", "1", 115: NULL, 116: 117: "ASINH", "1", NULL, 118: "FCT", "SQ", "1", 119: "INT", "1", "0", 120: "FCT", "SWAP", "2", 121: "FCT", "+", "0", 122: "FCT", "SQRT", "1", 123: "FCT", "INV", "1", 124: NULL, 125: 126: "ATAN", "1", NULL, 127: "INT", "1", "0", 128: "FCT", "SWAP", "2", 129: "FCT", "SQ", "1", 130: "FCT", "+", "0", 131: "FCT", "INV", "1", 132: NULL, 133: 134: "ATANH", "1", NULL, 135: "FCT", "SQ", "1", 136: "INT", "1", "0", 137: "FCT", "SWAP", "2", 138: "FCT", "-", "0", 139: "FCT", "INV", "1", 140: NULL, 141: 142: "CONJ", "1", NULL, 143: "FCT", "SWAP", "2", 144: "FCT", "DROP", "1", 145: "DER", "0", "0", 146: "FCT", "CONJ", "1", 147: "INT", "1", "0", 148: NULL, 149: 150: "COS", "1", NULL, 151: "FCT", "SIN", "1", 152: "FCT", "NEG", "1", 153: NULL, 154: 155: "COSH", "1", NULL, 156: "FCT", "SINH", "1", 157: NULL, 158: 159: "EXP", "1", NULL, 160: "FCT", "EXP", "1", 161: NULL, 162: 163: "EXPM", "1", NULL, 164: "FCT", "EXP", "1", 165: NULL, 166: 167: "IM", "1", NULL, 168: "FCT", "SWAP", "2", 169: "FCT", "DROP", "1", 170: "DER", "0", "0", 171: "FCT", "IM", "1", 172: "INT", "1", "0", 173: NULL, 174: 175: "INV", "1", NULL, 176: "FCT", "SQ", "1", 177: "FCT", "INV", "1", 178: "FCT", "NEG", "1", 179: NULL, 180: 181: "LN", "1", NULL, 182: "FCT", "INV", "1", 183: NULL, 184: 185: "LNP1", "1", NULL, 186: "INT", "1", "0", 187: "FCT", "+", "0", 188: "FCT", "INV", "1", 189: NULL, 190: 191: "LOG", "1", NULL, 192: "INT", "10", "0", 193: "FCT", "LN", "1", 194: "FCT", "*", "0", 195: "FCT", "INV", "1", 196: NULL, 197: 198: "NEG", "1", NULL, 199: "FCT", "SWAP", "2", 200: "FCT", "DROP", "1", 201: "DER", "0", "0", 202: "FCT", "NEG", "1", 203: "INT", "1", "0", 204: NULL, 205: 206: "RE", "1", NULL, 207: "FCT", "SWAP", "2", 208: "FCT", "DROP", "1", 209: "DER", "0", "0", 210: "FCT", "RE", "1", 211: "INT", "1", "0", 212: NULL, 213: 214: "RELAX", "1", NULL, 215: "FCT", "DROP", "1", 216: "INT", "1", "0", 217: NULL, 218: 219: "SIN", "1", NULL, 220: "FCT", "COS", "1", 221: NULL, 222: 223: "SINH", "1", NULL, 224: "FCT", "COSH", "1", 225: NULL, 226: 227: "SQ", "1", NULL, 228: "INT", "2", "0", 229: "FCT", "*", "0", 230: NULL, 231: 232: "SQRT", "1", NULL, 233: "FCT", "SQRT", "1", 234: "INT", "2", "0", 235: "FCT", "*", "0", 236: "FCT", "INV", "1", 237: NULL, 238: 239: "TAN", "1", NULL, 240: "INT", "1", "0", 241: "FCT", "SWAP", "2", 242: "FCT", "TAN", "1", 243: "FCT", "SQ", "1", 244: "FCT", "+", "0", 245: NULL, 246: 247: "TANH", "1", NULL, 248: "FCT", "COSH", "1", 249: "FCT", "SQ", "1", 250: "FCT", "INV", "1", 251: NULL, 252: 253: "XROOT", "2", NULL, 254: "FCT", "INV", "1", 255: "FCT", "**", "0", 256: "DER", "0", "0", 257: NULL, 258: 259: "=" , "0", NULL, 260: "FCT", "SWAP", "2", 261: "FCT", "DROP", "1", 262: "FCT", "SWAP", "2", 263: "DER", "0", "0", 264: "FCT", "SWAP", "2", 265: "DER", "0", "0", 266: "FCT", "=", "0", 267: "INT", "1", "0", 268: NULL, 269: 270: NULL 271: }; 272: 273: struct_liste_chainee *l_element_courant; 274: struct_liste_chainee *l_element_suivant; 275: 276: struct_objet *s_copie; 277: struct_objet *s_expression_courante; 278: 279: unsigned char *tampon; 280: unsigned char *variable; 281: 282: unsigned long i; 283: unsigned long position_courante; 284: unsigned long type_operation; 285: 286: if ((s_copie = copie_objet(s_etat_processus, *s_expression, 'O')) == NULL) 287: { 288: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 289: return; 290: } 291: 292: liberation(s_etat_processus, *s_expression); 293: *s_expression = s_copie; 294: s_expression_courante = *s_expression; 295: 296: do 297: { 298: /* 299: * Recherche de la première occurrence de la fonction DER 300: */ 301: 302: l_element_courant = (struct_liste_chainee *) 303: (*s_expression_courante).objet; 304: position_courante = 0; 305: drapeau = d_faux; 306: 307: while((l_element_courant != NULL) && (drapeau == d_faux)) 308: { 309: if ((*(*l_element_courant).donnee).type == FCT) 310: { 311: if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee) 312: .objet)).nom_fonction, "DER") == 0) 313: { 314: drapeau = d_vrai; 315: } 316: } 317: 318: l_element_courant = (*l_element_courant).suivant; 319: 320: if (drapeau == d_faux) 321: { 322: position_courante++; 323: } 324: } 325: 326: l_element_courant = (struct_liste_chainee *) 327: (*s_expression_courante).objet; 328: 329: for(i = 0; i < (position_courante - 2); 330: i++, l_element_courant = (*l_element_courant).suivant); 331: 332: variable = (*((struct_nom *) (*(*(*l_element_courant).suivant) 333: .donnee).objet)).nom; 334: 335: /* 336: * Recherche du type d'objet à dériver 337: */ 338: 339: if (((*(*l_element_courant).donnee).type == INT) || 340: ((*(*l_element_courant).donnee).type == REL) || 341: ((*(*l_element_courant).donnee).type == CPL)) 342: { 343: l_element_suivant = (*(*(*l_element_courant).suivant) 344: .suivant).suivant; 345: 346: liberation(s_etat_processus, (*l_element_courant).donnee); 347: liberation(s_etat_processus, 348: (*(*l_element_courant).suivant).donnee); 349: liberation(s_etat_processus, 350: (*(*(*l_element_courant).suivant).suivant).donnee); 351: 352: free((*(*l_element_courant).suivant).suivant); 353: free((*l_element_courant).suivant); 354: 355: (*l_element_courant).suivant = l_element_suivant; 356: 357: if (((*l_element_courant).donnee = allocation(s_etat_processus, 358: INT)) == NULL) 359: { 360: (*s_expression) = s_expression_courante; 361: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 362: return; 363: } 364: 365: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = 0; 366: } 367: else if ((*(*l_element_courant).donnee).type == NOM) 368: { 369: l_element_suivant = (*(*(*l_element_courant).suivant) 370: .suivant).suivant; 371: 372: if (strcmp((*((struct_nom *) (*(*l_element_courant).donnee).objet)) 373: .nom, variable) == 0) 374: { 375: derivee = 1; 376: } 377: else 378: { 379: derivee = 0; 380: } 381: 382: liberation(s_etat_processus, (*l_element_courant).donnee); 383: liberation(s_etat_processus, 384: (*(*l_element_courant).suivant).donnee); 385: liberation(s_etat_processus, 386: (*(*(*l_element_courant).suivant).suivant).donnee); 387: 388: free((*(*l_element_courant).suivant).suivant); 389: free((*l_element_courant).suivant); 390: 391: (*l_element_courant).suivant = l_element_suivant; 392: 393: if (((*l_element_courant).donnee = allocation(s_etat_processus, 394: INT)) == NULL) 395: { 396: (*s_expression) = s_expression_courante; 397: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 398: return; 399: } 400: 401: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = derivee; 402: } 403: else if ((*(*l_element_courant).donnee).type == FCT) 404: { 405: if ((strcmp((*((struct_fonction *) (*(*l_element_courant).donnee) 406: .objet)).nom_fonction, "+") == 0) || 407: (strcmp((*((struct_fonction *) (*(*l_element_courant) 408: .donnee).objet)).nom_fonction, "-") == 0)) 409: { 410: if (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee) 411: .objet)).nom_fonction, "+") == 0) 412: { 413: // Opération à dériver : '+' 414: type_operation = 0; 415: } 416: else 417: { 418: // Opération à dériver : '-' 419: type_operation = 1; 420: } 421: 422: /* 423: * Transormer << + X DER >> en << SWAP X DER SWAP X DER + >> 424: * ou << - X DER >> en << SWAP X DER SWAP X DER - >> 425: */ 426: 427: // Transformation du '+' en SWAP 428: 429: l_element_suivant = (*l_element_courant).suivant; 430: 431: free((*((struct_fonction *) (*(*l_element_courant).donnee) 432: .objet)).nom_fonction); 433: 434: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 435: .objet)).nom_fonction = malloc(5 * 436: sizeof(unsigned char))) == NULL) 437: { 438: (*s_expression) = s_expression_courante; 439: (*s_etat_processus).erreur_systeme = 440: d_es_allocation_memoire; 441: return; 442: } 443: 444: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 445: .objet)).nom_fonction, "SWAP"); 446: (*((struct_fonction *) (*(*l_element_courant).donnee) 447: .objet)).nombre_arguments = -1; 448: (*((struct_fonction *) (*(*l_element_courant).donnee) 449: .objet)).fonction = instruction_swap; 450: 451: // Ajout de la variable de dérivation 452: 453: if (((*l_element_courant).suivant = malloc( 454: sizeof(struct_liste_chainee))) == NULL) 455: { 456: (*s_expression) = s_expression_courante; 457: (*s_etat_processus).erreur_systeme = 458: d_es_allocation_memoire; 459: return; 460: } 461: 462: l_element_courant = (*l_element_courant).suivant; 463: 464: if (((*l_element_courant).donnee = allocation(s_etat_processus, 465: NOM)) == NULL) 466: { 467: (*s_expression) = s_expression_courante; 468: (*s_etat_processus).erreur_systeme = 469: d_es_allocation_memoire; 470: return; 471: } 472: 473: if (((*((struct_nom *) (*(*l_element_courant).donnee) 474: .objet)).nom = malloc((strlen(variable) + 1) 475: * sizeof(unsigned char))) == NULL) 476: { 477: (*s_expression) = s_expression_courante; 478: (*s_etat_processus).erreur_systeme = 479: d_es_allocation_memoire; 480: return; 481: } 482: 483: strcpy((*((struct_nom *) (*(*l_element_courant).donnee) 484: .objet)).nom, variable); 485: (*((struct_nom *) (*(*l_element_courant).donnee).objet)) 486: .symbole = d_vrai; 487: 488: // Ajout de la fonction DER 489: 490: if (((*l_element_courant).suivant = malloc( 491: sizeof(struct_liste_chainee))) == NULL) 492: { 493: (*s_expression) = s_expression_courante; 494: (*s_etat_processus).erreur_systeme = 495: d_es_allocation_memoire; 496: return; 497: } 498: 499: l_element_courant = (*l_element_courant).suivant; 500: 501: if (((*l_element_courant).donnee = allocation(s_etat_processus, 502: FCT)) == NULL) 503: { 504: (*s_expression) = s_expression_courante; 505: (*s_etat_processus).erreur_systeme = 506: d_es_allocation_memoire; 507: return; 508: } 509: 510: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 511: .objet)).nom_fonction = malloc(4 * 512: sizeof(unsigned char))) == NULL) 513: { 514: (*s_expression) = s_expression_courante; 515: (*s_etat_processus).erreur_systeme = 516: d_es_allocation_memoire; 517: return; 518: } 519: 520: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 521: .objet)).nom_fonction, "DER"); 522: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 523: .nombre_arguments = 2; 524: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 525: .fonction = instruction_der; 526: 527: // Ajout de la fonction SWAP 528: 529: if (((*l_element_courant).suivant = malloc( 530: sizeof(struct_liste_chainee))) == NULL) 531: { 532: (*s_expression) = s_expression_courante; 533: (*s_etat_processus).erreur_systeme = 534: d_es_allocation_memoire; 535: return; 536: } 537: 538: l_element_courant = (*l_element_courant).suivant; 539: 540: if (((*l_element_courant).donnee = allocation(s_etat_processus, 541: FCT)) == NULL) 542: { 543: (*s_expression) = s_expression_courante; 544: (*s_etat_processus).erreur_systeme = 545: d_es_allocation_memoire; 546: return; 547: } 548: 549: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 550: .objet)).nom_fonction = malloc(5 * 551: sizeof(unsigned char))) == NULL) 552: { 553: (*s_expression) = s_expression_courante; 554: (*s_etat_processus).erreur_systeme = 555: d_es_allocation_memoire; 556: return; 557: } 558: 559: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 560: .objet)).nom_fonction, "SWAP"); 561: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 562: .nombre_arguments = -1; 563: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 564: .fonction = instruction_swap; 565: 566: // Ajout de la variable de dérivation 567: 568: if (((*l_element_courant).suivant = malloc( 569: sizeof(struct_liste_chainee))) == NULL) 570: { 571: (*s_expression) = s_expression_courante; 572: (*s_etat_processus).erreur_systeme = 573: d_es_allocation_memoire; 574: return; 575: } 576: 577: l_element_courant = (*l_element_courant).suivant; 578: 579: if (((*l_element_courant).donnee = allocation(s_etat_processus, 580: NOM)) == NULL) 581: { 582: (*s_expression) = s_expression_courante; 583: (*s_etat_processus).erreur_systeme = 584: d_es_allocation_memoire; 585: return; 586: } 587: 588: if (((*((struct_nom *) (*(*l_element_courant).donnee) 589: .objet)).nom = malloc((strlen(variable) + 1) 590: * sizeof(unsigned char))) == NULL) 591: { 592: (*s_expression) = s_expression_courante; 593: (*s_etat_processus).erreur_systeme = 594: d_es_allocation_memoire; 595: return; 596: } 597: 598: strcpy((*((struct_nom *) (*(*l_element_courant).donnee) 599: .objet)).nom, variable); 600: (*((struct_nom *) (*(*l_element_courant).donnee).objet)) 601: .symbole = d_vrai; 602: 603: // Ajout de la fonction DER 604: 605: if (((*l_element_courant).suivant = malloc( 606: sizeof(struct_liste_chainee))) == NULL) 607: { 608: (*s_expression) = s_expression_courante; 609: (*s_etat_processus).erreur_systeme = 610: d_es_allocation_memoire; 611: return; 612: } 613: 614: l_element_courant = (*l_element_courant).suivant; 615: 616: if (((*l_element_courant).donnee = allocation(s_etat_processus, 617: FCT)) == NULL) 618: { 619: (*s_expression) = s_expression_courante; 620: (*s_etat_processus).erreur_systeme = 621: d_es_allocation_memoire; 622: return; 623: } 624: 625: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 626: .objet)).nom_fonction = malloc(4 * 627: sizeof(unsigned char))) == NULL) 628: { 629: (*s_expression) = s_expression_courante; 630: (*s_etat_processus).erreur_systeme = 631: d_es_allocation_memoire; 632: return; 633: } 634: 635: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 636: .objet)).nom_fonction, "DER"); 637: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 638: .nombre_arguments = 2; 639: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 640: .fonction = instruction_der; 641: 642: (*l_element_courant).suivant = (*l_element_suivant).suivant; 643: 644: liberation(s_etat_processus, (*l_element_suivant).donnee); 645: free(l_element_suivant); 646: 647: // Ajout de l'opérateur 648: 649: l_element_courant = (*l_element_courant).suivant; 650: 651: free((*((struct_fonction *) (*(*l_element_courant).donnee) 652: .objet)).nom_fonction); 653: 654: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 655: .objet)).nom_fonction = malloc(2 * 656: sizeof(unsigned char))) == NULL) 657: { 658: (*s_expression) = s_expression_courante; 659: (*s_etat_processus).erreur_systeme = 660: d_es_allocation_memoire; 661: return; 662: } 663: 664: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 665: .objet)).nom_fonction, 666: (type_operation == 0) ? "+" : "-"); 667: (*((struct_fonction *) (*(*l_element_courant).donnee) 668: .objet)).nombre_arguments = 0; 669: (*((struct_fonction *) (*(*l_element_courant).donnee) 670: .objet)).fonction = (type_operation == 0) 671: ? instruction_plus : instruction_moins; 672: } 673: else if (strcmp((*((struct_fonction *) 674: (*(*l_element_courant).donnee) 675: .objet)).nom_fonction, "*") == 0) 676: { 677: /* 678: * Transormer << * X DER >> en 679: * << DUP2 X DER * ROT X DER ROT * + >> 680: */ 681: 682: // Transformation du '*' en DUP2 683: 684: l_element_suivant = (*l_element_courant).suivant; 685: 686: free((*((struct_fonction *) (*(*l_element_courant).donnee) 687: .objet)).nom_fonction); 688: 689: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 690: .objet)).nom_fonction = malloc(5 * 691: sizeof(unsigned char))) == NULL) 692: { 693: (*s_expression) = s_expression_courante; 694: (*s_etat_processus).erreur_systeme = 695: d_es_allocation_memoire; 696: return; 697: } 698: 699: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 700: .objet)).nom_fonction, "DUP2"); 701: (*((struct_fonction *) (*(*l_element_courant).donnee) 702: .objet)).nombre_arguments = -1; 703: (*((struct_fonction *) (*(*l_element_courant).donnee) 704: .objet)).fonction = instruction_dup2; 705: 706: // Ajout de la variable de dérivation 707: 708: if (((*l_element_courant).suivant = malloc( 709: sizeof(struct_liste_chainee))) == NULL) 710: { 711: (*s_expression) = s_expression_courante; 712: (*s_etat_processus).erreur_systeme = 713: d_es_allocation_memoire; 714: return; 715: } 716: 717: l_element_courant = (*l_element_courant).suivant; 718: 719: if (((*l_element_courant).donnee = allocation(s_etat_processus, 720: NOM)) == NULL) 721: { 722: (*s_expression) = s_expression_courante; 723: (*s_etat_processus).erreur_systeme = 724: d_es_allocation_memoire; 725: return; 726: } 727: 728: if (((*((struct_nom *) (*(*l_element_courant).donnee) 729: .objet)).nom = malloc((strlen(variable) + 1) 730: * sizeof(unsigned char))) == NULL) 731: { 732: (*s_expression) = s_expression_courante; 733: (*s_etat_processus).erreur_systeme = 734: d_es_allocation_memoire; 735: return; 736: } 737: 738: strcpy((*((struct_nom *) (*(*l_element_courant).donnee) 739: .objet)).nom, variable); 740: (*((struct_nom *) (*(*l_element_courant).donnee).objet)) 741: .symbole = d_vrai; 742: 743: // Ajout de la fonction DER 744: 745: if (((*l_element_courant).suivant = malloc( 746: sizeof(struct_liste_chainee))) == NULL) 747: { 748: (*s_expression) = s_expression_courante; 749: (*s_etat_processus).erreur_systeme = 750: d_es_allocation_memoire; 751: return; 752: } 753: 754: l_element_courant = (*l_element_courant).suivant; 755: 756: if (((*l_element_courant).donnee = allocation(s_etat_processus, 757: FCT)) == NULL) 758: { 759: (*s_expression) = s_expression_courante; 760: (*s_etat_processus).erreur_systeme = 761: d_es_allocation_memoire; 762: return; 763: } 764: 765: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 766: .objet)).nom_fonction = malloc(4 * 767: sizeof(unsigned char))) == NULL) 768: { 769: (*s_expression) = s_expression_courante; 770: (*s_etat_processus).erreur_systeme = 771: d_es_allocation_memoire; 772: return; 773: } 774: 775: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 776: .objet)).nom_fonction, "DER"); 777: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 778: .nombre_arguments = 2; 779: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 780: .fonction = instruction_der; 781: 782: // Ajout de la fonction '*' 783: 784: if (((*l_element_courant).suivant = malloc( 785: sizeof(struct_liste_chainee))) == NULL) 786: { 787: (*s_expression) = s_expression_courante; 788: (*s_etat_processus).erreur_systeme = 789: d_es_allocation_memoire; 790: return; 791: } 792: 793: l_element_courant = (*l_element_courant).suivant; 794: 795: if (((*l_element_courant).donnee = allocation(s_etat_processus, 796: FCT)) == NULL) 797: { 798: (*s_expression) = s_expression_courante; 799: (*s_etat_processus).erreur_systeme = 800: d_es_allocation_memoire; 801: return; 802: } 803: 804: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 805: .objet)).nom_fonction = malloc(2 * 806: sizeof(unsigned char))) == NULL) 807: { 808: (*s_expression) = s_expression_courante; 809: (*s_etat_processus).erreur_systeme = 810: d_es_allocation_memoire; 811: return; 812: } 813: 814: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 815: .objet)).nom_fonction, "*"); 816: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 817: .nombre_arguments = 0; 818: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 819: .fonction = instruction_multiplication; 820: 821: // Ajout de la fonction ROT 822: 823: if (((*l_element_courant).suivant = malloc( 824: sizeof(struct_liste_chainee))) == NULL) 825: { 826: (*s_expression) = s_expression_courante; 827: (*s_etat_processus).erreur_systeme = 828: d_es_allocation_memoire; 829: return; 830: } 831: 832: l_element_courant = (*l_element_courant).suivant; 833: 834: if (((*l_element_courant).donnee = allocation(s_etat_processus, 835: FCT)) == NULL) 836: { 837: (*s_expression) = s_expression_courante; 838: (*s_etat_processus).erreur_systeme = 839: d_es_allocation_memoire; 840: return; 841: } 842: 843: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 844: .objet)).nom_fonction = malloc(4 * 845: sizeof(unsigned char))) == NULL) 846: { 847: (*s_expression) = s_expression_courante; 848: (*s_etat_processus).erreur_systeme = 849: d_es_allocation_memoire; 850: return; 851: } 852: 853: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 854: .objet)).nom_fonction, "ROT"); 855: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 856: .nombre_arguments = -1; 857: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 858: .fonction = instruction_rot; 859: 860: // Ajout de la variable de dérivation 861: 862: if (((*l_element_courant).suivant = malloc( 863: sizeof(struct_liste_chainee))) == NULL) 864: { 865: (*s_expression) = s_expression_courante; 866: (*s_etat_processus).erreur_systeme = 867: d_es_allocation_memoire; 868: return; 869: } 870: 871: l_element_courant = (*l_element_courant).suivant; 872: 873: if (((*l_element_courant).donnee = allocation(s_etat_processus, 874: NOM)) == NULL) 875: { 876: (*s_expression) = s_expression_courante; 877: (*s_etat_processus).erreur_systeme = 878: d_es_allocation_memoire; 879: return; 880: } 881: 882: if (((*((struct_nom *) (*(*l_element_courant).donnee) 883: .objet)).nom = malloc((strlen(variable) + 1) 884: * sizeof(unsigned char))) == NULL) 885: { 886: (*s_expression) = s_expression_courante; 887: (*s_etat_processus).erreur_systeme = 888: d_es_allocation_memoire; 889: return; 890: } 891: 892: strcpy((*((struct_nom *) (*(*l_element_courant).donnee) 893: .objet)).nom, variable); 894: (*((struct_nom *) (*(*l_element_courant).donnee).objet)) 895: .symbole = d_vrai; 896: 897: // Ajout de la fonction DER 898: 899: if (((*l_element_courant).suivant = malloc( 900: sizeof(struct_liste_chainee))) == NULL) 901: { 902: (*s_expression) = s_expression_courante; 903: (*s_etat_processus).erreur_systeme = 904: d_es_allocation_memoire; 905: return; 906: } 907: 908: l_element_courant = (*l_element_courant).suivant; 909: 910: if (((*l_element_courant).donnee = allocation(s_etat_processus, 911: FCT)) == NULL) 912: { 913: (*s_expression) = s_expression_courante; 914: (*s_etat_processus).erreur_systeme = 915: d_es_allocation_memoire; 916: return; 917: } 918: 919: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 920: .objet)).nom_fonction = malloc(4 * 921: sizeof(unsigned char))) == NULL) 922: { 923: (*s_expression) = s_expression_courante; 924: (*s_etat_processus).erreur_systeme = 925: d_es_allocation_memoire; 926: return; 927: } 928: 929: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 930: .objet)).nom_fonction, "DER"); 931: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 932: .nombre_arguments = 2; 933: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 934: .fonction = instruction_der; 935: 936: // Ajout de la fonction ROT 937: 938: if (((*l_element_courant).suivant = malloc( 939: sizeof(struct_liste_chainee))) == NULL) 940: { 941: (*s_expression) = s_expression_courante; 942: (*s_etat_processus).erreur_systeme = 943: d_es_allocation_memoire; 944: return; 945: } 946: 947: l_element_courant = (*l_element_courant).suivant; 948: 949: if (((*l_element_courant).donnee = allocation(s_etat_processus, 950: FCT)) == NULL) 951: { 952: (*s_expression) = s_expression_courante; 953: (*s_etat_processus).erreur_systeme = 954: d_es_allocation_memoire; 955: return; 956: } 957: 958: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 959: .objet)).nom_fonction = malloc(4 * 960: sizeof(unsigned char))) == NULL) 961: { 962: (*s_expression) = s_expression_courante; 963: (*s_etat_processus).erreur_systeme = 964: d_es_allocation_memoire; 965: return; 966: } 967: 968: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 969: .objet)).nom_fonction, "ROT"); 970: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 971: .nombre_arguments = -1; 972: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 973: .fonction = instruction_rot; 974: 975: // Ajout de la fonction '*' 976: 977: if (((*l_element_courant).suivant = malloc( 978: sizeof(struct_liste_chainee))) == NULL) 979: { 980: (*s_expression) = s_expression_courante; 981: (*s_etat_processus).erreur_systeme = 982: d_es_allocation_memoire; 983: return; 984: } 985: 986: l_element_courant = (*l_element_courant).suivant; 987: 988: if (((*l_element_courant).donnee = allocation(s_etat_processus, 989: FCT)) == NULL) 990: { 991: (*s_expression) = s_expression_courante; 992: (*s_etat_processus).erreur_systeme = 993: d_es_allocation_memoire; 994: return; 995: } 996: 997: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 998: .objet)).nom_fonction = malloc(2 * 999: sizeof(unsigned char))) == NULL) 1000: { 1001: (*s_expression) = s_expression_courante; 1002: (*s_etat_processus).erreur_systeme = 1003: d_es_allocation_memoire; 1004: return; 1005: } 1006: 1007: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1008: .objet)).nom_fonction, "*"); 1009: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1010: .nombre_arguments = 0; 1011: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1012: .fonction = instruction_multiplication; 1013: 1014: // Ajout de la fonction '+' 1015: 1016: (*l_element_courant).suivant = (*l_element_suivant).suivant; 1017: 1018: liberation(s_etat_processus, (*l_element_suivant).donnee); 1019: free(l_element_suivant); 1020: 1021: l_element_courant = (*l_element_courant).suivant; 1022: 1023: free((*((struct_fonction *) (*(*l_element_courant).donnee) 1024: .objet)).nom_fonction); 1025: 1026: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1027: .objet)).nom_fonction = malloc(2 * 1028: sizeof(unsigned char))) == NULL) 1029: { 1030: (*s_expression) = s_expression_courante; 1031: (*s_etat_processus).erreur_systeme = 1032: d_es_allocation_memoire; 1033: return; 1034: } 1035: 1036: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1037: .objet)).nom_fonction, "+"); 1038: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1039: .nombre_arguments = 0; 1040: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1041: .fonction = instruction_plus; 1042: } 1043: else if (strcmp((*((struct_fonction *) 1044: (*(*l_element_courant).donnee) 1045: .objet)).nom_fonction, "/") == 0) 1046: { 1047: /* 1048: * Transormer << / X DER >> en 1049: * << DUP2 DUP SQ ROT ROT X DER * SWAP / ROT X DER ROT / 1050: * SWAP - >> 1051: */ 1052: 1053: // Transformation du '/' en DUP2 1054: 1055: l_element_suivant = (*l_element_courant).suivant; 1056: 1057: free((*((struct_fonction *) (*(*l_element_courant).donnee) 1058: .objet)).nom_fonction); 1059: 1060: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1061: .objet)).nom_fonction = malloc(5 * 1062: sizeof(unsigned char))) == NULL) 1063: { 1064: (*s_expression) = s_expression_courante; 1065: (*s_etat_processus).erreur_systeme = 1066: d_es_allocation_memoire; 1067: return; 1068: } 1069: 1070: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1071: .objet)).nom_fonction, "DUP2"); 1072: (*((struct_fonction *) (*(*l_element_courant).donnee) 1073: .objet)).nombre_arguments = -1; 1074: (*((struct_fonction *) (*(*l_element_courant).donnee) 1075: .objet)).fonction = instruction_dup2; 1076: 1077: // Ajout de la fonction DUP 1078: 1079: if (((*l_element_courant).suivant = malloc( 1080: sizeof(struct_liste_chainee))) == NULL) 1081: { 1082: (*s_expression) = s_expression_courante; 1083: (*s_etat_processus).erreur_systeme = 1084: d_es_allocation_memoire; 1085: return; 1086: } 1087: 1088: l_element_courant = (*l_element_courant).suivant; 1089: 1090: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1091: FCT)) == NULL) 1092: { 1093: (*s_expression) = s_expression_courante; 1094: (*s_etat_processus).erreur_systeme = 1095: d_es_allocation_memoire; 1096: return; 1097: } 1098: 1099: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1100: .objet)).nom_fonction = malloc(4 * 1101: sizeof(unsigned char))) == NULL) 1102: { 1103: (*s_expression) = s_expression_courante; 1104: (*s_etat_processus).erreur_systeme = 1105: d_es_allocation_memoire; 1106: return; 1107: } 1108: 1109: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1110: .objet)).nom_fonction, "DUP"); 1111: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1112: .nombre_arguments = -1; 1113: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1114: .fonction = instruction_dup; 1115: 1116: // Ajout de la fonction SQ 1117: 1118: if (((*l_element_courant).suivant = malloc( 1119: sizeof(struct_liste_chainee))) == NULL) 1120: { 1121: (*s_expression) = s_expression_courante; 1122: (*s_etat_processus).erreur_systeme = 1123: d_es_allocation_memoire; 1124: return; 1125: } 1126: 1127: l_element_courant = (*l_element_courant).suivant; 1128: 1129: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1130: FCT)) == NULL) 1131: { 1132: (*s_expression) = s_expression_courante; 1133: (*s_etat_processus).erreur_systeme = 1134: d_es_allocation_memoire; 1135: return; 1136: } 1137: 1138: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1139: .objet)).nom_fonction = malloc(3 * 1140: sizeof(unsigned char))) == NULL) 1141: { 1142: (*s_expression) = s_expression_courante; 1143: (*s_etat_processus).erreur_systeme = 1144: d_es_allocation_memoire; 1145: return; 1146: } 1147: 1148: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1149: .objet)).nom_fonction, "SQ"); 1150: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1151: .nombre_arguments = 1; 1152: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1153: .fonction = instruction_sq; 1154: 1155: // Ajout de la fonction ROT 1156: 1157: if (((*l_element_courant).suivant = malloc( 1158: sizeof(struct_liste_chainee))) == NULL) 1159: { 1160: (*s_expression) = s_expression_courante; 1161: (*s_etat_processus).erreur_systeme = 1162: d_es_allocation_memoire; 1163: return; 1164: } 1165: 1166: l_element_courant = (*l_element_courant).suivant; 1167: 1168: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1169: FCT)) == NULL) 1170: { 1171: (*s_expression) = s_expression_courante; 1172: (*s_etat_processus).erreur_systeme = 1173: d_es_allocation_memoire; 1174: return; 1175: } 1176: 1177: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1178: .objet)).nom_fonction = malloc(4 * 1179: sizeof(unsigned char))) == NULL) 1180: { 1181: (*s_expression) = s_expression_courante; 1182: (*s_etat_processus).erreur_systeme = 1183: d_es_allocation_memoire; 1184: return; 1185: } 1186: 1187: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1188: .objet)).nom_fonction, "ROT"); 1189: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1190: .nombre_arguments = -1; 1191: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1192: .fonction = instruction_rot; 1193: 1194: // Ajout de la fonction ROT 1195: 1196: if (((*l_element_courant).suivant = malloc( 1197: sizeof(struct_liste_chainee))) == NULL) 1198: { 1199: (*s_expression) = s_expression_courante; 1200: (*s_etat_processus).erreur_systeme = 1201: d_es_allocation_memoire; 1202: return; 1203: } 1204: 1205: l_element_courant = (*l_element_courant).suivant; 1206: 1207: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1208: FCT)) == NULL) 1209: { 1210: (*s_expression) = s_expression_courante; 1211: (*s_etat_processus).erreur_systeme = 1212: d_es_allocation_memoire; 1213: return; 1214: } 1215: 1216: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1217: .objet)).nom_fonction = malloc(4 * 1218: sizeof(unsigned char))) == NULL) 1219: { 1220: (*s_expression) = s_expression_courante; 1221: (*s_etat_processus).erreur_systeme = 1222: d_es_allocation_memoire; 1223: return; 1224: } 1225: 1226: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1227: .objet)).nom_fonction, "ROT"); 1228: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1229: .nombre_arguments = -1; 1230: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1231: .fonction = instruction_rot; 1232: 1233: // Ajout de la variable de dérivation 1234: 1235: if (((*l_element_courant).suivant = malloc( 1236: sizeof(struct_liste_chainee))) == NULL) 1237: { 1238: (*s_expression) = s_expression_courante; 1239: (*s_etat_processus).erreur_systeme = 1240: d_es_allocation_memoire; 1241: return; 1242: } 1243: 1244: l_element_courant = (*l_element_courant).suivant; 1245: 1246: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1247: NOM)) == NULL) 1248: { 1249: (*s_expression) = s_expression_courante; 1250: (*s_etat_processus).erreur_systeme = 1251: d_es_allocation_memoire; 1252: return; 1253: } 1254: 1255: if (((*((struct_nom *) (*(*l_element_courant).donnee) 1256: .objet)).nom = malloc((strlen(variable) + 1) 1257: * sizeof(unsigned char))) == NULL) 1258: { 1259: (*s_expression) = s_expression_courante; 1260: (*s_etat_processus).erreur_systeme = 1261: d_es_allocation_memoire; 1262: return; 1263: } 1264: 1265: strcpy((*((struct_nom *) (*(*l_element_courant).donnee) 1266: .objet)).nom, variable); 1267: (*((struct_nom *) (*(*l_element_courant).donnee).objet)) 1268: .symbole = d_vrai; 1269: 1270: // Ajout de la fonction DER 1271: 1272: if (((*l_element_courant).suivant = malloc( 1273: sizeof(struct_liste_chainee))) == NULL) 1274: { 1275: (*s_expression) = s_expression_courante; 1276: (*s_etat_processus).erreur_systeme = 1277: d_es_allocation_memoire; 1278: return; 1279: } 1280: 1281: l_element_courant = (*l_element_courant).suivant; 1282: 1283: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1284: FCT)) == NULL) 1285: { 1286: (*s_expression) = s_expression_courante; 1287: (*s_etat_processus).erreur_systeme = 1288: d_es_allocation_memoire; 1289: return; 1290: } 1291: 1292: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1293: .objet)).nom_fonction = malloc(4 * 1294: sizeof(unsigned char))) == NULL) 1295: { 1296: (*s_expression) = s_expression_courante; 1297: (*s_etat_processus).erreur_systeme = 1298: d_es_allocation_memoire; 1299: return; 1300: } 1301: 1302: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1303: .objet)).nom_fonction, "DER"); 1304: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1305: .nombre_arguments = 2; 1306: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1307: .fonction = instruction_der; 1308: 1309: // Ajout de la fonction '*' 1310: 1311: if (((*l_element_courant).suivant = malloc( 1312: sizeof(struct_liste_chainee))) == NULL) 1313: { 1314: (*s_expression) = s_expression_courante; 1315: (*s_etat_processus).erreur_systeme = 1316: d_es_allocation_memoire; 1317: return; 1318: } 1319: 1320: l_element_courant = (*l_element_courant).suivant; 1321: 1322: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1323: FCT)) == NULL) 1324: { 1325: (*s_expression) = s_expression_courante; 1326: (*s_etat_processus).erreur_systeme = 1327: d_es_allocation_memoire; 1328: return; 1329: } 1330: 1331: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1332: .objet)).nom_fonction = malloc(2 * 1333: sizeof(unsigned char))) == NULL) 1334: { 1335: (*s_expression) = s_expression_courante; 1336: (*s_etat_processus).erreur_systeme = 1337: d_es_allocation_memoire; 1338: return; 1339: } 1340: 1341: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1342: .objet)).nom_fonction, "*"); 1343: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1344: .nombre_arguments = 0; 1345: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1346: .fonction = instruction_multiplication; 1347: 1348: // Ajout de la fonction SWAP 1349: 1350: if (((*l_element_courant).suivant = malloc( 1351: sizeof(struct_liste_chainee))) == NULL) 1352: { 1353: (*s_expression) = s_expression_courante; 1354: (*s_etat_processus).erreur_systeme = 1355: d_es_allocation_memoire; 1356: return; 1357: } 1358: 1359: l_element_courant = (*l_element_courant).suivant; 1360: 1361: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1362: FCT)) == NULL) 1363: { 1364: (*s_expression) = s_expression_courante; 1365: (*s_etat_processus).erreur_systeme = 1366: d_es_allocation_memoire; 1367: return; 1368: } 1369: 1370: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1371: .objet)).nom_fonction = malloc(5 * 1372: sizeof(unsigned char))) == NULL) 1373: { 1374: (*s_expression) = s_expression_courante; 1375: (*s_etat_processus).erreur_systeme = 1376: d_es_allocation_memoire; 1377: return; 1378: } 1379: 1380: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1381: .objet)).nom_fonction, "SWAP"); 1382: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1383: .nombre_arguments = -1; 1384: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1385: .fonction = instruction_swap; 1386: 1387: // Ajout de la fonction '/' 1388: 1389: if (((*l_element_courant).suivant = malloc( 1390: sizeof(struct_liste_chainee))) == NULL) 1391: { 1392: (*s_expression) = s_expression_courante; 1393: (*s_etat_processus).erreur_systeme = 1394: d_es_allocation_memoire; 1395: return; 1396: } 1397: 1398: l_element_courant = (*l_element_courant).suivant; 1399: 1400: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1401: FCT)) == NULL) 1402: { 1403: (*s_expression) = s_expression_courante; 1404: (*s_etat_processus).erreur_systeme = 1405: d_es_allocation_memoire; 1406: return; 1407: } 1408: 1409: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1410: .objet)).nom_fonction = malloc(2 * 1411: sizeof(unsigned char))) == NULL) 1412: { 1413: (*s_expression) = s_expression_courante; 1414: (*s_etat_processus).erreur_systeme = 1415: d_es_allocation_memoire; 1416: return; 1417: } 1418: 1419: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1420: .objet)).nom_fonction, "/"); 1421: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1422: .nombre_arguments = 0; 1423: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1424: .fonction = instruction_division; 1425: 1426: // Ajout de la fonction ROT 1427: 1428: if (((*l_element_courant).suivant = malloc( 1429: sizeof(struct_liste_chainee))) == NULL) 1430: { 1431: (*s_expression) = s_expression_courante; 1432: (*s_etat_processus).erreur_systeme = 1433: d_es_allocation_memoire; 1434: return; 1435: } 1436: 1437: l_element_courant = (*l_element_courant).suivant; 1438: 1439: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1440: FCT)) == NULL) 1441: { 1442: (*s_expression) = s_expression_courante; 1443: (*s_etat_processus).erreur_systeme = 1444: d_es_allocation_memoire; 1445: return; 1446: } 1447: 1448: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1449: .objet)).nom_fonction = malloc(4 * 1450: sizeof(unsigned char))) == NULL) 1451: { 1452: (*s_expression) = s_expression_courante; 1453: (*s_etat_processus).erreur_systeme = 1454: d_es_allocation_memoire; 1455: return; 1456: } 1457: 1458: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1459: .objet)).nom_fonction, "ROT"); 1460: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1461: .nombre_arguments = -1; 1462: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1463: .fonction = instruction_rot; 1464: 1465: // Ajout de la variable de dérivation 1466: 1467: if (((*l_element_courant).suivant = malloc( 1468: sizeof(struct_liste_chainee))) == NULL) 1469: { 1470: (*s_expression) = s_expression_courante; 1471: (*s_etat_processus).erreur_systeme = 1472: d_es_allocation_memoire; 1473: return; 1474: } 1475: 1476: l_element_courant = (*l_element_courant).suivant; 1477: 1478: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1479: NOM)) == NULL) 1480: { 1481: (*s_expression) = s_expression_courante; 1482: (*s_etat_processus).erreur_systeme = 1483: d_es_allocation_memoire; 1484: return; 1485: } 1486: 1487: if (((*((struct_nom *) (*(*l_element_courant).donnee) 1488: .objet)).nom = malloc((strlen(variable) + 1) 1489: * sizeof(unsigned char))) == NULL) 1490: { 1491: (*s_expression) = s_expression_courante; 1492: (*s_etat_processus).erreur_systeme = 1493: d_es_allocation_memoire; 1494: return; 1495: } 1496: 1497: strcpy((*((struct_nom *) (*(*l_element_courant).donnee) 1498: .objet)).nom, variable); 1499: (*((struct_nom *) (*(*l_element_courant).donnee).objet)) 1500: .symbole = d_vrai; 1501: 1502: // Ajout de la fonction DER 1503: 1504: if (((*l_element_courant).suivant = malloc( 1505: sizeof(struct_liste_chainee))) == NULL) 1506: { 1507: (*s_expression) = s_expression_courante; 1508: (*s_etat_processus).erreur_systeme = 1509: d_es_allocation_memoire; 1510: return; 1511: } 1512: 1513: l_element_courant = (*l_element_courant).suivant; 1514: 1515: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1516: FCT)) == NULL) 1517: { 1518: (*s_expression) = s_expression_courante; 1519: (*s_etat_processus).erreur_systeme = 1520: d_es_allocation_memoire; 1521: return; 1522: } 1523: 1524: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1525: .objet)).nom_fonction = malloc(4 * 1526: sizeof(unsigned char))) == NULL) 1527: { 1528: (*s_expression) = s_expression_courante; 1529: (*s_etat_processus).erreur_systeme = 1530: d_es_allocation_memoire; 1531: return; 1532: } 1533: 1534: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1535: .objet)).nom_fonction, "DER"); 1536: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1537: .nombre_arguments = 2; 1538: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1539: .fonction = instruction_der; 1540: 1541: // Ajout de la fonction ROT 1542: 1543: if (((*l_element_courant).suivant = malloc( 1544: sizeof(struct_liste_chainee))) == NULL) 1545: { 1546: (*s_expression) = s_expression_courante; 1547: (*s_etat_processus).erreur_systeme = 1548: d_es_allocation_memoire; 1549: return; 1550: } 1551: 1552: l_element_courant = (*l_element_courant).suivant; 1553: 1554: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1555: FCT)) == NULL) 1556: { 1557: (*s_expression) = s_expression_courante; 1558: (*s_etat_processus).erreur_systeme = 1559: d_es_allocation_memoire; 1560: return; 1561: } 1562: 1563: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1564: .objet)).nom_fonction = malloc(4 * 1565: sizeof(unsigned char))) == NULL) 1566: { 1567: (*s_expression) = s_expression_courante; 1568: (*s_etat_processus).erreur_systeme = 1569: d_es_allocation_memoire; 1570: return; 1571: } 1572: 1573: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1574: .objet)).nom_fonction, "ROT"); 1575: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1576: .nombre_arguments = -1; 1577: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1578: .fonction = instruction_rot; 1579: 1580: // Ajout de la fonction '/' 1581: 1582: if (((*l_element_courant).suivant = malloc( 1583: sizeof(struct_liste_chainee))) == NULL) 1584: { 1585: (*s_expression) = s_expression_courante; 1586: (*s_etat_processus).erreur_systeme = 1587: d_es_allocation_memoire; 1588: return; 1589: } 1590: 1591: l_element_courant = (*l_element_courant).suivant; 1592: 1593: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1594: FCT)) == NULL) 1595: { 1596: (*s_expression) = s_expression_courante; 1597: (*s_etat_processus).erreur_systeme = 1598: d_es_allocation_memoire; 1599: return; 1600: } 1601: 1602: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1603: .objet)).nom_fonction = malloc(2 * 1604: sizeof(unsigned char))) == NULL) 1605: { 1606: (*s_expression) = s_expression_courante; 1607: (*s_etat_processus).erreur_systeme = 1608: d_es_allocation_memoire; 1609: return; 1610: } 1611: 1612: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1613: .objet)).nom_fonction, "/"); 1614: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1615: .nombre_arguments = 0; 1616: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1617: .fonction = instruction_division; 1618: 1619: // Ajout de la fonction SWAP 1620: 1621: if (((*l_element_courant).suivant = malloc( 1622: sizeof(struct_liste_chainee))) == NULL) 1623: { 1624: (*s_expression) = s_expression_courante; 1625: (*s_etat_processus).erreur_systeme = 1626: d_es_allocation_memoire; 1627: return; 1628: } 1629: 1630: l_element_courant = (*l_element_courant).suivant; 1631: 1632: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1633: FCT)) == NULL) 1634: { 1635: (*s_expression) = s_expression_courante; 1636: (*s_etat_processus).erreur_systeme = 1637: d_es_allocation_memoire; 1638: return; 1639: } 1640: 1641: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1642: .objet)).nom_fonction = malloc(5 * 1643: sizeof(unsigned char))) == NULL) 1644: { 1645: (*s_expression) = s_expression_courante; 1646: (*s_etat_processus).erreur_systeme = 1647: d_es_allocation_memoire; 1648: return; 1649: } 1650: 1651: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1652: .objet)).nom_fonction, "SWAP"); 1653: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1654: .nombre_arguments = -1; 1655: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1656: .fonction = instruction_swap; 1657: 1658: // Ajout de la fonction '-' 1659: 1660: (*l_element_courant).suivant = (*l_element_suivant).suivant; 1661: 1662: liberation(s_etat_processus, (*l_element_suivant).donnee); 1663: free(l_element_suivant); 1664: 1665: l_element_courant = (*l_element_courant).suivant; 1666: 1667: free((*((struct_fonction *) (*(*l_element_courant).donnee) 1668: .objet)).nom_fonction); 1669: 1670: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1671: .objet)).nom_fonction = malloc(2 * 1672: sizeof(unsigned char))) == NULL) 1673: { 1674: (*s_expression) = s_expression_courante; 1675: (*s_etat_processus).erreur_systeme = 1676: d_es_allocation_memoire; 1677: return; 1678: } 1679: 1680: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1681: .objet)).nom_fonction, "-"); 1682: (*((struct_fonction *) (*(*l_element_courant).donnee) 1683: .objet)).nombre_arguments = 0; 1684: (*((struct_fonction *) (*(*l_element_courant).donnee) 1685: .objet)).fonction = instruction_moins; 1686: } 1687: else if ((strcmp((*((struct_fonction *) 1688: (*(*l_element_courant).donnee) 1689: .objet)).nom_fonction, "^") == 0) || 1690: (strcmp((*((struct_fonction *) (*(*l_element_courant) 1691: .donnee).objet)).nom_fonction , "**") == 0)) 1692: { 1693: /* 1694: * Transormer << ** X DER >> en 1695: * << OVER X DER ROT ROT DUP 1 - ROT SWAP ** * * >> 1696: */ 1697: 1698: // Transformation du '**' en OVER 1699: 1700: l_element_suivant = (*l_element_courant).suivant; 1701: 1702: free((*((struct_fonction *) (*(*l_element_courant).donnee) 1703: .objet)).nom_fonction); 1704: 1705: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1706: .objet)).nom_fonction = malloc(5 * 1707: sizeof(unsigned char))) == NULL) 1708: { 1709: (*s_expression) = s_expression_courante; 1710: (*s_etat_processus).erreur_systeme = 1711: d_es_allocation_memoire; 1712: return; 1713: } 1714: 1715: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1716: .objet)).nom_fonction, "OVER"); 1717: (*((struct_fonction *) (*(*l_element_courant).donnee) 1718: .objet)).nombre_arguments = -1; 1719: (*((struct_fonction *) (*(*l_element_courant).donnee) 1720: .objet)).fonction = instruction_over; 1721: 1722: // Ajout de la variable de dérivation 1723: 1724: if (((*l_element_courant).suivant = malloc( 1725: sizeof(struct_liste_chainee))) == NULL) 1726: { 1727: (*s_expression) = s_expression_courante; 1728: (*s_etat_processus).erreur_systeme = 1729: d_es_allocation_memoire; 1730: return; 1731: } 1732: 1733: l_element_courant = (*l_element_courant).suivant; 1734: 1735: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1736: NOM)) == NULL) 1737: { 1738: (*s_expression) = s_expression_courante; 1739: (*s_etat_processus).erreur_systeme = 1740: d_es_allocation_memoire; 1741: return; 1742: } 1743: 1744: if (((*((struct_nom *) (*(*l_element_courant).donnee) 1745: .objet)).nom = malloc((strlen(variable) + 1) 1746: * sizeof(unsigned char))) == NULL) 1747: { 1748: (*s_expression) = s_expression_courante; 1749: (*s_etat_processus).erreur_systeme = 1750: d_es_allocation_memoire; 1751: return; 1752: } 1753: 1754: strcpy((*((struct_nom *) (*(*l_element_courant).donnee) 1755: .objet)).nom, variable); 1756: (*((struct_nom *) (*(*l_element_courant).donnee).objet)) 1757: .symbole = d_vrai; 1758: 1759: // Ajout de la fonction DER 1760: 1761: if (((*l_element_courant).suivant = malloc( 1762: sizeof(struct_liste_chainee))) == NULL) 1763: { 1764: (*s_expression) = s_expression_courante; 1765: (*s_etat_processus).erreur_systeme = 1766: d_es_allocation_memoire; 1767: return; 1768: } 1769: 1770: l_element_courant = (*l_element_courant).suivant; 1771: 1772: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1773: FCT)) == NULL) 1774: { 1775: (*s_expression) = s_expression_courante; 1776: (*s_etat_processus).erreur_systeme = 1777: d_es_allocation_memoire; 1778: return; 1779: } 1780: 1781: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1782: .objet)).nom_fonction = malloc(4 * 1783: sizeof(unsigned char))) == NULL) 1784: { 1785: (*s_expression) = s_expression_courante; 1786: (*s_etat_processus).erreur_systeme = 1787: d_es_allocation_memoire; 1788: return; 1789: } 1790: 1791: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1792: .objet)).nom_fonction, "DER"); 1793: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1794: .nombre_arguments = 2; 1795: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1796: .fonction = instruction_der; 1797: 1798: // Ajout de la fonction ROT 1799: 1800: if (((*l_element_courant).suivant = malloc( 1801: sizeof(struct_liste_chainee))) == NULL) 1802: { 1803: (*s_expression) = s_expression_courante; 1804: (*s_etat_processus).erreur_systeme = 1805: d_es_allocation_memoire; 1806: return; 1807: } 1808: 1809: l_element_courant = (*l_element_courant).suivant; 1810: 1811: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1812: FCT)) == NULL) 1813: { 1814: (*s_expression) = s_expression_courante; 1815: (*s_etat_processus).erreur_systeme = 1816: d_es_allocation_memoire; 1817: return; 1818: } 1819: 1820: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1821: .objet)).nom_fonction = malloc(4 * 1822: sizeof(unsigned char))) == NULL) 1823: { 1824: (*s_expression) = s_expression_courante; 1825: (*s_etat_processus).erreur_systeme = 1826: d_es_allocation_memoire; 1827: return; 1828: } 1829: 1830: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1831: .objet)).nom_fonction, "ROT"); 1832: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1833: .nombre_arguments = -1; 1834: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1835: .fonction = instruction_rot; 1836: 1837: // Ajout de la fonction ROT 1838: 1839: if (((*l_element_courant).suivant = malloc( 1840: sizeof(struct_liste_chainee))) == NULL) 1841: { 1842: (*s_expression) = s_expression_courante; 1843: (*s_etat_processus).erreur_systeme = 1844: d_es_allocation_memoire; 1845: return; 1846: } 1847: 1848: l_element_courant = (*l_element_courant).suivant; 1849: 1850: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1851: FCT)) == NULL) 1852: { 1853: (*s_expression) = s_expression_courante; 1854: (*s_etat_processus).erreur_systeme = 1855: d_es_allocation_memoire; 1856: return; 1857: } 1858: 1859: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1860: .objet)).nom_fonction = malloc(4 * 1861: sizeof(unsigned char))) == NULL) 1862: { 1863: (*s_expression) = s_expression_courante; 1864: (*s_etat_processus).erreur_systeme = 1865: d_es_allocation_memoire; 1866: return; 1867: } 1868: 1869: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1870: .objet)).nom_fonction, "ROT"); 1871: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1872: .nombre_arguments = -1; 1873: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1874: .fonction = instruction_rot; 1875: 1876: // Ajout de la fonction DUP 1877: 1878: if (((*l_element_courant).suivant = malloc( 1879: sizeof(struct_liste_chainee))) == NULL) 1880: { 1881: (*s_expression) = s_expression_courante; 1882: (*s_etat_processus).erreur_systeme = 1883: d_es_allocation_memoire; 1884: return; 1885: } 1886: 1887: l_element_courant = (*l_element_courant).suivant; 1888: 1889: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1890: FCT)) == NULL) 1891: { 1892: (*s_expression) = s_expression_courante; 1893: (*s_etat_processus).erreur_systeme = 1894: d_es_allocation_memoire; 1895: return; 1896: } 1897: 1898: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1899: .objet)).nom_fonction = malloc(4 * 1900: sizeof(unsigned char))) == NULL) 1901: { 1902: (*s_expression) = s_expression_courante; 1903: (*s_etat_processus).erreur_systeme = 1904: d_es_allocation_memoire; 1905: return; 1906: } 1907: 1908: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1909: .objet)).nom_fonction, "DUP"); 1910: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1911: .nombre_arguments = -1; 1912: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1913: .fonction = instruction_dup; 1914: 1915: // Ajout de 1 sur la pile 1916: 1917: if (((*l_element_courant).suivant = malloc( 1918: sizeof(struct_liste_chainee))) == NULL) 1919: { 1920: (*s_expression) = s_expression_courante; 1921: (*s_etat_processus).erreur_systeme = 1922: d_es_allocation_memoire; 1923: return; 1924: } 1925: 1926: l_element_courant = (*l_element_courant).suivant; 1927: 1928: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1929: INT)) == NULL) 1930: { 1931: (*s_expression) = s_expression_courante; 1932: (*s_etat_processus).erreur_systeme = 1933: d_es_allocation_memoire; 1934: return; 1935: } 1936: 1937: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = 1; 1938: 1939: // Ajout de la fonction '-' 1940: 1941: if (((*l_element_courant).suivant = malloc( 1942: sizeof(struct_liste_chainee))) == NULL) 1943: { 1944: (*s_expression) = s_expression_courante; 1945: (*s_etat_processus).erreur_systeme = 1946: d_es_allocation_memoire; 1947: return; 1948: } 1949: 1950: l_element_courant = (*l_element_courant).suivant; 1951: 1952: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1953: FCT)) == NULL) 1954: { 1955: (*s_expression) = s_expression_courante; 1956: (*s_etat_processus).erreur_systeme = 1957: d_es_allocation_memoire; 1958: return; 1959: } 1960: 1961: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1962: .objet)).nom_fonction = malloc(2 * 1963: sizeof(unsigned char))) == NULL) 1964: { 1965: (*s_expression) = s_expression_courante; 1966: (*s_etat_processus).erreur_systeme = 1967: d_es_allocation_memoire; 1968: return; 1969: } 1970: 1971: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1972: .objet)).nom_fonction, "-"); 1973: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1974: .nombre_arguments = 0; 1975: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1976: .fonction = instruction_moins; 1977: 1978: // Ajout de la fonction ROT 1979: 1980: if (((*l_element_courant).suivant = malloc( 1981: sizeof(struct_liste_chainee))) == NULL) 1982: { 1983: (*s_expression) = s_expression_courante; 1984: (*s_etat_processus).erreur_systeme = 1985: d_es_allocation_memoire; 1986: return; 1987: } 1988: 1989: l_element_courant = (*l_element_courant).suivant; 1990: 1991: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1992: FCT)) == NULL) 1993: { 1994: (*s_expression) = s_expression_courante; 1995: (*s_etat_processus).erreur_systeme = 1996: d_es_allocation_memoire; 1997: return; 1998: } 1999: 2000: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 2001: .objet)).nom_fonction = malloc(4 * 2002: sizeof(unsigned char))) == NULL) 2003: { 2004: (*s_expression) = s_expression_courante; 2005: (*s_etat_processus).erreur_systeme = 2006: d_es_allocation_memoire; 2007: return; 2008: } 2009: 2010: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 2011: .objet)).nom_fonction, "ROT"); 2012: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 2013: .nombre_arguments = -1; 2014: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 2015: .fonction = instruction_rot; 2016: 2017: // Ajout de la fonction SWAP 2018: 2019: if (((*l_element_courant).suivant = malloc( 2020: sizeof(struct_liste_chainee))) == NULL) 2021: { 2022: (*s_expression) = s_expression_courante; 2023: (*s_etat_processus).erreur_systeme = 2024: d_es_allocation_memoire; 2025: return; 2026: } 2027: 2028: l_element_courant = (*l_element_courant).suivant; 2029: 2030: if (((*l_element_courant).donnee = allocation(s_etat_processus, 2031: FCT)) == NULL) 2032: { 2033: (*s_expression) = s_expression_courante; 2034: (*s_etat_processus).erreur_systeme = 2035: d_es_allocation_memoire; 2036: return; 2037: } 2038: 2039: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 2040: .objet)).nom_fonction = malloc(5 * 2041: sizeof(unsigned char))) == NULL) 2042: { 2043: (*s_expression) = s_expression_courante; 2044: (*s_etat_processus).erreur_systeme = 2045: d_es_allocation_memoire; 2046: return; 2047: } 2048: 2049: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 2050: .objet)).nom_fonction, "SWAP"); 2051: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 2052: .nombre_arguments = -1; 2053: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 2054: .fonction = instruction_swap; 2055: 2056: // Ajout de la fonction '**' 2057: 2058: if (((*l_element_courant).suivant = malloc( 2059: sizeof(struct_liste_chainee))) == NULL) 2060: { 2061: (*s_expression) = s_expression_courante; 2062: (*s_etat_processus).erreur_systeme = 2063: d_es_allocation_memoire; 2064: return; 2065: } 2066: 2067: l_element_courant = (*l_element_courant).suivant; 2068: 2069: if (((*l_element_courant).donnee = allocation(s_etat_processus, 2070: FCT)) == NULL) 2071: { 2072: (*s_expression) = s_expression_courante; 2073: (*s_etat_processus).erreur_systeme = 2074: d_es_allocation_memoire; 2075: return; 2076: } 2077: 2078: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 2079: .objet)).nom_fonction = malloc(3 * 2080: sizeof(unsigned char))) == NULL) 2081: { 2082: (*s_expression) = s_expression_courante; 2083: (*s_etat_processus).erreur_systeme = 2084: d_es_allocation_memoire; 2085: return; 2086: } 2087: 2088: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 2089: .objet)).nom_fonction, "**"); 2090: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 2091: .nombre_arguments = 0; 2092: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 2093: .fonction = instruction_puissance; 2094: 2095: // Ajout de la fonction '*' 2096: 2097: if (((*l_element_courant).suivant = malloc( 2098: sizeof(struct_liste_chainee))) == NULL) 2099: { 2100: (*s_expression) = s_expression_courante; 2101: (*s_etat_processus).erreur_systeme = 2102: d_es_allocation_memoire; 2103: return; 2104: } 2105: 2106: l_element_courant = (*l_element_courant).suivant; 2107: 2108: if (((*l_element_courant).donnee = allocation(s_etat_processus, 2109: FCT)) == NULL) 2110: { 2111: (*s_expression) = s_expression_courante; 2112: (*s_etat_processus).erreur_systeme = 2113: d_es_allocation_memoire; 2114: return; 2115: } 2116: 2117: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 2118: .objet)).nom_fonction = malloc(2 * 2119: sizeof(unsigned char))) == NULL) 2120: { 2121: (*s_expression) = s_expression_courante; 2122: (*s_etat_processus).erreur_systeme = 2123: d_es_allocation_memoire; 2124: return; 2125: } 2126: 2127: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 2128: .objet)).nom_fonction, "*"); 2129: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 2130: .nombre_arguments = 0; 2131: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 2132: .fonction = instruction_multiplication; 2133: 2134: // Ajout de la fonction '*' 2135: 2136: (*l_element_courant).suivant = (*l_element_suivant).suivant; 2137: 2138: liberation(s_etat_processus, (*l_element_suivant).donnee); 2139: free(l_element_suivant); 2140: 2141: l_element_courant = (*l_element_courant).suivant; 2142: 2143: free((*((struct_fonction *) (*(*l_element_courant).donnee) 2144: .objet)).nom_fonction); 2145: 2146: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 2147: .objet)).nom_fonction = malloc(2 * 2148: sizeof(unsigned char))) == NULL) 2149: { 2150: (*s_expression) = s_expression_courante; 2151: (*s_etat_processus).erreur_systeme = 2152: d_es_allocation_memoire; 2153: return; 2154: } 2155: 2156: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 2157: .objet)).nom_fonction, "*"); 2158: (*((struct_fonction *) (*(*l_element_courant).donnee) 2159: .objet)).nombre_arguments = 0; 2160: (*((struct_fonction *) (*(*l_element_courant).donnee) 2161: .objet)).fonction = instruction_multiplication; 2162: } 2163: 2164: /* 2165: * Traitement des fonctions 2166: */ 2167: 2168: else 2169: { 2170: derivee_fonction_disponible = d_faux; 2171: 2172: tampon = (*((struct_fonction *) (*(*l_element_courant) 2173: .donnee).objet)).nom_fonction; 2174: 2175: derivee_fonction_disponible = d_faux; 2176: fin_boucle = d_faux; 2177: 2178: i = 0; 2179: 2180: do 2181: { 2182: if (fonctions[i] == NULL) 2183: { 2184: /* 2185: * On saute les expressions dérivées, donc 2186: * on cherche le prochain NULL. 2187: */ 2188: 2189: while(fonctions[++i] != NULL); 2190: 2191: if (fonctions[++i] == NULL) 2192: { 2193: fin_boucle = d_vrai; 2194: } 2195: } 2196: else if (strcmp(fonctions[i], tampon) == 0) 2197: { 2198: /* 2199: * Vérification du nombre d'arguments de la fonction 2200: */ 2201: 2202: if ((*((struct_fonction *) (*(*l_element_courant) 2203: .donnee).objet)).nombre_arguments == 2204: (unsigned long) atol(fonctions[i + 1])) 2205: { 2206: i += 2; 2207: derivee_fonction_disponible = d_vrai; 2208: fin_boucle = d_vrai; 2209: 2210: while(fonctions[i] != NULL) 2211: { 2212: i++; 2213: } 2214: } 2215: } 2216: else 2217: { 2218: /* 2219: * Saut de la fonction et du nombre d'arguments 2220: */ 2221: 2222: i += 2; 2223: } 2224: } while(fin_boucle == d_faux); 2225: 2226: if (derivee_fonction_disponible == d_faux) 2227: { 2228: /* 2229: * Remplacement de 'fct' X DER par 2230: * 'Derfct(arg, X)' 2231: */ 2232: 2233: tampon = (*((struct_fonction *) (*(*l_element_courant) 2234: .donnee).objet)).nom_fonction; 2235: 2236: // Transformation du nom de la fonction 2237: // en variable de dérivation 2238: 2239: l_element_suivant = (*l_element_courant).suivant; 2240: 2241: free((*(*l_element_courant).donnee).objet); 2242: 2243: (*(*l_element_courant).donnee).type = NOM; 2244: 2245: if (((*(*l_element_courant).donnee).objet = malloc( 2246: sizeof(struct_nom))) == NULL) 2247: { 2248: (*s_expression) = s_expression_courante; 2249: (*s_etat_processus).erreur_systeme = 2250: d_es_allocation_memoire; 2251: return; 2252: } 2253: 2254: if (((*((struct_nom *) (*(*l_element_courant).donnee) 2255: .objet)).nom = malloc((strlen(variable) + 1) 2256: * sizeof(unsigned char))) == NULL) 2257: { 2258: (*s_expression) = s_expression_courante; 2259: (*s_etat_processus).erreur_systeme = 2260: d_es_allocation_memoire; 2261: return; 2262: } 2263: 2264: strcpy((*((struct_nom *) (*(*l_element_courant).donnee) 2265: .objet)).nom, variable); 2266: (*((struct_nom *) (*(*l_element_courant).donnee).objet)) 2267: .symbole = d_vrai; 2268: 2269: (*l_element_courant).suivant = 2270: (*l_element_suivant).suivant; 2271: 2272: liberation(s_etat_processus, (*l_element_suivant).donnee); 2273: free(l_element_suivant); 2274: 2275: l_element_courant = (*l_element_courant).suivant; 2276: 2277: free((*((struct_fonction *) (*(*l_element_courant).donnee) 2278: .objet)).nom_fonction); 2279: 2280: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 2281: .objet)).nom_fonction = malloc((strlen(tampon) + 4) 2282: * sizeof(unsigned char))) == NULL) 2283: { 2284: (*s_expression) = s_expression_courante; 2285: (*s_etat_processus).erreur_systeme = 2286: d_es_allocation_memoire; 2287: return; 2288: } 2289: 2290: strcat(strcpy((*((struct_fonction *) (*(*l_element_courant) 2291: .donnee).objet)).nom_fonction, "Der"), tampon); 2292: 2293: if ((*((struct_fonction *) (*(*l_element_courant).donnee) 2294: .objet)).nombre_arguments == 0) 2295: { 2296: (*((struct_fonction *) (*(*l_element_courant).donnee) 2297: .objet)).nombre_arguments = 3; 2298: } 2299: else 2300: { 2301: (*((struct_fonction *) (*(*l_element_courant).donnee) 2302: .objet)).nombre_arguments += 1; 2303: } 2304: 2305: free(tampon); 2306: } 2307: else 2308: { 2309: /* 2310: * Transormer << FCT X DER >> en 2311: * << DUP X DER SWAP DerFCT * >> 2312: */ 2313: 2314: // Transformation de la fonction à dériver en DUP 2315: 2316: l_element_suivant = (*l_element_courant).suivant; 2317: 2318: free((*((struct_fonction *) (*(*l_element_courant).donnee) 2319: .objet)).nom_fonction); 2320: 2321: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 2322: .objet)).nom_fonction = malloc(4 * 2323: sizeof(unsigned char))) == NULL) 2324: { 2325: (*s_expression) = s_expression_courante; 2326: (*s_etat_processus).erreur_systeme = 2327: d_es_allocation_memoire; 2328: return; 2329: } 2330: 2331: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 2332: .objet)).nom_fonction, "DUP"); 2333: (*((struct_fonction *) (*(*l_element_courant).donnee) 2334: .objet)).nombre_arguments = -1; 2335: (*((struct_fonction *) (*(*l_element_courant).donnee) 2336: .objet)).fonction = instruction_dup; 2337: 2338: // Ajout de la variable de dérivation 2339: 2340: if (((*l_element_courant).suivant = malloc( 2341: sizeof(struct_liste_chainee))) == NULL) 2342: { 2343: (*s_expression) = s_expression_courante; 2344: (*s_etat_processus).erreur_systeme = 2345: d_es_allocation_memoire; 2346: return; 2347: } 2348: 2349: l_element_courant = (*l_element_courant).suivant; 2350: 2351: if (((*l_element_courant).donnee = 2352: allocation(s_etat_processus, NOM)) == NULL) 2353: { 2354: (*s_expression) = s_expression_courante; 2355: (*s_etat_processus).erreur_systeme = 2356: d_es_allocation_memoire; 2357: return; 2358: } 2359: 2360: if (((*((struct_nom *) (*(*l_element_courant).donnee) 2361: .objet)).nom = malloc((strlen(variable) + 1) 2362: * sizeof(unsigned char))) == NULL) 2363: { 2364: (*s_expression) = s_expression_courante; 2365: (*s_etat_processus).erreur_systeme = 2366: d_es_allocation_memoire; 2367: return; 2368: } 2369: 2370: strcpy((*((struct_nom *) (*(*l_element_courant).donnee) 2371: .objet)).nom, variable); 2372: (*((struct_nom *) (*(*l_element_courant).donnee).objet)) 2373: .symbole = d_vrai; 2374: 2375: // Ajout de la fonction DER 2376: 2377: if (((*l_element_courant).suivant = malloc( 2378: sizeof(struct_liste_chainee))) == NULL) 2379: { 2380: (*s_expression) = s_expression_courante; 2381: (*s_etat_processus).erreur_systeme = 2382: d_es_allocation_memoire; 2383: return; 2384: } 2385: 2386: l_element_courant = (*l_element_courant).suivant; 2387: 2388: if (((*l_element_courant).donnee = 2389: allocation(s_etat_processus, FCT)) == NULL) 2390: { 2391: (*s_expression) = s_expression_courante; 2392: (*s_etat_processus).erreur_systeme = 2393: d_es_allocation_memoire; 2394: return; 2395: } 2396: 2397: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 2398: .objet)).nom_fonction = malloc(4 * 2399: sizeof(unsigned char))) == NULL) 2400: { 2401: (*s_expression) = s_expression_courante; 2402: (*s_etat_processus).erreur_systeme = 2403: d_es_allocation_memoire; 2404: return; 2405: } 2406: 2407: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 2408: .objet)).nom_fonction, "DER"); 2409: (*((struct_fonction *) (*(*l_element_courant).donnee) 2410: .objet)).nombre_arguments = 2; 2411: (*((struct_fonction *) (*(*l_element_courant).donnee) 2412: .objet)).fonction = instruction_der; 2413: 2414: // Ajout de la fonction SWAP 2415: 2416: if (((*l_element_courant).suivant = malloc( 2417: sizeof(struct_liste_chainee))) == NULL) 2418: { 2419: (*s_expression) = s_expression_courante; 2420: (*s_etat_processus).erreur_systeme = 2421: d_es_allocation_memoire; 2422: return; 2423: } 2424: 2425: l_element_courant = (*l_element_courant).suivant; 2426: 2427: if (((*l_element_courant).donnee = 2428: allocation(s_etat_processus, FCT)) == NULL) 2429: { 2430: (*s_expression) = s_expression_courante; 2431: (*s_etat_processus).erreur_systeme = 2432: d_es_allocation_memoire; 2433: return; 2434: } 2435: 2436: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 2437: .objet)).nom_fonction = malloc(5 * 2438: sizeof(unsigned char))) == NULL) 2439: { 2440: (*s_expression) = s_expression_courante; 2441: (*s_etat_processus).erreur_systeme = 2442: d_es_allocation_memoire; 2443: return; 2444: } 2445: 2446: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 2447: .objet)).nom_fonction, "SWAP"); 2448: (*((struct_fonction *) (*(*l_element_courant).donnee) 2449: .objet)).nombre_arguments = -1; 2450: (*((struct_fonction *) (*(*l_element_courant).donnee) 2451: .objet)).fonction = instruction_swap; 2452: 2453: // Ajout de la fonction dérivée 2454: 2455: i++; 2456: 2457: do 2458: { 2459: if (((*l_element_courant).suivant = malloc( 2460: sizeof(struct_liste_chainee))) == NULL) 2461: { 2462: (*s_expression) = s_expression_courante; 2463: (*s_etat_processus).erreur_systeme = 2464: d_es_allocation_memoire; 2465: return; 2466: } 2467: 2468: l_element_courant = (*l_element_courant).suivant; 2469: 2470: if (strcmp(fonctions[i], "FCT") == 0) 2471: { 2472: if (((*l_element_courant).donnee = allocation( 2473: s_etat_processus, FCT)) == NULL) 2474: { 2475: (*s_expression) = s_expression_courante; 2476: (*s_etat_processus).erreur_systeme = 2477: d_es_allocation_memoire; 2478: return; 2479: } 2480: 2481: if (((*((struct_fonction *) (*(*l_element_courant) 2482: .donnee).objet)).nom_fonction = malloc( 2483: (strlen(fonctions[i + 1]) + 1) * 2484: sizeof(unsigned char))) == NULL) 2485: { 2486: (*s_expression) = s_expression_courante; 2487: (*s_etat_processus).erreur_systeme = 2488: d_es_allocation_memoire; 2489: return; 2490: } 2491: 2492: strcpy((*((struct_fonction *) (*(*l_element_courant) 2493: .donnee).objet)).nom_fonction, 2494: fonctions[i + 1]); 2495: (*((struct_fonction *) (*(*l_element_courant) 2496: .donnee).objet)).nombre_arguments = 2497: atoi(fonctions[i + 2]); 2498: (*((struct_fonction *) (*(*l_element_courant) 2499: .donnee).objet)).fonction = 2500: analyse_instruction(s_etat_processus, 2501: fonctions[i + 1]); 2502: } 2503: else if (strcmp(fonctions[i], "INT") == 0) 2504: { 2505: if (((*l_element_courant).donnee = allocation( 2506: s_etat_processus, INT)) == NULL) 2507: { 2508: (*s_expression) = s_expression_courante; 2509: (*s_etat_processus).erreur_systeme = 2510: d_es_allocation_memoire; 2511: return; 2512: } 2513: 2514: (*((integer8 *) (*(*l_element_courant) 2515: .donnee).objet)) = atoi(fonctions[i + 1]); 2516: } 2517: else if (strcmp(fonctions[i], "NOM") == 0) 2518: { 2519: if (((*l_element_courant).donnee = allocation( 2520: s_etat_processus, NOM)) == NULL) 2521: { 2522: (*s_expression) = s_expression_courante; 2523: (*s_etat_processus).erreur_systeme = 2524: d_es_allocation_memoire; 2525: return; 2526: } 2527: 2528: if (((*((struct_nom *) (*(*l_element_courant) 2529: .donnee).objet)).nom = malloc( 2530: strlen((fonctions[i + 1]) + 1) * 2531: sizeof(unsigned char))) == NULL) 2532: { 2533: (*s_expression) = s_expression_courante; 2534: (*s_etat_processus).erreur_systeme = 2535: d_es_allocation_memoire; 2536: return; 2537: } 2538: 2539: strcpy((*((struct_nom *) (*(*l_element_courant) 2540: .donnee).objet)).nom, fonctions[i + 1]); 2541: (*((struct_nom *) (*(*l_element_courant) 2542: .donnee).objet)).symbole = d_vrai; 2543: } 2544: else if (strcmp(fonctions[i], "DER") == 0) 2545: { 2546: // Ajout de la variable de dérivation 2547: 2548: if (((*l_element_courant).donnee = allocation( 2549: s_etat_processus, NOM)) == NULL) 2550: { 2551: (*s_expression) = s_expression_courante; 2552: (*s_etat_processus).erreur_systeme = 2553: d_es_allocation_memoire; 2554: return; 2555: } 2556: 2557: if (((*((struct_nom *) (*(*l_element_courant) 2558: .donnee).objet)).nom = 2559: malloc((strlen(variable) + 1) 2560: * sizeof(unsigned char))) == NULL) 2561: { 2562: (*s_expression) = s_expression_courante; 2563: (*s_etat_processus).erreur_systeme = 2564: d_es_allocation_memoire; 2565: return; 2566: } 2567: 2568: strcpy((*((struct_nom *) (*(*l_element_courant) 2569: .donnee).objet)).nom, variable); 2570: (*((struct_nom *) (*(*l_element_courant).donnee) 2571: .objet)).symbole = d_vrai; 2572: 2573: // Ajout de la fonction DER 2574: 2575: if (((*l_element_courant).suivant = malloc( 2576: sizeof(struct_liste_chainee))) == NULL) 2577: { 2578: (*s_expression) = s_expression_courante; 2579: (*s_etat_processus).erreur_systeme = 2580: d_es_allocation_memoire; 2581: return; 2582: } 2583: 2584: l_element_courant = (*l_element_courant).suivant; 2585: 2586: if (((*l_element_courant).donnee = 2587: allocation(s_etat_processus, FCT)) 2588: == NULL) 2589: { 2590: (*s_expression) = s_expression_courante; 2591: (*s_etat_processus).erreur_systeme = 2592: d_es_allocation_memoire; 2593: return; 2594: } 2595: 2596: if (((*((struct_fonction *) (*(*l_element_courant) 2597: .donnee).objet)).nom_fonction = malloc(4 * 2598: sizeof(unsigned char))) == NULL) 2599: { 2600: (*s_expression) = s_expression_courante; 2601: (*s_etat_processus).erreur_systeme = 2602: d_es_allocation_memoire; 2603: return; 2604: } 2605: 2606: strcpy((*((struct_fonction *) 2607: (*(*l_element_courant).donnee) 2608: .objet)).nom_fonction, "DER"); 2609: (*((struct_fonction *) (*(*l_element_courant) 2610: .donnee).objet)).nombre_arguments = 2; 2611: (*((struct_fonction *) (*(*l_element_courant) 2612: .donnee).objet)).fonction = 2613: instruction_der; 2614: } 2615: 2616: i += 3; 2617: } while(fonctions[i] != NULL); 2618: 2619: // Ajout de la fonction '*' 2620: 2621: (*l_element_courant).suivant = (*l_element_suivant).suivant; 2622: 2623: liberation(s_etat_processus, (*l_element_suivant).donnee); 2624: free(l_element_suivant); 2625: 2626: l_element_courant = (*l_element_courant).suivant; 2627: 2628: free((*((struct_fonction *) (*(*l_element_courant).donnee) 2629: .objet)).nom_fonction); 2630: 2631: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 2632: .objet)).nom_fonction = malloc(2 * 2633: sizeof(unsigned char))) == NULL) 2634: { 2635: (*s_expression) = s_expression_courante; 2636: (*s_etat_processus).erreur_systeme = 2637: d_es_allocation_memoire; 2638: return; 2639: } 2640: 2641: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 2642: .objet)).nom_fonction, "*"); 2643: (*((struct_fonction *) (*(*l_element_courant).donnee) 2644: .objet)).nombre_arguments = 0; 2645: (*((struct_fonction *) (*(*l_element_courant).donnee) 2646: .objet)).fonction = instruction_multiplication; 2647: } 2648: } 2649: } 2650: 2651: (*s_etat_processus).traitement_symbolique = 'Y'; 2652: 2653: if (evaluation(s_etat_processus, s_expression_courante, 'E') 2654: == d_erreur) 2655: { 2656: (*s_expression) = s_expression_courante; 2657: (*s_etat_processus).traitement_symbolique = 'N'; 2658: return; 2659: } 2660: 2661: (*s_etat_processus).traitement_symbolique = 'N'; 2662: liberation(s_etat_processus, s_expression_courante); 2663: 2664: if ((*s_etat_processus).var_volatile_requete_arret == 0) 2665: { 2666: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2667: &s_expression_courante) == d_erreur) 2668: { 2669: (*s_expression) = NULL; 2670: (*s_etat_processus).erreur_systeme = 2671: d_es_pile_operationnelle_vide; 2672: return; 2673: } 2674: 2675: /* 2676: * Arrêt lorsqu'il n'y a plus de fonction 'DER' dans l'expression 2677: * courante. 2678: */ 2679: 2680: if (((*s_expression_courante).type == ALG) || 2681: ((*s_expression_courante).type == RPN)) 2682: { 2683: l_element_courant = (struct_liste_chainee *) 2684: (*s_expression_courante).objet; 2685: drapeau = d_faux; 2686: 2687: while((l_element_courant != NULL) && (drapeau == d_faux)) 2688: { 2689: if ((*(*l_element_courant).donnee).type == FCT) 2690: { 2691: if (strcmp((*((struct_fonction *) 2692: (*(*l_element_courant).donnee) 2693: .objet)).nom_fonction, "DER") == 0) 2694: { 2695: drapeau = d_vrai; 2696: } 2697: } 2698: 2699: l_element_courant = (*l_element_courant).suivant; 2700: } 2701: } 2702: else 2703: { 2704: drapeau = d_faux; 2705: } 2706: } 2707: else 2708: { 2709: s_expression_courante = NULL; 2710: } 2711: } while((drapeau == d_vrai) && ((*s_etat_processus) 2712: .var_volatile_requete_arret == 0)); 2713: 2714: (*s_expression) = s_expression_courante; 2715: 2716: return; 2717: } 2718: 2719: // vim: ts=4