![]() ![]() | ![]() |
Passage de la branche 4.1 en branche stable.
1: /* 2: ================================================================================ 3: RPL/2 (R) version 4.1.0 4: Copyright (C) 1989-2011 Dr. BERTRAND Joël 5: 6: This file is part of RPL/2. 7: 8: RPL/2 is free software; you can redistribute it and/or modify it 9: under the terms of the CeCILL V2 License as published by the french 10: CEA, CNRS and INRIA. 11: 12: RPL/2 is distributed in the hope that it will be useful, but WITHOUT 13: ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14: FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL V2 License 15: for more details. 16: 17: You should have received a copy of the CeCILL License 18: along with RPL/2. If not, write to info@cecill.info. 19: ================================================================================ 20: */ 21: 22: 23: #include "rpl-conv.h" 24: 25: 26: /* 27: ================================================================================ 28: Fonction '%' 29: ================================================================================ 30: Entrées : 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_pourcent(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("(pourcentage)\n\n"); 61: } 62: else 63: { 64: printf("(percentage)\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_REL); 70: 71: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL); 72: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL); 73: printf("-> 1: %s\n\n", d_ALG); 74: 75: printf(" 2: %s, %s, %s, %s\n", d_RPN, d_NOM, d_INT, d_REL); 76: printf(" 1: %s, %s, %s, %s\n", d_RPN, d_NOM, d_INT, d_REL); 77: printf("-> 1: %s\n", d_RPN); 78: 79: return; 80: } 81: else if ((*s_etat_processus).test_instruction == 'Y') 82: { 83: (*s_etat_processus).nombre_arguments = -1; 84: return; 85: } 86: 87: if (test_cfsf(s_etat_processus, 31) == d_vrai) 88: { 89: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 90: { 91: return; 92: } 93: } 94: 95: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 96: &s_objet_argument_1) == d_erreur) 97: { 98: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 99: return; 100: } 101: 102: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 103: &s_objet_argument_2) == d_erreur) 104: { 105: liberation(s_etat_processus, s_objet_argument_1); 106: 107: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 108: return; 109: } 110: 111: /* 112: -------------------------------------------------------------------------------- 113: % portant sur des valeurs numériques 114: -------------------------------------------------------------------------------- 115: */ 116: 117: if ((((*s_objet_argument_1).type == INT) || 118: ((*s_objet_argument_1).type == REL)) && 119: (((*s_objet_argument_2).type == INT) || 120: ((*s_objet_argument_2).type == REL))) 121: { 122: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 123: == NULL) 124: { 125: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 126: return; 127: } 128: 129: if ((*s_objet_argument_1).type == INT) 130: { 131: if ((*s_objet_argument_2).type == INT) 132: { 133: (*((real8 *) (*s_objet_resultat).objet)) = 134: (((real8) (*((integer8 *) (*s_objet_argument_1) 135: .objet))) * ((real8) (*((integer8 *) 136: (*s_objet_argument_2).objet)))) / 100; 137: } 138: else 139: { 140: (*((real8 *) (*s_objet_resultat).objet)) = 141: (((real8) (*((integer8 *) (*s_objet_argument_1) 142: .objet))) * (*((real8 *) 143: (*s_objet_argument_2).objet))) / 100; 144: } 145: } 146: else 147: { 148: if ((*s_objet_argument_2).type == INT) 149: { 150: (*((real8 *) (*s_objet_resultat).objet)) = 151: ((*((real8 *) (*s_objet_argument_1).objet)) * 152: ((real8) (*((integer8 *) (*s_objet_argument_2) 153: .objet)))) / 100; 154: } 155: else 156: { 157: (*((real8 *) (*s_objet_resultat).objet)) = 158: ((*((real8 *) (*s_objet_argument_1).objet)) * 159: (*((real8 *) (*s_objet_argument_2).objet))) / 100; 160: } 161: } 162: } 163: 164: /* 165: -------------------------------------------------------------------------------- 166: % entre des arguments complexes 167: -------------------------------------------------------------------------------- 168: */ 169: 170: /* 171: * Nom ou valeur numérique / Nom ou valeur numérique 172: */ 173: 174: else if ((((*s_objet_argument_1).type == NOM) && 175: (((*s_objet_argument_2).type == NOM) || 176: ((*s_objet_argument_2).type == INT) || 177: ((*s_objet_argument_2).type == REL))) || 178: (((*s_objet_argument_2).type == NOM) && 179: (((*s_objet_argument_1).type == INT) || 180: ((*s_objet_argument_1).type == REL)))) 181: { 182: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) 183: == NULL) 184: { 185: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 186: return; 187: } 188: 189: if (((*s_objet_resultat).objet = 190: allocation_maillon(s_etat_processus)) == NULL) 191: { 192: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 193: return; 194: } 195: 196: l_element_courant = (*s_objet_resultat).objet; 197: 198: if (((*l_element_courant).donnee = allocation(s_etat_processus, 199: FCT)) == NULL) 200: { 201: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 202: return; 203: } 204: 205: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 206: .nombre_arguments = 0; 207: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 208: .fonction = instruction_vers_niveau_superieur; 209: 210: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 211: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 212: { 213: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 214: return; 215: } 216: 217: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 218: .nom_fonction, "<<"); 219: 220: if (((*l_element_courant).suivant = 221: allocation_maillon(s_etat_processus)) == NULL) 222: { 223: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 224: return; 225: } 226: 227: l_element_courant = (*l_element_courant).suivant; 228: (*l_element_courant).donnee = s_objet_argument_2; 229: 230: if (((*l_element_courant).suivant = 231: allocation_maillon(s_etat_processus)) == NULL) 232: { 233: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 234: return; 235: } 236: 237: l_element_courant = (*l_element_courant).suivant; 238: (*l_element_courant).donnee = s_objet_argument_1; 239: 240: if (((*l_element_courant).suivant = 241: allocation_maillon(s_etat_processus)) == NULL) 242: { 243: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 244: return; 245: } 246: 247: l_element_courant = (*l_element_courant).suivant; 248: 249: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 250: == NULL) 251: { 252: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 253: return; 254: } 255: 256: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 257: .nombre_arguments = 2; 258: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 259: .fonction = instruction_pourcent; 260: 261: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 262: .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) 263: { 264: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 265: return; 266: } 267: 268: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 269: .nom_fonction, "%"); 270: 271: if (((*l_element_courant).suivant = 272: allocation_maillon(s_etat_processus)) == NULL) 273: { 274: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 275: return; 276: } 277: 278: l_element_courant = (*l_element_courant).suivant; 279: 280: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 281: == NULL) 282: { 283: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 284: return; 285: } 286: 287: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 288: .nombre_arguments = 0; 289: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 290: .fonction = instruction_vers_niveau_inferieur; 291: 292: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 293: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 294: { 295: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 296: return; 297: } 298: 299: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 300: .nom_fonction, ">>"); 301: 302: (*l_element_courant).suivant = NULL; 303: 304: s_objet_argument_1 = NULL; 305: s_objet_argument_2 = NULL; 306: } 307: 308: /* 309: * Nom ou valeur numérique / Expression 310: */ 311: 312: else if (((((*s_objet_argument_1).type == ALG) || 313: ((*s_objet_argument_1).type == RPN))) && 314: (((*s_objet_argument_2).type == NOM) || 315: ((*s_objet_argument_2).type == INT) || 316: ((*s_objet_argument_2).type == REL))) 317: { 318: nombre_elements = 0; 319: l_element_courant = (struct_liste_chainee *) 320: (*s_objet_argument_1).objet; 321: 322: while(l_element_courant != NULL) 323: { 324: nombre_elements++; 325: l_element_courant = (*l_element_courant).suivant; 326: } 327: 328: if (nombre_elements == 2) 329: { 330: liberation(s_etat_processus, s_objet_argument_1); 331: liberation(s_etat_processus, s_objet_argument_2); 332: 333: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 334: return; 335: } 336: 337: if ((s_objet_resultat = copie_objet(s_etat_processus, 338: s_objet_argument_1, 'N')) == NULL) 339: { 340: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 341: return; 342: } 343: 344: l_element_courant = (struct_liste_chainee *) 345: (*s_objet_resultat).objet; 346: l_element_precedent = l_element_courant; 347: l_element_courant = (*l_element_courant).suivant; 348: 349: if (((*l_element_precedent).suivant = 350: allocation_maillon(s_etat_processus)) == NULL) 351: { 352: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 353: return; 354: } 355: 356: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2; 357: (*(*l_element_precedent).suivant).suivant = l_element_courant; 358: 359: while((*l_element_courant).suivant != NULL) 360: { 361: l_element_precedent = l_element_courant; 362: l_element_courant = (*l_element_courant).suivant; 363: } 364: 365: if (((*l_element_precedent).suivant = 366: allocation_maillon(s_etat_processus)) == NULL) 367: { 368: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 369: return; 370: } 371: 372: if (((*(*l_element_precedent).suivant).donnee = 373: allocation(s_etat_processus, FCT)) == NULL) 374: { 375: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 376: return; 377: } 378: 379: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 380: .donnee).objet)).nombre_arguments = 2; 381: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 382: .donnee).objet)).fonction = instruction_pourcent; 383: 384: if (((*((struct_fonction *) (*(*(*l_element_precedent) 385: .suivant).donnee).objet)).nom_fonction = 386: malloc(2 * sizeof(unsigned char))) == NULL) 387: { 388: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 389: return; 390: } 391: 392: strcpy((*((struct_fonction *) (*(*(*l_element_precedent) 393: .suivant).donnee).objet)).nom_fonction, "%"); 394: 395: (*(*l_element_precedent).suivant).suivant = l_element_courant; 396: 397: s_objet_argument_2 = NULL; 398: } 399: 400: /* 401: * Expression / Nom ou valeur numérique 402: */ 403: 404: else if ((((*s_objet_argument_1).type == NOM) || 405: ((*s_objet_argument_1).type == INT) || 406: ((*s_objet_argument_1).type == REL)) && 407: ((((*s_objet_argument_2).type == ALG) || 408: ((*s_objet_argument_2).type == RPN)))) 409: { 410: nombre_elements = 0; 411: l_element_courant = (struct_liste_chainee *) 412: (*s_objet_argument_2).objet; 413: 414: while(l_element_courant != NULL) 415: { 416: nombre_elements++; 417: l_element_courant = (*l_element_courant).suivant; 418: } 419: 420: if (nombre_elements == 2) 421: { 422: liberation(s_etat_processus, s_objet_argument_1); 423: liberation(s_etat_processus, s_objet_argument_2); 424: 425: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 426: return; 427: } 428: 429: if ((s_objet_resultat = copie_objet(s_etat_processus, 430: s_objet_argument_2, 'N')) == NULL) 431: { 432: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 433: return; 434: } 435: 436: l_element_courant = (struct_liste_chainee *) 437: (*s_objet_resultat).objet; 438: l_element_precedent = l_element_courant; 439: 440: while((*l_element_courant).suivant != NULL) 441: { 442: l_element_precedent = l_element_courant; 443: l_element_courant = (*l_element_courant).suivant; 444: } 445: 446: if (((*l_element_precedent).suivant = 447: allocation_maillon(s_etat_processus)) == NULL) 448: { 449: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 450: return; 451: } 452: 453: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1; 454: l_element_precedent = (*l_element_precedent).suivant; 455: 456: if (((*l_element_precedent).suivant = 457: allocation_maillon(s_etat_processus)) == NULL) 458: { 459: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 460: return; 461: } 462: 463: if (((*(*l_element_precedent).suivant).donnee = 464: allocation(s_etat_processus, FCT)) == NULL) 465: { 466: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 467: return; 468: } 469: 470: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 471: .donnee).objet)).nombre_arguments = 2; 472: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 473: .donnee).objet)).fonction = instruction_pourcent; 474: 475: if (((*((struct_fonction *) (*(*(*l_element_precedent) 476: .suivant).donnee).objet)).nom_fonction = 477: malloc(2 * sizeof(unsigned char))) == NULL) 478: { 479: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 480: return; 481: } 482: 483: strcpy((*((struct_fonction *) (*(*(*l_element_precedent) 484: .suivant).donnee).objet)).nom_fonction, "%"); 485: 486: (*(*l_element_precedent).suivant).suivant = l_element_courant; 487: 488: s_objet_argument_1 = NULL; 489: } 490: 491: /* 492: * Expression / Expression 493: */ 494: 495: else if ((((*s_objet_argument_1).type == ALG) && 496: ((*s_objet_argument_2).type == ALG)) || 497: (((*s_objet_argument_1).type == RPN) && 498: ((*s_objet_argument_2).type == RPN))) 499: { 500: nombre_elements = 0; 501: l_element_courant = (struct_liste_chainee *) 502: (*s_objet_argument_1).objet; 503: 504: while(l_element_courant != NULL) 505: { 506: nombre_elements++; 507: l_element_courant = (*l_element_courant).suivant; 508: } 509: 510: if (nombre_elements == 2) 511: { 512: liberation(s_etat_processus, s_objet_argument_1); 513: liberation(s_etat_processus, s_objet_argument_2); 514: 515: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 516: return; 517: } 518: 519: nombre_elements = 0; 520: l_element_courant = (struct_liste_chainee *) 521: (*s_objet_argument_2).objet; 522: 523: while(l_element_courant != NULL) 524: { 525: nombre_elements++; 526: l_element_courant = (*l_element_courant).suivant; 527: } 528: 529: if (nombre_elements == 2) 530: { 531: liberation(s_etat_processus, s_objet_argument_1); 532: liberation(s_etat_processus, s_objet_argument_2); 533: 534: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 535: return; 536: } 537: 538: if ((s_copie_argument_1 = copie_objet(s_etat_processus, 539: s_objet_argument_1, 'N')) == NULL) 540: { 541: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 542: return; 543: } 544: 545: if ((s_copie_argument_2 = copie_objet(s_etat_processus, 546: s_objet_argument_2, 'N')) == NULL) 547: { 548: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 549: return; 550: } 551: 552: l_element_courant = (struct_liste_chainee *) 553: (*s_copie_argument_1).objet; 554: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *) 555: (*s_copie_argument_1).objet)).suivant; 556: 557: liberation(s_etat_processus, (*l_element_courant).donnee); 558: free(l_element_courant); 559: 560: l_element_courant = (struct_liste_chainee *) 561: (*s_copie_argument_2).objet; 562: l_element_precedent = l_element_courant; 563: s_objet_resultat = s_copie_argument_2; 564: 565: while((*l_element_courant).suivant != NULL) 566: { 567: l_element_precedent = l_element_courant; 568: l_element_courant = (*l_element_courant).suivant; 569: } 570: 571: liberation(s_etat_processus, (*l_element_courant).donnee); 572: free(l_element_courant); 573: 574: (*l_element_precedent).suivant = (struct_liste_chainee *) 575: (*s_copie_argument_1).objet; 576: free(s_copie_argument_1); 577: 578: l_element_courant = (*l_element_precedent).suivant; 579: while((*l_element_courant).suivant != NULL) 580: { 581: l_element_precedent = l_element_courant; 582: l_element_courant = (*l_element_courant).suivant; 583: } 584: 585: if (((*l_element_precedent).suivant = 586: allocation_maillon(s_etat_processus)) == NULL) 587: { 588: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 589: return; 590: } 591: 592: (*(*l_element_precedent).suivant).suivant = l_element_courant; 593: l_element_courant = (*l_element_precedent).suivant; 594: 595: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 596: == NULL) 597: { 598: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 599: return; 600: } 601: 602: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 603: .nombre_arguments = 2; 604: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 605: .fonction = instruction_pourcent; 606: 607: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 608: .nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL) 609: { 610: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 611: return; 612: } 613: 614: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 615: .nom_fonction, "%"); 616: } 617: 618: /* 619: -------------------------------------------------------------------------------- 620: Arguments incorrects 621: -------------------------------------------------------------------------------- 622: */ 623: 624: else 625: { 626: liberation(s_etat_processus, s_objet_argument_1); 627: liberation(s_etat_processus, s_objet_argument_2); 628: 629: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 630: return; 631: } 632: 633: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 634: s_objet_resultat) == d_erreur) 635: { 636: return; 637: } 638: 639: liberation(s_etat_processus, s_objet_argument_1); 640: liberation(s_etat_processus, s_objet_argument_2); 641: 642: return; 643: } 644: 645: 646: /* 647: ================================================================================ 648: Fonction '%CH' 649: ================================================================================ 650: Entrées : 651: -------------------------------------------------------------------------------- 652: Sorties : 653: -------------------------------------------------------------------------------- 654: Effets de bord : néant 655: ================================================================================ 656: */ 657: 658: void 659: instruction_pourcent_ch(struct_processus *s_etat_processus) 660: { 661: struct_liste_chainee *l_element_courant; 662: struct_liste_chainee *l_element_precedent; 663: 664: struct_objet *s_copie_argument_1; 665: struct_objet *s_copie_argument_2; 666: struct_objet *s_objet_argument_1; 667: struct_objet *s_objet_argument_2; 668: struct_objet *s_objet_resultat; 669: 670: unsigned long nombre_elements; 671: 672: (*s_etat_processus).erreur_execution = d_ex; 673: 674: if ((*s_etat_processus).affichage_arguments == 'Y') 675: { 676: printf("\n %%CH "); 677: 678: if ((*s_etat_processus).langue == 'F') 679: { 680: printf("(différence en pourcent)\n\n"); 681: } 682: else 683: { 684: printf("(change percentage)\n\n"); 685: } 686: 687: printf(" 2: %s, %s\n", d_INT, d_REL); 688: printf(" 1: %s, %s\n", d_INT, d_REL); 689: printf("-> 1: %s\n\n", d_REL); 690: 691: printf(" 2: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL); 692: printf(" 1: %s, %s, %s, %s\n", d_NOM, d_ALG, d_INT, d_REL); 693: printf("-> 1: %s\n\n", d_ALG); 694: 695: printf(" 2: %s, %s, %s, %s\n", d_RPN, d_NOM, d_INT, d_REL); 696: printf(" 1: %s, %s, %s, %s\n", d_RPN, d_NOM, d_INT, d_REL); 697: printf("-> 1: %s\n", d_RPN); 698: 699: return; 700: } 701: else if ((*s_etat_processus).test_instruction == 'Y') 702: { 703: (*s_etat_processus).nombre_arguments = -1; 704: return; 705: } 706: 707: if (test_cfsf(s_etat_processus, 31) == d_vrai) 708: { 709: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 710: { 711: return; 712: } 713: } 714: 715: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 716: &s_objet_argument_1) == d_erreur) 717: { 718: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 719: return; 720: } 721: 722: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 723: &s_objet_argument_2) == d_erreur) 724: { 725: liberation(s_etat_processus, s_objet_argument_1); 726: 727: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 728: return; 729: } 730: 731: /* 732: -------------------------------------------------------------------------------- 733: %CH portant sur des valeurs numériques 734: -------------------------------------------------------------------------------- 735: */ 736: 737: if ((((*s_objet_argument_1).type == INT) || 738: ((*s_objet_argument_1).type == REL)) && 739: (((*s_objet_argument_2).type == INT) || 740: ((*s_objet_argument_2).type == REL))) 741: { 742: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 743: == NULL) 744: { 745: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 746: return; 747: } 748: 749: if ((*s_objet_argument_1).type == INT) 750: { 751: if ((*s_objet_argument_2).type == INT) 752: { 753: (*((real8 *) (*s_objet_resultat).objet)) = 100 * 754: (((real8) (*((integer8 *) (*s_objet_argument_1) 755: .objet)) - ((real8) (*((integer8 *) 756: (*s_objet_argument_2).objet)))) / ((real8) 757: (*((integer8 *) (*s_objet_argument_2).objet)))); 758: } 759: else 760: { 761: (*((real8 *) (*s_objet_resultat).objet)) = 100 * 762: (((real8) (*((integer8 *) (*s_objet_argument_1) 763: .objet)) - (*((real8 *) (*s_objet_argument_2).objet))) 764: / (*((real8 *) (*s_objet_argument_2).objet))); 765: } 766: } 767: else 768: { 769: if ((*s_objet_argument_2).type == INT) 770: { 771: (*((real8 *) (*s_objet_resultat).objet)) = 100 * 772: (((*((real8 *) (*s_objet_argument_1) 773: .objet)) - ((real8) (*((integer8 *) 774: (*s_objet_argument_2).objet)))) / ((real8) 775: (*((integer8 *) (*s_objet_argument_2).objet)))); 776: } 777: else 778: { 779: (*((real8 *) (*s_objet_resultat).objet)) = 100 * 780: (((*((real8 *) (*s_objet_argument_1).objet)) - 781: (*((real8 *) (*s_objet_argument_2).objet)))/ 782: (*((real8 *) (*s_objet_argument_2).objet))); 783: } 784: } 785: } 786: 787: /* 788: -------------------------------------------------------------------------------- 789: %CH entre des arguments complexes 790: -------------------------------------------------------------------------------- 791: */ 792: 793: /* 794: * Nom ou valeur numérique / Nom ou valeur numérique 795: */ 796: 797: else if ((((*s_objet_argument_1).type == NOM) && 798: (((*s_objet_argument_2).type == NOM) || 799: ((*s_objet_argument_2).type == INT) || 800: ((*s_objet_argument_2).type == REL))) || 801: (((*s_objet_argument_2).type == NOM) && 802: (((*s_objet_argument_1).type == INT) || 803: ((*s_objet_argument_1).type == REL)))) 804: { 805: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) 806: == NULL) 807: { 808: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 809: return; 810: } 811: 812: if (((*s_objet_resultat).objet = 813: allocation_maillon(s_etat_processus)) == NULL) 814: { 815: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 816: return; 817: } 818: 819: l_element_courant = (*s_objet_resultat).objet; 820: 821: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 822: == NULL) 823: { 824: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 825: return; 826: } 827: 828: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 829: .nombre_arguments = 0; 830: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 831: .fonction = instruction_vers_niveau_superieur; 832: 833: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 834: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 835: { 836: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 837: return; 838: } 839: 840: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 841: .nom_fonction, "<<"); 842: 843: if (((*l_element_courant).suivant = 844: allocation_maillon(s_etat_processus)) == NULL) 845: { 846: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 847: return; 848: } 849: 850: l_element_courant = (*l_element_courant).suivant; 851: (*l_element_courant).donnee = s_objet_argument_2; 852: 853: if (((*l_element_courant).suivant = 854: allocation_maillon(s_etat_processus)) == NULL) 855: { 856: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 857: return; 858: } 859: 860: l_element_courant = (*l_element_courant).suivant; 861: (*l_element_courant).donnee = s_objet_argument_1; 862: 863: if (((*l_element_courant).suivant = 864: allocation_maillon(s_etat_processus)) == NULL) 865: { 866: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 867: return; 868: } 869: 870: l_element_courant = (*l_element_courant).suivant; 871: 872: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 873: == NULL) 874: { 875: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 876: return; 877: } 878: 879: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 880: .nombre_arguments = 2; 881: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 882: .fonction = instruction_pourcent_ch; 883: 884: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 885: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) 886: { 887: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 888: return; 889: } 890: 891: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 892: .nom_fonction, "%CH"); 893: 894: if (((*l_element_courant).suivant = 895: allocation_maillon(s_etat_processus)) == NULL) 896: { 897: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 898: return; 899: } 900: 901: l_element_courant = (*l_element_courant).suivant; 902: 903: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 904: == NULL) 905: { 906: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 907: return; 908: } 909: 910: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 911: .nombre_arguments = 0; 912: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 913: .fonction = instruction_vers_niveau_inferieur; 914: 915: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 916: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 917: { 918: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 919: return; 920: } 921: 922: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 923: .nom_fonction, ">>"); 924: 925: (*l_element_courant).suivant = NULL; 926: 927: s_objet_argument_1 = NULL; 928: s_objet_argument_2 = NULL; 929: } 930: 931: /* 932: * Nom ou valeur numérique / Expression 933: */ 934: 935: else if (((((*s_objet_argument_1).type == ALG) || 936: ((*s_objet_argument_1).type == RPN))) && 937: (((*s_objet_argument_2).type == NOM) || 938: ((*s_objet_argument_2).type == INT) || 939: ((*s_objet_argument_2).type == REL))) 940: { 941: nombre_elements = 0; 942: l_element_courant = (struct_liste_chainee *) 943: (*s_objet_argument_1).objet; 944: 945: while(l_element_courant != NULL) 946: { 947: nombre_elements++; 948: l_element_courant = (*l_element_courant).suivant; 949: } 950: 951: if (nombre_elements == 2) 952: { 953: liberation(s_etat_processus, s_objet_argument_1); 954: liberation(s_etat_processus, s_objet_argument_2); 955: 956: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 957: return; 958: } 959: 960: if ((s_objet_resultat = copie_objet(s_etat_processus, 961: s_objet_argument_1, 'N')) == NULL) 962: { 963: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 964: return; 965: } 966: 967: l_element_courant = (struct_liste_chainee *) 968: (*s_objet_resultat).objet; 969: l_element_precedent = l_element_courant; 970: l_element_courant = (*l_element_courant).suivant; 971: 972: if (((*l_element_precedent).suivant = 973: allocation_maillon(s_etat_processus)) == NULL) 974: { 975: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 976: return; 977: } 978: 979: (*(*l_element_precedent).suivant).donnee = s_objet_argument_2; 980: (*(*l_element_precedent).suivant).suivant = l_element_courant; 981: 982: while((*l_element_courant).suivant != NULL) 983: { 984: l_element_precedent = l_element_courant; 985: l_element_courant = (*l_element_courant).suivant; 986: } 987: 988: if (((*l_element_precedent).suivant = 989: allocation_maillon(s_etat_processus)) == NULL) 990: { 991: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 992: return; 993: } 994: 995: if (((*(*l_element_precedent).suivant).donnee = 996: allocation(s_etat_processus, FCT)) == NULL) 997: { 998: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 999: return; 1000: } 1001: 1002: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1003: .donnee).objet)).nombre_arguments = 2; 1004: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1005: .donnee).objet)).fonction = instruction_pourcent_ch; 1006: 1007: if (((*((struct_fonction *) (*(*(*l_element_precedent) 1008: .suivant).donnee).objet)).nom_fonction = 1009: malloc(4 * sizeof(unsigned char))) == NULL) 1010: { 1011: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1012: return; 1013: } 1014: 1015: strcpy((*((struct_fonction *) (*(*(*l_element_precedent) 1016: .suivant).donnee).objet)).nom_fonction, "%CH"); 1017: 1018: (*(*l_element_precedent).suivant).suivant = l_element_courant; 1019: 1020: s_objet_argument_2 = NULL; 1021: } 1022: 1023: /* 1024: * Expression / Nom ou valeur numérique 1025: */ 1026: 1027: else if ((((*s_objet_argument_1).type == NOM) || 1028: ((*s_objet_argument_1).type == INT) || 1029: ((*s_objet_argument_1).type == REL)) && 1030: ((((*s_objet_argument_2).type == ALG) || 1031: ((*s_objet_argument_2).type == RPN)))) 1032: { 1033: nombre_elements = 0; 1034: l_element_courant = (struct_liste_chainee *) 1035: (*s_objet_argument_2).objet; 1036: 1037: while(l_element_courant != NULL) 1038: { 1039: nombre_elements++; 1040: l_element_courant = (*l_element_courant).suivant; 1041: } 1042: 1043: if (nombre_elements == 2) 1044: { 1045: liberation(s_etat_processus, s_objet_argument_1); 1046: liberation(s_etat_processus, s_objet_argument_2); 1047: 1048: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1049: return; 1050: } 1051: 1052: if ((s_objet_resultat = copie_objet(s_etat_processus, 1053: s_objet_argument_2, 'N')) == NULL) 1054: { 1055: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1056: return; 1057: } 1058: 1059: l_element_courant = (struct_liste_chainee *) 1060: (*s_objet_resultat).objet; 1061: l_element_precedent = l_element_courant; 1062: 1063: while((*l_element_courant).suivant != NULL) 1064: { 1065: l_element_precedent = l_element_courant; 1066: l_element_courant = (*l_element_courant).suivant; 1067: } 1068: 1069: if (((*l_element_precedent).suivant = 1070: allocation_maillon(s_etat_processus)) == NULL) 1071: { 1072: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1073: return; 1074: } 1075: 1076: (*(*l_element_precedent).suivant).donnee = s_objet_argument_1; 1077: l_element_precedent = (*l_element_precedent).suivant; 1078: 1079: if (((*l_element_precedent).suivant = 1080: allocation_maillon(s_etat_processus)) == NULL) 1081: { 1082: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1083: return; 1084: } 1085: 1086: if (((*(*l_element_precedent).suivant).donnee = 1087: allocation(s_etat_processus, FCT)) == NULL) 1088: { 1089: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1090: return; 1091: } 1092: 1093: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1094: .donnee).objet)).nombre_arguments = 2; 1095: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1096: .donnee).objet)).fonction = instruction_pourcent_ch; 1097: 1098: if (((*((struct_fonction *) (*(*(*l_element_precedent) 1099: .suivant).donnee).objet)).nom_fonction = 1100: malloc(4 * sizeof(unsigned char))) == NULL) 1101: { 1102: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1103: return; 1104: } 1105: 1106: strcpy((*((struct_fonction *) (*(*(*l_element_precedent) 1107: .suivant).donnee).objet)).nom_fonction, "%CH"); 1108: 1109: (*(*l_element_precedent).suivant).suivant = l_element_courant; 1110: 1111: s_objet_argument_1 = NULL; 1112: } 1113: 1114: /* 1115: * Expression / Expression 1116: */ 1117: 1118: else if ((((*s_objet_argument_1).type == ALG) && 1119: ((*s_objet_argument_2).type == ALG)) || 1120: (((*s_objet_argument_1).type == RPN) && 1121: ((*s_objet_argument_2).type == RPN))) 1122: { 1123: nombre_elements = 0; 1124: l_element_courant = (struct_liste_chainee *) 1125: (*s_objet_argument_1).objet; 1126: 1127: while(l_element_courant != NULL) 1128: { 1129: nombre_elements++; 1130: l_element_courant = (*l_element_courant).suivant; 1131: } 1132: 1133: if (nombre_elements == 2) 1134: { 1135: liberation(s_etat_processus, s_objet_argument_1); 1136: liberation(s_etat_processus, s_objet_argument_2); 1137: 1138: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1139: return; 1140: } 1141: 1142: nombre_elements = 0; 1143: l_element_courant = (struct_liste_chainee *) 1144: (*s_objet_argument_2).objet; 1145: 1146: while(l_element_courant != NULL) 1147: { 1148: nombre_elements++; 1149: l_element_courant = (*l_element_courant).suivant; 1150: } 1151: 1152: if (nombre_elements == 2) 1153: { 1154: liberation(s_etat_processus, s_objet_argument_1); 1155: liberation(s_etat_processus, s_objet_argument_2); 1156: 1157: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1158: return; 1159: } 1160: 1161: if ((s_copie_argument_1 = copie_objet(s_etat_processus, 1162: s_objet_argument_1, 'N')) == NULL) 1163: { 1164: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1165: return; 1166: } 1167: 1168: if ((s_copie_argument_2 = copie_objet(s_etat_processus, 1169: s_objet_argument_2, 'N')) == NULL) 1170: { 1171: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1172: return; 1173: } 1174: 1175: l_element_courant = (struct_liste_chainee *) 1176: (*s_copie_argument_1).objet; 1177: (*s_copie_argument_1).objet = (void *) (*((struct_liste_chainee *) 1178: (*s_copie_argument_1).objet)).suivant; 1179: 1180: liberation(s_etat_processus, (*l_element_courant).donnee); 1181: free(l_element_courant); 1182: 1183: l_element_courant = (struct_liste_chainee *) 1184: (*s_copie_argument_2).objet; 1185: l_element_precedent = l_element_courant; 1186: s_objet_resultat = s_copie_argument_2; 1187: 1188: while((*l_element_courant).suivant != NULL) 1189: { 1190: l_element_precedent = l_element_courant; 1191: l_element_courant = (*l_element_courant).suivant; 1192: } 1193: 1194: liberation(s_etat_processus, (*l_element_courant).donnee); 1195: free(l_element_courant); 1196: 1197: (*l_element_precedent).suivant = (struct_liste_chainee *) 1198: (*s_copie_argument_1).objet; 1199: free(s_copie_argument_1); 1200: 1201: l_element_courant = (*l_element_precedent).suivant; 1202: while((*l_element_courant).suivant != NULL) 1203: { 1204: l_element_precedent = l_element_courant; 1205: l_element_courant = (*l_element_courant).suivant; 1206: } 1207: 1208: if (((*l_element_precedent).suivant = 1209: allocation_maillon(s_etat_processus)) == NULL) 1210: { 1211: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1212: return; 1213: } 1214: 1215: (*(*l_element_precedent).suivant).suivant = l_element_courant; 1216: l_element_courant = (*l_element_precedent).suivant; 1217: 1218: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1219: == NULL) 1220: { 1221: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1222: return; 1223: } 1224: 1225: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1226: .nombre_arguments = 2; 1227: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1228: .fonction = instruction_pourcent_ch; 1229: 1230: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1231: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) 1232: { 1233: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1234: return; 1235: } 1236: 1237: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1238: .nom_fonction, "%CH"); 1239: } 1240: 1241: /* 1242: -------------------------------------------------------------------------------- 1243: Arguments incorrects 1244: -------------------------------------------------------------------------------- 1245: */ 1246: 1247: else 1248: { 1249: liberation(s_etat_processus, s_objet_argument_1); 1250: liberation(s_etat_processus, s_objet_argument_2); 1251: 1252: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1253: return; 1254: } 1255: 1256: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1257: s_objet_resultat) == d_erreur) 1258: { 1259: return; 1260: } 1261: 1262: liberation(s_etat_processus, s_objet_argument_1); 1263: liberation(s_etat_processus, s_objet_argument_2); 1264: 1265: return; 1266: } 1267: 1268: 1269: /* 1270: ================================================================================ 1271: Fonction 'pos' 1272: ================================================================================ 1273: Entrées : 1274: -------------------------------------------------------------------------------- 1275: Sorties : 1276: -------------------------------------------------------------------------------- 1277: Effets de bord : néant 1278: ================================================================================ 1279: */ 1280: 1281: void 1282: instruction_pos(struct_processus *s_etat_processus) 1283: { 1284: logical1 presence_atome; 1285: 1286: struct_liste_chainee *l_base_pile; 1287: struct_liste_chainee *l_element_courant; 1288: 1289: struct_objet *s_objet_argument_1; 1290: struct_objet *s_objet_argument_2; 1291: struct_objet *s_objet_elementaire; 1292: struct_objet *s_objet_resultat; 1293: 1294: unsigned char *pointeur_occurrence; 1295: 1296: unsigned long position; 1297: 1298: (*s_etat_processus).erreur_execution = d_ex; 1299: 1300: if ((*s_etat_processus).affichage_arguments == 'Y') 1301: { 1302: printf("\n POS "); 1303: 1304: if ((*s_etat_processus).langue == 'F') 1305: { 1306: printf("(position)\n\n"); 1307: } 1308: else 1309: { 1310: printf("(position)\n\n"); 1311: } 1312: 1313: printf(" 2: %s\n", d_CHN); 1314: printf(" 1: %s\n", d_CHN); 1315: printf("-> 1: %s\n\n", d_INT); 1316: 1317: printf(" 2: %s, %s\n", d_LST, d_TAB); 1318: printf(" 1: %s, %s, %s, %s, %s, %s,\n" 1319: " %s, %s, %s, %s, %s,\n" 1320: " %s, %s, %s, %s\n", 1321: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 1322: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN); 1323: printf("-> 1: %s\n", d_INT); 1324: 1325: return; 1326: } 1327: else if ((*s_etat_processus).test_instruction == 'Y') 1328: { 1329: (*s_etat_processus).nombre_arguments = -1; 1330: return; 1331: } 1332: 1333: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1334: { 1335: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 1336: { 1337: return; 1338: } 1339: } 1340: 1341: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1342: &s_objet_argument_1) == d_erreur) 1343: { 1344: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1345: return; 1346: } 1347: 1348: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1349: &s_objet_argument_2) == d_erreur) 1350: { 1351: liberation(s_etat_processus, s_objet_argument_1); 1352: 1353: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1354: return; 1355: } 1356: 1357: /* 1358: -------------------------------------------------------------------------------- 1359: Types chaînes de caractères 1360: -------------------------------------------------------------------------------- 1361: */ 1362: 1363: if (((*s_objet_argument_1).type == CHN) && 1364: ((*s_objet_argument_2).type == CHN)) 1365: { 1366: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 1367: { 1368: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1369: return; 1370: } 1371: 1372: if ((pointeur_occurrence = strstr((unsigned char *) 1373: (*s_objet_argument_2).objet, (unsigned char *) 1374: (*s_objet_argument_1).objet)) == NULL) 1375: { 1376: (*((integer8 *) (*s_objet_resultat).objet)) = 0; 1377: } 1378: else 1379: { 1380: (*((integer8 *) (*s_objet_resultat).objet)) = 1 + (integer8) 1381: (pointeur_occurrence - ((unsigned char *) 1382: (*s_objet_argument_2).objet)); 1383: } 1384: } 1385: 1386: /* 1387: -------------------------------------------------------------------------------- 1388: L'argument au niveau 2 est une liste, celui au niveau 1 peut prendre 1389: n'importe quel type susceptible d'être contenu dans une liste. 1390: -------------------------------------------------------------------------------- 1391: */ 1392: 1393: else if ((*s_objet_argument_2).type == LST) 1394: { 1395: l_element_courant = (struct_liste_chainee *) 1396: (*s_objet_argument_2).objet; 1397: position = 1; 1398: presence_atome = d_faux; 1399: 1400: l_base_pile = (*s_etat_processus).l_base_pile_last; 1401: (*s_etat_processus).l_base_pile_last = NULL; 1402: 1403: while(l_element_courant != NULL) 1404: { 1405: if ((s_objet_elementaire = 1406: copie_objet(s_etat_processus, (*l_element_courant).donnee, 1407: 'P')) == NULL) 1408: { 1409: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1410: return; 1411: } 1412: 1413: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1414: s_objet_elementaire) == d_erreur) 1415: { 1416: return; 1417: } 1418: 1419: if ((s_objet_elementaire = 1420: copie_objet(s_etat_processus, s_objet_argument_1, 'P')) 1421: == NULL) 1422: { 1423: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1424: return; 1425: } 1426: 1427: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1428: s_objet_elementaire) == d_erreur) 1429: { 1430: return; 1431: } 1432: 1433: instruction_same(s_etat_processus); 1434: 1435: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1436: &s_objet_elementaire) == d_erreur) 1437: { 1438: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1439: return; 1440: } 1441: 1442: if ((*s_objet_elementaire).type == INT) 1443: { 1444: if ((*((integer8 *) (*s_objet_elementaire).objet)) != 0) 1445: { 1446: presence_atome = d_vrai; 1447: 1448: liberation(s_etat_processus, s_objet_elementaire); 1449: break; 1450: } 1451: } 1452: else 1453: { 1454: (*s_etat_processus).erreur_execution = 1455: d_ex_erreur_type_argument; 1456: return; 1457: } 1458: 1459: liberation(s_etat_processus, s_objet_elementaire); 1460: 1461: l_element_courant = (*l_element_courant).suivant; 1462: position++; 1463: } 1464: 1465: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1466: { 1467: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 1468: { 1469: return; 1470: } 1471: } 1472: 1473: (*s_etat_processus).l_base_pile_last = l_base_pile; 1474: 1475: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 1476: { 1477: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1478: return; 1479: } 1480: 1481: if (presence_atome == d_faux) 1482: { 1483: (*((integer8 *) (*s_objet_resultat).objet)) = 0; 1484: } 1485: else 1486: { 1487: (*((integer8 *) (*s_objet_resultat).objet)) = position; 1488: } 1489: } 1490: 1491: /* 1492: -------------------------------------------------------------------------------- 1493: L'argument au niveau 2 est une table, celui au niveau 1 peut prendre 1494: n'importe quel type susceptible d'être contenu dans une liste. 1495: -------------------------------------------------------------------------------- 1496: */ 1497: 1498: else if ((*s_objet_argument_2).type == TBL) 1499: { 1500: presence_atome = d_faux; 1501: 1502: l_base_pile = (*s_etat_processus).l_base_pile_last; 1503: (*s_etat_processus).l_base_pile_last = NULL; 1504: 1505: position = 0; 1506: 1507: do 1508: { 1509: if ((s_objet_elementaire = 1510: copie_objet(s_etat_processus, (*((struct_tableau *) 1511: (*s_objet_argument_2) .objet)).elements[position], 'P')) 1512: == NULL) 1513: { 1514: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1515: return; 1516: } 1517: 1518: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1519: s_objet_elementaire) == d_erreur) 1520: { 1521: return; 1522: } 1523: 1524: if ((s_objet_elementaire = copie_objet(s_etat_processus, 1525: s_objet_argument_1, 'P')) == NULL) 1526: { 1527: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1528: return; 1529: } 1530: 1531: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1532: s_objet_elementaire) == d_erreur) 1533: { 1534: return; 1535: } 1536: 1537: instruction_same(s_etat_processus); 1538: 1539: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1540: &s_objet_elementaire) == d_erreur) 1541: { 1542: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1543: return; 1544: } 1545: 1546: if ((*s_objet_elementaire).type == INT) 1547: { 1548: if ((*((integer8 *) (*s_objet_elementaire).objet)) != 0) 1549: { 1550: presence_atome = d_vrai; 1551: position++; 1552: 1553: liberation(s_etat_processus, s_objet_elementaire); 1554: break; 1555: } 1556: } 1557: else 1558: { 1559: (*s_etat_processus).erreur_execution = 1560: d_ex_erreur_type_argument; 1561: return; 1562: } 1563: 1564: liberation(s_etat_processus, s_objet_elementaire); 1565: 1566: position++; 1567: } while(position < (*((struct_tableau *) (*s_objet_argument_2).objet)) 1568: .nombre_elements); 1569: 1570: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1571: { 1572: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 1573: { 1574: return; 1575: } 1576: } 1577: 1578: (*s_etat_processus).l_base_pile_last = l_base_pile; 1579: 1580: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 1581: { 1582: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1583: return; 1584: } 1585: 1586: if (presence_atome == d_faux) 1587: { 1588: (*((integer8 *) (*s_objet_resultat).objet)) = 0; 1589: } 1590: else 1591: { 1592: (*((integer8 *) (*s_objet_resultat).objet)) = position; 1593: } 1594: } 1595: 1596: /* 1597: -------------------------------------------------------------------------------- 1598: Arguments invalides 1599: -------------------------------------------------------------------------------- 1600: */ 1601: 1602: else 1603: { 1604: liberation(s_etat_processus, s_objet_argument_1); 1605: liberation(s_etat_processus, s_objet_argument_2); 1606: 1607: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1608: return; 1609: } 1610: 1611: liberation(s_etat_processus, s_objet_argument_1); 1612: liberation(s_etat_processus, s_objet_argument_2); 1613: 1614: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1615: s_objet_resultat) == d_erreur) 1616: { 1617: return; 1618: } 1619: 1620: return; 1621: } 1622: 1623: 1624: /* 1625: ================================================================================ 1626: Fonction 'prompt' 1627: ================================================================================ 1628: Entrées : 1629: -------------------------------------------------------------------------------- 1630: Sorties : 1631: -------------------------------------------------------------------------------- 1632: Effets de bord : néant 1633: ================================================================================ 1634: */ 1635: 1636: void 1637: instruction_prompt(struct_processus *s_etat_processus) 1638: { 1639: struct_objet *s_objet_argument; 1640: struct_objet *s_objet_resultat; 1641: 1642: unsigned char *tampon; 1643: unsigned char *tampon2; 1644: 1645: (*s_etat_processus).erreur_execution = d_ex; 1646: 1647: if ((*s_etat_processus).affichage_arguments == 'Y') 1648: { 1649: printf("\n PROMPT "); 1650: 1651: if ((*s_etat_processus).langue == 'F') 1652: { 1653: printf("(attente d'une entrée)\n\n"); 1654: } 1655: else 1656: { 1657: printf("(prompt)\n\n"); 1658: } 1659: 1660: printf(" 1: %s\n", d_CHN); 1661: printf("-> 1: %s\n", d_CHN); 1662: 1663: return; 1664: } 1665: else if ((*s_etat_processus).test_instruction == 'Y') 1666: { 1667: (*s_etat_processus).nombre_arguments = -1; 1668: return; 1669: } 1670: 1671: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1672: { 1673: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1674: { 1675: return; 1676: } 1677: } 1678: 1679: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1680: &s_objet_argument) == d_erreur) 1681: { 1682: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1683: return; 1684: } 1685: 1686: if ((*s_objet_argument).type == CHN) 1687: { 1688: if ((tampon = formateur(s_etat_processus, 0, s_objet_argument)) == NULL) 1689: { 1690: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1691: return; 1692: } 1693: 1694: if ((tampon2 = transliteration(s_etat_processus, tampon, 1695: d_locale, (*s_etat_processus).localisation)) == NULL) 1696: { 1697: free(tampon); 1698: 1699: (*s_etat_processus).erreur_execution = d_ex_erreur_transcodage; 1700: return; 1701: } 1702: 1703: free(tampon); 1704: 1705: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL) 1706: { 1707: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1708: return; 1709: } 1710: 1711: flockfile(stdin); 1712: flockfile(stdout); 1713: 1714: (*s_objet_resultat).objet = (void *) readline(tampon2); 1715: 1716: funlockfile(stdin); 1717: funlockfile(stdout); 1718: 1719: free(tampon2); 1720: 1721: if ((*s_objet_resultat).objet == NULL) 1722: { 1723: if (((*s_objet_resultat).objet = malloc(sizeof(unsigned char))) 1724: == NULL) 1725: { 1726: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1727: return; 1728: } 1729: 1730: (*((unsigned char *) (*s_objet_resultat).objet)) = 1731: d_code_fin_chaine; 1732: } 1733: 1734: if ((tampon = transliteration(s_etat_processus, 1735: (unsigned char *) (*s_objet_resultat).objet, 1736: (*s_etat_processus).localisation, d_locale)) == NULL) 1737: { 1738: return; 1739: } 1740: 1741: free((unsigned char *) (*s_objet_resultat).objet); 1742: (*s_objet_resultat).objet = tampon; 1743: 1744: add_history((unsigned char *) (*s_objet_resultat).objet); 1745: stifle_history(ds_longueur_historique); 1746: } 1747: else 1748: { 1749: liberation(s_etat_processus, s_objet_argument); 1750: 1751: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1752: return; 1753: } 1754: 1755: liberation(s_etat_processus, s_objet_argument); 1756: 1757: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1758: s_objet_resultat) == d_erreur) 1759: { 1760: return; 1761: } 1762: 1763: return; 1764: } 1765: 1766: // vim: ts=4