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