![]() ![]() | ![]() |
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 'list->' 29: ================================================================================ 30: Entrées : structure processus 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_list_fleche(struct_processus *s_etat_processus) 40: { 41: struct_liste_chainee *l_element_courant; 42: struct_liste_chainee *l_element_precedent; 43: 44: struct_objet *s_copie_objet; 45: struct_objet *s_objet; 46: 47: unsigned long nombre_elements; 48: 49: (*s_etat_processus).erreur_execution = d_ex; 50: 51: if ((*s_etat_processus).affichage_arguments == 'Y') 52: { 53: printf("\n LIST-> "); 54: 55: if ((*s_etat_processus).langue == 'F') 56: { 57: printf("(expansion d'une liste)\n\n"); 58: } 59: else 60: { 61: printf("(expand list)\n\n"); 62: } 63: 64: printf(" 1: %s\n", d_LST); 65: printf("-> n: %s, %s, %s, %s, %s, %s,\n" 66: " %s, %s, %s, %s, %s,\n" 67: " %s, %s, %s, %s, %s,\n" 68: " %s, %s\n", 69: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 70: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB); 71: printf(" ...\n"); 72: printf(" 2: %s, %s, %s, %s, %s, %s,\n" 73: " %s, %s, %s, %s, %s,\n" 74: " %s, %s, %s, %s, %s,\n" 75: " %s, %s\n", 76: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 77: d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB); 78: printf(" 1: %s\n", d_INT); 79: 80: return; 81: } 82: else if ((*s_etat_processus).test_instruction == 'Y') 83: { 84: (*s_etat_processus).nombre_arguments = -1; 85: return; 86: } 87: 88: if (test_cfsf(s_etat_processus, 31) == d_vrai) 89: { 90: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 91: { 92: return; 93: } 94: } 95: 96: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 97: &s_objet) == d_erreur) 98: { 99: return; 100: } 101: 102: if ((*s_objet).type != LST) 103: { 104: liberation(s_etat_processus, s_objet); 105: 106: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 107: return; 108: } 109: 110: if ((s_copie_objet = copie_objet(s_etat_processus, s_objet, 'N')) == NULL) 111: { 112: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 113: return; 114: } 115: 116: liberation(s_etat_processus, s_objet); 117: s_objet = s_copie_objet; 118: 119: l_element_courant = (struct_liste_chainee *) ((*s_objet).objet); 120: nombre_elements = 0; 121: 122: while(l_element_courant != NULL) 123: { 124: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 125: (*l_element_courant).donnee) == d_erreur) 126: { 127: return; 128: } 129: 130: l_element_precedent = l_element_courant; 131: l_element_courant = (*l_element_courant).suivant; 132: 133: free(l_element_precedent); 134: 135: nombre_elements++; 136: } 137: 138: free(s_objet); 139: 140: if ((s_objet = allocation(s_etat_processus, INT)) == NULL) 141: { 142: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 143: return; 144: } 145: 146: (*((integer8 *) ((*s_objet).objet))) = (integer8) nombre_elements; 147: 148: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 149: s_objet) == d_erreur) 150: { 151: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 152: return; 153: } 154: 155: return; 156: } 157: 158: 159: /* 160: ================================================================================ 161: Fonction '<=' 162: ================================================================================ 163: Entrées : 164: -------------------------------------------------------------------------------- 165: Sorties : 166: -------------------------------------------------------------------------------- 167: Effets de bord : néant 168: ================================================================================ 169: */ 170: 171: void 172: instruction_le(struct_processus *s_etat_processus) 173: { 174: struct_liste_chainee *l_element_courant; 175: struct_liste_chainee *l_element_precedent; 176: 177: struct_objet *s_copie_argument_1; 178: struct_objet *s_copie_argument_2; 179: struct_objet *s_objet_argument_1; 180: struct_objet *s_objet_argument_2; 181: struct_objet *s_objet_resultat; 182: 183: unsigned long nombre_elements; 184: 185: (*s_etat_processus).erreur_execution = d_ex; 186: 187: if ((*s_etat_processus).affichage_arguments == 'Y') 188: { 189: printf("\n <= "); 190: 191: if ((*s_etat_processus).langue == 'F') 192: { 193: printf("(opérateur inférieur ou égal)\n\n"); 194: } 195: else 196: { 197: printf("(less or equal)\n\n"); 198: } 199: 200: printf(" 2: %s, %s\n", d_INT, d_REL); 201: printf(" 1: %s, %s\n", d_INT, d_REL); 202: printf("-> 1: %s\n\n", d_INT); 203: 204: printf(" 2: %s\n", d_BIN); 205: printf(" 1: %s\n", d_BIN); 206: printf("-> 1: %s\n\n", d_INT); 207: 208: printf(" 2: %s\n", d_CHN); 209: printf(" 1: %s\n", d_CHN); 210: printf("-> 1: %s\n\n", d_INT); 211: 212: printf(" 2: %s\n", d_NOM); 213: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL); 214: printf("-> 1: %s\n\n", d_ALG); 215: 216: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL); 217: printf(" 1: %s\n", d_NOM); 218: printf("-> 1: %s\n\n", d_ALG); 219: 220: printf(" 2: %s\n", d_ALG); 221: printf(" 1: %s\n", d_ALG); 222: printf("-> 1: %s\n\n", d_ALG); 223: 224: printf(" 2: %s\n", d_RPN); 225: printf(" 1: %s\n", d_RPN); 226: printf("-> 1: %s\n", d_RPN); 227: 228: return; 229: } 230: else if ((*s_etat_processus).test_instruction == 'Y') 231: { 232: (*s_etat_processus).nombre_arguments = 0; 233: return; 234: } 235: 236: if (test_cfsf(s_etat_processus, 31) == d_vrai) 237: { 238: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 239: { 240: return; 241: } 242: } 243: 244: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 245: &s_objet_argument_1) == d_erreur) 246: { 247: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 248: return; 249: } 250: 251: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 252: &s_objet_argument_2) == d_erreur) 253: { 254: liberation(s_etat_processus, s_objet_argument_1); 255: 256: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 257: return; 258: } 259: 260: /* 261: -------------------------------------------------------------------------------- 262: LE sur des valeurs numériques 263: -------------------------------------------------------------------------------- 264: */ 265: 266: if ((((*s_objet_argument_1).type == INT) || 267: ((*s_objet_argument_1).type == REL)) && 268: (((*s_objet_argument_2).type == INT) || 269: ((*s_objet_argument_2).type == REL))) 270: { 271: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 272: { 273: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 274: return; 275: } 276: 277: if ((*s_objet_argument_1).type == INT) 278: { 279: if ((*s_objet_argument_2).type == INT) 280: { 281: (*((integer8 *) (*s_objet_resultat).objet)) = 282: ((*((integer8 *) (*s_objet_argument_1).objet)) >= 283: (*((integer8 *) (*s_objet_argument_2).objet))) 284: ? -1 : 0; 285: } 286: else 287: { 288: (*((integer8 *) (*s_objet_resultat).objet)) = 289: ((*((integer8 *) (*s_objet_argument_1).objet)) >= 290: (*((real8 *) (*s_objet_argument_2).objet))) 291: ? -1 : 0; 292: } 293: } 294: else 295: { 296: if ((*s_objet_argument_2).type == INT) 297: { 298: (*((integer8 *) (*s_objet_resultat).objet)) = 299: ((*((real8 *) (*s_objet_argument_1).objet)) >= 300: (*((integer8 *) (*s_objet_argument_2).objet))) 301: ? -1 : 0; 302: } 303: else 304: { 305: (*((integer8 *) (*s_objet_resultat).objet)) = 306: ((*((real8 *) (*s_objet_argument_1).objet)) >= 307: (*((real8 *) (*s_objet_argument_2).objet))) 308: ? -1 : 0; 309: } 310: } 311: } 312: 313: /* 314: -------------------------------------------------------------------------------- 315: LE binaire 316: -------------------------------------------------------------------------------- 317: */ 318: 319: else if (((*s_objet_argument_1).type == BIN) && 320: ((*s_objet_argument_2).type == BIN)) 321: { 322: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 323: { 324: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 325: return; 326: } 327: 328: (*((integer8 *) (*s_objet_resultat).objet)) = 329: ((*((logical8 *) (*s_objet_argument_1).objet)) >= 330: (*((logical8 *) (*s_objet_argument_2).objet))) 331: ? -1 : 0; 332: } 333: 334: /* 335: -------------------------------------------------------------------------------- 336: LE portant sur des chaînes de caractères 337: -------------------------------------------------------------------------------- 338: */ 339: 340: else if (((*s_objet_argument_1).type == CHN) && 341: ((*s_objet_argument_2).type == CHN)) 342: { 343: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 344: { 345: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 346: return; 347: } 348: 349: (*((integer8 *) (*s_objet_resultat).objet)) = 350: (strcmp((unsigned char *) (*s_objet_argument_1).objet, 351: (unsigned char *) (*s_objet_argument_2).objet) >= 0) ? -1 : 0; 352: } 353: 354: /* 355: -------------------------------------------------------------------------------- 356: LE entre des arguments complexes 357: -------------------------------------------------------------------------------- 358: */ 359: 360: /* 361: * Nom ou valeur numérique / Nom ou valeur numérique 362: */ 363: 364: else if ((((*s_objet_argument_1).type == NOM) && 365: (((*s_objet_argument_2).type == NOM) || 366: ((*s_objet_argument_2).type == INT) || 367: ((*s_objet_argument_2).type == REL))) || 368: (((*s_objet_argument_2).type == NOM) && 369: (((*s_objet_argument_1).type == INT) || 370: ((*s_objet_argument_1).type == REL)))) 371: { 372: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL) 373: { 374: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 375: return; 376: } 377: 378: if (((*s_objet_resultat).objet = 379: allocation_maillon(s_etat_processus)) == NULL) 380: { 381: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 382: return; 383: } 384: 385: l_element_courant = (*s_objet_resultat).objet; 386: 387: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 388: == NULL) 389: { 390: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 391: return; 392: } 393: 394: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 395: .nombre_arguments = 0; 396: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 397: .fonction = instruction_vers_niveau_superieur; 398: 399: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 400: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 401: { 402: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 403: return; 404: } 405: 406: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 407: .nom_fonction, "<<"); 408: 409: if (((*l_element_courant).suivant = 410: allocation_maillon(s_etat_processus)) == NULL) 411: { 412: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 413: return; 414: } 415: 416: l_element_courant = (*l_element_courant).suivant; 417: (*l_element_courant).donnee = s_objet_argument_2; 418: 419: if (((*l_element_courant).suivant = 420: allocation_maillon(s_etat_processus)) == NULL) 421: { 422: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 423: return; 424: } 425: 426: l_element_courant = (*l_element_courant).suivant; 427: (*l_element_courant).donnee = s_objet_argument_1; 428: 429: if (((*l_element_courant).suivant = 430: allocation_maillon(s_etat_processus)) == NULL) 431: { 432: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 433: return; 434: } 435: 436: l_element_courant = (*l_element_courant).suivant; 437: 438: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 439: == NULL) 440: { 441: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 442: return; 443: } 444: 445: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 446: .nombre_arguments = 0; 447: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 448: .fonction = instruction_le; 449: 450: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 451: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 452: { 453: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 454: return; 455: } 456: 457: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 458: .nom_fonction, "<="); 459: 460: if (((*l_element_courant).suivant = 461: allocation_maillon(s_etat_processus)) == NULL) 462: { 463: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 464: return; 465: } 466: 467: l_element_courant = (*l_element_courant).suivant; 468: 469: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 470: == NULL) 471: { 472: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 473: return; 474: } 475: 476: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 477: .nombre_arguments = 0; 478: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 479: .fonction = instruction_vers_niveau_inferieur; 480: 481: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 482: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 483: { 484: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 485: return; 486: } 487: 488: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 489: .nom_fonction, ">>"); 490: 491: (*l_element_courant).suivant = NULL; 492: 493: s_objet_argument_1 = NULL; 494: s_objet_argument_2 = NULL; 495: } 496: 497: /* 498: * Nom ou valeur numérique / Expression 499: */ 500: 501: else if (((((*s_objet_argument_1).type == ALG) || 502: ((*s_objet_argument_1).type == RPN))) && 503: (((*s_objet_argument_2).type == NOM) || 504: ((*s_objet_argument_2).type == INT) || 505: ((*s_objet_argument_2).type == REL))) 506: { 507: nombre_elements = 0; 508: l_element_courant = (struct_liste_chainee *) 509: (*s_objet_argument_1).objet; 510: 511: while(l_element_courant != NULL) 512: { 513: nombre_elements++; 514: l_element_courant = (*l_element_courant).suivant; 515: } 516: 517: if (nombre_elements == 2) 518: { 519: liberation(s_etat_processus, s_objet_argument_1); 520: liberation(s_etat_processus, s_objet_argument_2); 521: 522: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 523: return; 524: } 525: 526: if ((s_objet_resultat = copie_objet(s_etat_processus, 527: s_objet_argument_1, 'N')) == NULL) 528: { 529: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 530: return; 531: } 532: 533: l_element_courant = (struct_liste_chainee *) 534: (*s_objet_resultat).objet; 535: l_element_precedent = l_element_courant; 536: l_element_courant = (*l_element_courant).suivant; 537: 538: if (((*l_element_precedent).suivant = 539: allocation_maillon(s_etat_processus)) == NULL) 540: { 541: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 542: return; 543: } 544: 545: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2; 546: (*(*l_element_precedent).suivant).suivant = l_element_courant; 547: 548: while((*l_element_courant).suivant != NULL) 549: { 550: l_element_precedent = l_element_courant; 551: l_element_courant = (*l_element_courant).suivant; 552: } 553: 554: if (((*l_element_precedent).suivant = 555: allocation_maillon(s_etat_processus)) == NULL) 556: { 557: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 558: return; 559: } 560: 561: if (((*(*l_element_precedent).suivant).donnee = 562: allocation(s_etat_processus, FCT)) == NULL) 563: { 564: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 565: return; 566: } 567: 568: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 569: .donnee).objet)).nombre_arguments = 0; 570: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 571: .donnee).objet)).fonction = instruction_le; 572: 573: if (((*((struct_fonction *) (*(*(*l_element_precedent) 574: .suivant).donnee).objet)).nom_fonction = 575: malloc(3 * sizeof(unsigned char))) == NULL) 576: { 577: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 578: return; 579: } 580: 581: strcpy((*((struct_fonction *) (*(*(*l_element_precedent) 582: .suivant).donnee).objet)).nom_fonction, "<="); 583: 584: (*(*l_element_precedent).suivant).suivant = l_element_courant; 585: 586: s_objet_argument_2 = NULL; 587: } 588: 589: /* 590: * Expression / Nom ou valeur numérique 591: */ 592: 593: else if ((((*s_objet_argument_1).type == NOM) || 594: ((*s_objet_argument_1).type == INT) || 595: ((*s_objet_argument_1).type == REL)) && 596: ((((*s_objet_argument_2).type == ALG) || 597: ((*s_objet_argument_2).type == RPN)))) 598: { 599: nombre_elements = 0; 600: l_element_courant = (struct_liste_chainee *) 601: (*s_objet_argument_2).objet; 602: 603: while(l_element_courant != NULL) 604: { 605: nombre_elements++; 606: l_element_courant = (*l_element_courant).suivant; 607: } 608: 609: if (nombre_elements == 2) 610: { 611: liberation(s_etat_processus, s_objet_argument_1); 612: liberation(s_etat_processus, s_objet_argument_2); 613: 614: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 615: return; 616: } 617: 618: if ((s_objet_resultat = copie_objet(s_etat_processus, 619: s_objet_argument_2, 'N')) == NULL) 620: { 621: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 622: return; 623: } 624: 625: l_element_courant = (struct_liste_chainee *) 626: (*s_objet_resultat).objet; 627: l_element_precedent = l_element_courant; 628: 629: while((*l_element_courant).suivant != NULL) 630: { 631: l_element_precedent = l_element_courant; 632: l_element_courant = (*l_element_courant).suivant; 633: } 634: 635: if (((*l_element_precedent).suivant = 636: allocation_maillon(s_etat_processus)) == NULL) 637: { 638: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 639: return; 640: } 641: 642: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1; 643: l_element_precedent = (*l_element_precedent).suivant; 644: 645: if (((*l_element_precedent).suivant = 646: allocation_maillon(s_etat_processus)) == NULL) 647: { 648: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 649: return; 650: } 651: 652: if (((*(*l_element_precedent).suivant).donnee = 653: allocation(s_etat_processus, FCT)) == NULL) 654: { 655: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 656: return; 657: } 658: 659: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 660: .donnee).objet)).nombre_arguments = 0; 661: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 662: .donnee).objet)).fonction = instruction_le; 663: 664: if (((*((struct_fonction *) (*(*(*l_element_precedent) 665: .suivant).donnee).objet)).nom_fonction = 666: malloc(3 * sizeof(unsigned char))) == NULL) 667: { 668: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 669: return; 670: } 671: 672: strcpy((*((struct_fonction *) (*(*(*l_element_precedent) 673: .suivant).donnee).objet)).nom_fonction, "<="); 674: 675: (*(*l_element_precedent).suivant).suivant = l_element_courant; 676: 677: s_objet_argument_1 = NULL; 678: } 679: 680: /* 681: * Expression / Expression 682: */ 683: 684: else if ((((*s_objet_argument_1).type == ALG) && 685: ((*s_objet_argument_2).type == ALG)) || 686: (((*s_objet_argument_1).type == RPN) && 687: ((*s_objet_argument_2).type == RPN))) 688: { 689: nombre_elements = 0; 690: l_element_courant = (struct_liste_chainee *) 691: (*s_objet_argument_1).objet; 692: 693: while(l_element_courant != NULL) 694: { 695: nombre_elements++; 696: l_element_courant = (*l_element_courant).suivant; 697: } 698: 699: if (nombre_elements == 2) 700: { 701: liberation(s_etat_processus, s_objet_argument_1); 702: liberation(s_etat_processus, s_objet_argument_2); 703: 704: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 705: return; 706: } 707: 708: nombre_elements = 0; 709: l_element_courant = (struct_liste_chainee *) 710: (*s_objet_argument_2).objet; 711: 712: while(l_element_courant != NULL) 713: { 714: nombre_elements++; 715: l_element_courant = (*l_element_courant).suivant; 716: } 717: 718: if (nombre_elements == 2) 719: { 720: liberation(s_etat_processus, s_objet_argument_1); 721: liberation(s_etat_processus, s_objet_argument_2); 722: 723: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 724: return; 725: } 726: 727: if ((s_copie_argument_1 = copie_objet(s_etat_processus, 728: s_objet_argument_1, 'N')) == NULL) 729: { 730: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 731: return; 732: } 733: 734: if ((s_copie_argument_2 = copie_objet(s_etat_processus, 735: s_objet_argument_2, 'N')) == NULL) 736: { 737: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 738: return; 739: } 740: 741: l_element_courant = (struct_liste_chainee *) 742: (*s_copie_argument_1).objet; 743: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *) 744: (*s_copie_argument_1).objet)).suivant; 745: 746: liberation(s_etat_processus, (*l_element_courant).donnee); 747: free(l_element_courant); 748: 749: l_element_courant = (struct_liste_chainee *) 750: (*s_copie_argument_2).objet; 751: l_element_precedent = l_element_courant; 752: s_objet_resultat = s_copie_argument_2; 753: 754: while((*l_element_courant).suivant != NULL) 755: { 756: l_element_precedent = l_element_courant; 757: l_element_courant = (*l_element_courant).suivant; 758: } 759: 760: liberation(s_etat_processus, (*l_element_courant).donnee); 761: free(l_element_courant); 762: 763: (*l_element_precedent).suivant = (struct_liste_chainee *) 764: (*s_copie_argument_1).objet; 765: free(s_copie_argument_1); 766: 767: l_element_courant = (*l_element_precedent).suivant; 768: while((*l_element_courant).suivant != NULL) 769: { 770: l_element_precedent = l_element_courant; 771: l_element_courant = (*l_element_courant).suivant; 772: } 773: 774: if (((*l_element_precedent).suivant = 775: allocation_maillon(s_etat_processus)) == NULL) 776: { 777: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 778: return; 779: } 780: 781: (*(*l_element_precedent).suivant).suivant = l_element_courant; 782: l_element_courant = (*l_element_precedent).suivant; 783: 784: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 785: == NULL) 786: { 787: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 788: return; 789: } 790: 791: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 792: .nombre_arguments = 0; 793: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 794: .fonction = instruction_le; 795: 796: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 797: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 798: { 799: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 800: return; 801: } 802: 803: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 804: .nom_fonction, "<="); 805: } 806: 807: /* 808: -------------------------------------------------------------------------------- 809: LE impossible 810: -------------------------------------------------------------------------------- 811: */ 812: 813: else 814: { 815: liberation(s_etat_processus, s_objet_argument_1); 816: liberation(s_etat_processus, s_objet_argument_2); 817: 818: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 819: return; 820: } 821: 822: liberation(s_etat_processus, s_objet_argument_1); 823: liberation(s_etat_processus, s_objet_argument_2); 824: 825: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 826: s_objet_resultat) == d_erreur) 827: { 828: return; 829: } 830: 831: return; 832: } 833: 834: 835: /* 836: ================================================================================ 837: Fonction '<' 838: ================================================================================ 839: Entrées : 840: -------------------------------------------------------------------------------- 841: Sorties : 842: -------------------------------------------------------------------------------- 843: Effets de bord : néant 844: ================================================================================ 845: */ 846: 847: void 848: instruction_lt(struct_processus *s_etat_processus) 849: { 850: struct_liste_chainee *l_element_courant; 851: struct_liste_chainee *l_element_precedent; 852: 853: struct_objet *s_copie_argument_1; 854: struct_objet *s_copie_argument_2; 855: struct_objet *s_objet_argument_1; 856: struct_objet *s_objet_argument_2; 857: struct_objet *s_objet_resultat; 858: 859: unsigned long nombre_elements; 860: 861: (*s_etat_processus).erreur_execution = d_ex; 862: 863: if ((*s_etat_processus).affichage_arguments == 'Y') 864: { 865: printf("\n < "); 866: 867: if ((*s_etat_processus).langue == 'F') 868: { 869: printf("(opérateur inférieur strictement)\n\n"); 870: } 871: else 872: { 873: printf("(less than)\n\n"); 874: } 875: 876: printf(" 2: %s, %s\n", d_INT, d_REL); 877: printf(" 1: %s, %s\n", d_INT, d_REL); 878: printf("-> 1: %s\n\n", d_INT); 879: 880: printf(" 2: %s\n", d_BIN); 881: printf(" 1: %s\n", d_BIN); 882: printf("-> 1: %s\n\n", d_INT); 883: 884: printf(" 2: %s\n", d_CHN); 885: printf(" 1: %s\n", d_CHN); 886: printf("-> 1: %s\n\n", d_INT); 887: 888: printf(" 2: %s\n", d_NOM); 889: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL); 890: printf("-> 1: %s\n\n", d_ALG); 891: 892: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL); 893: printf(" 1: %s\n", d_NOM); 894: printf("-> 1: %s\n\n", d_ALG); 895: 896: printf(" 2: %s\n", d_ALG); 897: printf(" 1: %s\n", d_ALG); 898: printf("-> 1: %s\n\n", d_ALG); 899: 900: printf(" 2: %s\n", d_RPN); 901: printf(" 1: %s\n", d_RPN); 902: printf("-> 1: %s\n", d_RPN); 903: 904: return; 905: } 906: else if ((*s_etat_processus).test_instruction == 'Y') 907: { 908: (*s_etat_processus).nombre_arguments = 0; 909: return; 910: } 911: 912: if (test_cfsf(s_etat_processus, 31) == d_vrai) 913: { 914: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 915: { 916: return; 917: } 918: } 919: 920: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 921: &s_objet_argument_1) == d_erreur) 922: { 923: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 924: return; 925: } 926: 927: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 928: &s_objet_argument_2) == d_erreur) 929: { 930: liberation(s_etat_processus, s_objet_argument_1); 931: 932: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 933: return; 934: } 935: 936: /* 937: -------------------------------------------------------------------------------- 938: LT sur des valeurs numériques 939: -------------------------------------------------------------------------------- 940: */ 941: 942: if ((((*s_objet_argument_1).type == INT) || 943: ((*s_objet_argument_1).type == REL)) && 944: (((*s_objet_argument_2).type == INT) || 945: ((*s_objet_argument_2).type == REL))) 946: { 947: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 948: { 949: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 950: return; 951: } 952: 953: if ((*s_objet_argument_1).type == INT) 954: { 955: if ((*s_objet_argument_2).type == INT) 956: { 957: (*((integer8 *) (*s_objet_resultat).objet)) = 958: ((*((integer8 *) (*s_objet_argument_1).objet)) > 959: (*((integer8 *) (*s_objet_argument_2).objet))) 960: ? -1 : 0; 961: } 962: else 963: { 964: (*((integer8 *) (*s_objet_resultat).objet)) = 965: ((*((integer8 *) (*s_objet_argument_1).objet)) > 966: (*((real8 *) (*s_objet_argument_2).objet))) 967: ? -1 : 0; 968: } 969: } 970: else 971: { 972: if ((*s_objet_argument_2).type == INT) 973: { 974: (*((integer8 *) (*s_objet_resultat).objet)) = 975: ((*((real8 *) (*s_objet_argument_1).objet)) > 976: (*((integer8 *) (*s_objet_argument_2).objet))) 977: ? -1 : 0; 978: } 979: else 980: { 981: (*((integer8 *) (*s_objet_resultat).objet)) = 982: ((*((real8 *) (*s_objet_argument_1).objet)) > 983: (*((real8 *) (*s_objet_argument_2).objet))) 984: ? -1 : 0; 985: } 986: } 987: } 988: 989: /* 990: -------------------------------------------------------------------------------- 991: LT binaire 992: -------------------------------------------------------------------------------- 993: */ 994: 995: else if (((*s_objet_argument_1).type == BIN) && 996: ((*s_objet_argument_2).type == BIN)) 997: { 998: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 999: { 1000: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1001: return; 1002: } 1003: 1004: (*((integer8 *) (*s_objet_resultat).objet)) = 1005: ((*((logical8 *) (*s_objet_argument_1).objet)) > 1006: (*((logical8 *) (*s_objet_argument_2).objet))) 1007: ? -1 : 0; 1008: } 1009: 1010: /* 1011: -------------------------------------------------------------------------------- 1012: LT portant sur des chaînes de caractères 1013: -------------------------------------------------------------------------------- 1014: */ 1015: 1016: else if (((*s_objet_argument_1).type == CHN) && 1017: ((*s_objet_argument_2).type == CHN)) 1018: { 1019: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 1020: { 1021: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1022: return; 1023: } 1024: 1025: (*((integer8 *) (*s_objet_resultat).objet)) = 1026: (strcmp((unsigned char *) (*s_objet_argument_1).objet, 1027: (unsigned char *) (*s_objet_argument_2).objet) > 0) ? -1 : 0; 1028: } 1029: 1030: /* 1031: -------------------------------------------------------------------------------- 1032: LT entre des arguments complexes 1033: -------------------------------------------------------------------------------- 1034: */ 1035: 1036: /* 1037: * Nom ou valeur numérique / Nom ou valeur numérique 1038: */ 1039: 1040: else if ((((*s_objet_argument_1).type == NOM) && 1041: (((*s_objet_argument_2).type == NOM) || 1042: ((*s_objet_argument_2).type == INT) || 1043: ((*s_objet_argument_2).type == REL))) || 1044: (((*s_objet_argument_2).type == NOM) && 1045: (((*s_objet_argument_1).type == INT) || 1046: ((*s_objet_argument_1).type == REL)))) 1047: { 1048: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL) 1049: { 1050: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1051: return; 1052: } 1053: 1054: if (((*s_objet_resultat).objet = 1055: allocation_maillon(s_etat_processus)) == NULL) 1056: { 1057: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1058: return; 1059: } 1060: 1061: l_element_courant = (*s_objet_resultat).objet; 1062: 1063: if (((*l_element_courant).donnee = 1064: allocation(s_etat_processus, FCT)) == NULL) 1065: { 1066: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1067: return; 1068: } 1069: 1070: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1071: .nombre_arguments = 0; 1072: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1073: .fonction = instruction_vers_niveau_superieur; 1074: 1075: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1076: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 1077: { 1078: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1079: return; 1080: } 1081: 1082: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1083: .nom_fonction, "<<"); 1084: 1085: if (((*l_element_courant).suivant = 1086: allocation_maillon(s_etat_processus)) == NULL) 1087: { 1088: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1089: return; 1090: } 1091: 1092: l_element_courant = (*l_element_courant).suivant; 1093: (*l_element_courant).donnee = s_objet_argument_2; 1094: 1095: if (((*l_element_courant).suivant = 1096: allocation_maillon(s_etat_processus)) == NULL) 1097: { 1098: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1099: return; 1100: } 1101: 1102: l_element_courant = (*l_element_courant).suivant; 1103: (*l_element_courant).donnee = s_objet_argument_1; 1104: 1105: if (((*l_element_courant).suivant = 1106: allocation_maillon(s_etat_processus)) == NULL) 1107: { 1108: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1109: return; 1110: } 1111: 1112: l_element_courant = (*l_element_courant).suivant; 1113: 1114: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1115: == NULL) 1116: { 1117: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1118: return; 1119: } 1120: 1121: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1122: .nombre_arguments = 0; 1123: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1124: .fonction = instruction_lt; 1125: 1126: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1127: .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) 1128: { 1129: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1130: return; 1131: } 1132: 1133: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1134: .nom_fonction, "<"); 1135: 1136: if (((*l_element_courant).suivant = 1137: allocation_maillon(s_etat_processus)) == NULL) 1138: { 1139: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1140: return; 1141: } 1142: 1143: l_element_courant = (*l_element_courant).suivant; 1144: 1145: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1146: == NULL) 1147: { 1148: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1149: return; 1150: } 1151: 1152: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1153: .nombre_arguments = 0; 1154: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1155: .fonction = instruction_vers_niveau_inferieur; 1156: 1157: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1158: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 1159: { 1160: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1161: return; 1162: } 1163: 1164: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1165: .nom_fonction, ">>"); 1166: 1167: (*l_element_courant).suivant = NULL; 1168: 1169: s_objet_argument_1 = NULL; 1170: s_objet_argument_2 = NULL; 1171: } 1172: 1173: /* 1174: * Nom ou valeur numérique / Expression 1175: */ 1176: 1177: else if (((((*s_objet_argument_1).type == ALG) || 1178: ((*s_objet_argument_1).type == RPN))) && 1179: (((*s_objet_argument_2).type == NOM) || 1180: ((*s_objet_argument_2).type == INT) || 1181: ((*s_objet_argument_2).type == REL))) 1182: { 1183: nombre_elements = 0; 1184: l_element_courant = (struct_liste_chainee *) 1185: (*s_objet_argument_1).objet; 1186: 1187: while(l_element_courant != NULL) 1188: { 1189: nombre_elements++; 1190: l_element_courant = (*l_element_courant).suivant; 1191: } 1192: 1193: if (nombre_elements == 2) 1194: { 1195: liberation(s_etat_processus, s_objet_argument_1); 1196: liberation(s_etat_processus, s_objet_argument_2); 1197: 1198: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1199: return; 1200: } 1201: 1202: if ((s_objet_resultat = copie_objet(s_etat_processus, 1203: s_objet_argument_1, 'N')) == NULL) 1204: { 1205: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1206: return; 1207: } 1208: 1209: l_element_courant = (struct_liste_chainee *) 1210: (*s_objet_resultat).objet; 1211: l_element_precedent = l_element_courant; 1212: l_element_courant = (*l_element_courant).suivant; 1213: 1214: if (((*l_element_precedent).suivant = 1215: allocation_maillon(s_etat_processus)) == NULL) 1216: { 1217: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1218: return; 1219: } 1220: 1221: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2; 1222: (*(*l_element_precedent).suivant).suivant = l_element_courant; 1223: 1224: while((*l_element_courant).suivant != NULL) 1225: { 1226: l_element_precedent = l_element_courant; 1227: l_element_courant = (*l_element_courant).suivant; 1228: } 1229: 1230: if (((*l_element_precedent).suivant = 1231: allocation_maillon(s_etat_processus)) == NULL) 1232: { 1233: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1234: return; 1235: } 1236: 1237: if (((*(*l_element_precedent).suivant).donnee = 1238: allocation(s_etat_processus, FCT)) == NULL) 1239: { 1240: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1241: return; 1242: } 1243: 1244: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1245: .donnee).objet)).nombre_arguments = 0; 1246: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1247: .donnee).objet)).fonction = instruction_lt; 1248: 1249: if (((*((struct_fonction *) (*(*(*l_element_precedent) 1250: .suivant).donnee).objet)).nom_fonction = 1251: malloc(2 * sizeof(unsigned char))) == NULL) 1252: { 1253: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1254: return; 1255: } 1256: 1257: strcpy((*((struct_fonction *) (*(*(*l_element_precedent) 1258: .suivant).donnee).objet)).nom_fonction, "<"); 1259: 1260: (*(*l_element_precedent).suivant).suivant = l_element_courant; 1261: 1262: s_objet_argument_2 = NULL; 1263: } 1264: 1265: /* 1266: * Expression / Nom ou valeur numérique 1267: */ 1268: 1269: else if ((((*s_objet_argument_1).type == NOM) || 1270: ((*s_objet_argument_1).type == INT) || 1271: ((*s_objet_argument_1).type == REL)) && 1272: ((((*s_objet_argument_2).type == ALG) || 1273: ((*s_objet_argument_2).type == RPN)))) 1274: { 1275: nombre_elements = 0; 1276: l_element_courant = (struct_liste_chainee *) 1277: (*s_objet_argument_2).objet; 1278: 1279: while(l_element_courant != NULL) 1280: { 1281: nombre_elements++; 1282: l_element_courant = (*l_element_courant).suivant; 1283: } 1284: 1285: if (nombre_elements == 2) 1286: { 1287: liberation(s_etat_processus, s_objet_argument_1); 1288: liberation(s_etat_processus, s_objet_argument_2); 1289: 1290: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1291: return; 1292: } 1293: 1294: if ((s_objet_resultat = copie_objet(s_etat_processus, 1295: s_objet_argument_2, 'N')) == NULL) 1296: { 1297: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1298: return; 1299: } 1300: 1301: l_element_courant = (struct_liste_chainee *) 1302: (*s_objet_resultat).objet; 1303: l_element_precedent = l_element_courant; 1304: 1305: while((*l_element_courant).suivant != NULL) 1306: { 1307: l_element_precedent = l_element_courant; 1308: l_element_courant = (*l_element_courant).suivant; 1309: } 1310: 1311: if (((*l_element_precedent).suivant = 1312: allocation_maillon(s_etat_processus)) == NULL) 1313: { 1314: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1315: return; 1316: } 1317: 1318: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1; 1319: l_element_precedent = (*l_element_precedent).suivant; 1320: 1321: if (((*l_element_precedent).suivant = 1322: allocation_maillon(s_etat_processus)) == NULL) 1323: { 1324: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1325: return; 1326: } 1327: 1328: if (((*(*l_element_precedent).suivant).donnee = 1329: allocation(s_etat_processus, FCT)) == NULL) 1330: { 1331: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1332: return; 1333: } 1334: 1335: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1336: .donnee).objet)).nombre_arguments = 0; 1337: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1338: .donnee).objet)).fonction = instruction_lt; 1339: 1340: if (((*((struct_fonction *) (*(*(*l_element_precedent) 1341: .suivant).donnee).objet)).nom_fonction = 1342: malloc(2 * sizeof(unsigned char))) == NULL) 1343: { 1344: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1345: return; 1346: } 1347: 1348: strcpy((*((struct_fonction *) (*(*(*l_element_precedent) 1349: .suivant).donnee).objet)).nom_fonction, "<"); 1350: 1351: (*(*l_element_precedent).suivant).suivant = l_element_courant; 1352: 1353: s_objet_argument_1 = NULL; 1354: } 1355: 1356: /* 1357: * Expression / Expression 1358: */ 1359: 1360: else if ((((*s_objet_argument_1).type == ALG) && 1361: ((*s_objet_argument_2).type == ALG)) || 1362: (((*s_objet_argument_1).type == RPN) && 1363: ((*s_objet_argument_2).type == RPN))) 1364: { 1365: nombre_elements = 0; 1366: l_element_courant = (struct_liste_chainee *) 1367: (*s_objet_argument_1).objet; 1368: 1369: while(l_element_courant != NULL) 1370: { 1371: nombre_elements++; 1372: l_element_courant = (*l_element_courant).suivant; 1373: } 1374: 1375: if (nombre_elements == 2) 1376: { 1377: liberation(s_etat_processus, s_objet_argument_1); 1378: liberation(s_etat_processus, s_objet_argument_2); 1379: 1380: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1381: return; 1382: } 1383: 1384: nombre_elements = 0; 1385: l_element_courant = (struct_liste_chainee *) 1386: (*s_objet_argument_2).objet; 1387: 1388: while(l_element_courant != NULL) 1389: { 1390: nombre_elements++; 1391: l_element_courant = (*l_element_courant).suivant; 1392: } 1393: 1394: if (nombre_elements == 2) 1395: { 1396: liberation(s_etat_processus, s_objet_argument_1); 1397: liberation(s_etat_processus, s_objet_argument_2); 1398: 1399: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1400: return; 1401: } 1402: 1403: if ((s_copie_argument_1 = copie_objet(s_etat_processus, 1404: s_objet_argument_1, 'N')) == NULL) 1405: { 1406: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1407: return; 1408: } 1409: 1410: if ((s_copie_argument_2 = copie_objet(s_etat_processus, 1411: s_objet_argument_2, 'N')) == NULL) 1412: { 1413: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1414: return; 1415: } 1416: 1417: l_element_courant = (struct_liste_chainee *) 1418: (*s_copie_argument_1).objet; 1419: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *) 1420: (*s_copie_argument_1).objet)).suivant; 1421: 1422: liberation(s_etat_processus, (*l_element_courant).donnee); 1423: free(l_element_courant); 1424: 1425: l_element_courant = (struct_liste_chainee *) 1426: (*s_copie_argument_2).objet; 1427: l_element_precedent = l_element_courant; 1428: s_objet_resultat = s_copie_argument_2; 1429: 1430: while((*l_element_courant).suivant != NULL) 1431: { 1432: l_element_precedent = l_element_courant; 1433: l_element_courant = (*l_element_courant).suivant; 1434: } 1435: 1436: liberation(s_etat_processus, (*l_element_courant).donnee); 1437: free(l_element_courant); 1438: 1439: (*l_element_precedent).suivant = (struct_liste_chainee *) 1440: (*s_copie_argument_1).objet; 1441: free(s_copie_argument_1); 1442: 1443: l_element_courant = (*l_element_precedent).suivant; 1444: while((*l_element_courant).suivant != NULL) 1445: { 1446: l_element_precedent = l_element_courant; 1447: l_element_courant = (*l_element_courant).suivant; 1448: } 1449: 1450: if (((*l_element_precedent).suivant = 1451: allocation_maillon(s_etat_processus)) == NULL) 1452: { 1453: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1454: return; 1455: } 1456: 1457: (*(*l_element_precedent).suivant).suivant = l_element_courant; 1458: l_element_courant = (*l_element_precedent).suivant; 1459: 1460: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1461: == NULL) 1462: { 1463: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1464: return; 1465: } 1466: 1467: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1468: .nombre_arguments = 0; 1469: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1470: .fonction = instruction_lt; 1471: 1472: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1473: .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) 1474: { 1475: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1476: return; 1477: } 1478: 1479: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1480: .nom_fonction, "<"); 1481: } 1482: 1483: /* 1484: -------------------------------------------------------------------------------- 1485: LT impossible 1486: -------------------------------------------------------------------------------- 1487: */ 1488: 1489: else 1490: { 1491: liberation(s_etat_processus, s_objet_argument_1); 1492: liberation(s_etat_processus, s_objet_argument_2); 1493: 1494: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1495: return; 1496: } 1497: 1498: liberation(s_etat_processus, s_objet_argument_1); 1499: liberation(s_etat_processus, s_objet_argument_2); 1500: 1501: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1502: s_objet_resultat) == d_erreur) 1503: { 1504: return; 1505: } 1506: 1507: return; 1508: } 1509: 1510: 1511: /* 1512: ================================================================================ 1513: Fonction 'last' 1514: ================================================================================ 1515: Entrées : structure processus 1516: -------------------------------------------------------------------------------- 1517: Sorties : 1518: -------------------------------------------------------------------------------- 1519: Effets de bord : néant 1520: ================================================================================ 1521: */ 1522: 1523: void 1524: instruction_last(struct_processus *s_etat_processus) 1525: { 1526: struct_liste_chainee *l_element_courant; 1527: 1528: struct_objet *s_objet; 1529: 1530: (*s_etat_processus).erreur_execution = d_ex; 1531: 1532: if ((*s_etat_processus).affichage_arguments == 'Y') 1533: { 1534: printf("\n LAST "); 1535: 1536: if ((*s_etat_processus).langue == 'F') 1537: { 1538: printf("(renvoie les arguments de la dernière fonction " 1539: "intrinsèque)\n\n"); 1540: printf(" Aucun argument\n"); 1541: } 1542: else 1543: { 1544: printf("(return arguments of the last intrinsic function)\n\n"); 1545: printf(" No argument\n"); 1546: } 1547: 1548: return; 1549: } 1550: else if ((*s_etat_processus).test_instruction == 'Y') 1551: { 1552: (*s_etat_processus).nombre_arguments = -1; 1553: return; 1554: } 1555: 1556: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1557: { 1558: l_element_courant = (*s_etat_processus).l_base_pile_last; 1559: 1560: while(l_element_courant != NULL) 1561: { 1562: if ((s_objet = copie_objet(s_etat_processus, 1563: (*l_element_courant).donnee, 'P')) == NULL) 1564: { 1565: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1566: return; 1567: } 1568: 1569: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1570: s_objet) == d_erreur) 1571: { 1572: return; 1573: } 1574: 1575: l_element_courant = (*l_element_courant).suivant; 1576: } 1577: } 1578: 1579: return; 1580: } 1581: 1582: // vim: ts=4