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