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