Annotation of rpl/src/calcul_differentiel.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: 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
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to calcul_differentiel.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src