![]() ![]() | ![]() |
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 'eval' 29: ================================================================================ 30: Entrées : structure processus 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_eval(struct_processus *s_etat_processus) 40: { 41: logical1 last_valide; 42: 43: struct_objet *s_objet; 44: struct_objet *s_objet_simplifie; 45: 46: unsigned char registre_type_evaluation; 47: 48: (*s_etat_processus).erreur_execution = d_ex; 49: 50: if ((*s_etat_processus).affichage_arguments == 'Y') 51: { 52: printf("\n EVAL "); 53: 54: if ((*s_etat_processus).langue == 'F') 55: { 56: printf("(évaluation d'un objet)\n\n"); 57: } 58: else 59: { 60: printf("(object evaluation)\n\n"); 61: } 62: 63: printf(" 1: %s, %s, %s, %s, %s, %s,\n" 64: " %s, %s, %s, %s, %s,\n" 65: " %s, %s, %s, %s, %s,\n" 66: " %s\n", 67: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 68: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB); 69: printf("-> n: %s, %s, %s, %s, %s, %s,\n" 70: " %s, %s, %s, %s, %s,\n" 71: " %s, %s, %s, %s, %s,\n" 72: " %s\n", 73: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 74: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB); 75: printf(" ...\n"); 76: printf(" 1: %s, %s, %s, %s, %s, %s,\n" 77: " %s, %s, %s, %s, %s,\n" 78: " %s, %s, %s, %s, %s,\n" 79: " %s\n", 80: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 81: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB); 82: 83: return; 84: } 85: else if ((*s_etat_processus).test_instruction == 'Y') 86: { 87: (*s_etat_processus).nombre_arguments = -1; 88: return; 89: } 90: 91: if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai) 92: { 93: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 94: { 95: return; 96: } 97: 98: cf(s_etat_processus, 31); 99: } 100: 101: registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai) 102: ? 'E' : 'N'; 103: sf(s_etat_processus, 35); 104: 105: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 106: &s_objet) == d_erreur) 107: { 108: if (last_valide == d_vrai) 109: { 110: sf(s_etat_processus, 31); 111: } 112: 113: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 114: return; 115: } 116: 117: if ((s_objet_simplifie = simplification(s_etat_processus, s_objet)) == NULL) 118: { 119: if (last_valide == d_vrai) 120: { 121: sf(s_etat_processus, 31); 122: } 123: 124: return; 125: } 126: 127: liberation(s_etat_processus, s_objet); 128: s_objet = s_objet_simplifie; 129: 130: if ((*s_etat_processus).l_base_pile_systeme == NULL) 131: { 132: (*s_etat_processus).erreur_systeme = d_es_pile_vide; 133: return; 134: } 135: 136: (*(*s_etat_processus).l_base_pile_systeme).evaluation_expression = d_vrai; 137: 138: if (evaluation(s_etat_processus, s_objet, 'E') == d_erreur) 139: { 140: (*(*s_etat_processus).l_base_pile_systeme) 141: .evaluation_expression = d_faux; 142: 143: if (last_valide == d_vrai) 144: { 145: sf(s_etat_processus, 31); 146: } 147: 148: liberation(s_etat_processus, s_objet); 149: return; 150: } 151: 152: (*(*s_etat_processus).l_base_pile_systeme).evaluation_expression = d_faux; 153: liberation(s_etat_processus, s_objet); 154: 155: if (registre_type_evaluation == 'E') 156: { 157: sf(s_etat_processus, 35); 158: } 159: else 160: { 161: cf(s_etat_processus, 35); 162: } 163: 164: if (last_valide == d_vrai) 165: { 166: sf(s_etat_processus, 31); 167: } 168: 169: return; 170: } 171: 172: 173: /* 174: ================================================================================ 175: Fonction 'end' 176: ================================================================================ 177: Entrées : structure processus 178: -------------------------------------------------------------------------------- 179: Sorties : 180: -------------------------------------------------------------------------------- 181: Effets de bord : néant 182: ================================================================================ 183: */ 184: 185: void 186: instruction_end(struct_processus *s_etat_processus) 187: { 188: logical1 condition; 189: 190: struct_liste_pile_systeme *l_element_courant; 191: 192: struct_objet *s_objet; 193: 194: (*s_etat_processus).erreur_execution = d_ex; 195: 196: if ((*s_etat_processus).affichage_arguments == 'Y') 197: { 198: printf("\n END "); 199: 200: if ((*s_etat_processus).langue == 'F') 201: { 202: printf("(structure de contrôle)\n\n"); 203: printf(" Utilisation :\n\n"); 204: } 205: else 206: { 207: printf("(control statement)\n\n"); 208: printf(" Usage:\n\n"); 209: } 210: 211: printf(" IF\n"); 212: printf(" (expression test 1)\n"); 213: printf(" THEN\n"); 214: printf(" (expression 1)\n"); 215: printf(" [ELSEIF\n"); 216: printf(" (expression test 2)\n"); 217: printf(" THEN\n"); 218: printf(" (expression 2)]\n"); 219: printf(" ...\n"); 220: printf(" [ELSE\n"); 221: printf(" (expression n)]\n"); 222: printf(" END\n\n"); 223: 224: printf(" IFERR\n"); 225: printf(" (expression test)\n"); 226: printf(" THEN\n"); 227: printf(" (expression 1)\n"); 228: printf(" [ELSE\n"); 229: printf(" (expression 2)]\n"); 230: printf(" END\n\n"); 231: 232: printf(" DO\n"); 233: printf(" (expression)\n"); 234: printf(" UNTIL\n"); 235: printf(" (expression test)\n"); 236: printf(" END\n\n"); 237: 238: printf(" WHILE\n"); 239: printf(" (expression test)\n"); 240: printf(" REPEAT\n"); 241: printf(" (expression)\n"); 242: printf(" END\n\n"); 243: 244: printf(" SELECT (expression test)\n"); 245: printf(" CASE (clause 1) THEN (expression 1) END\n"); 246: printf(" CASE (clause 2) THEN (expression 2) END\n"); 247: printf(" ...\n"); 248: printf(" CASE (clause n) THEN (expression n) END\n"); 249: printf(" DEFAULT\n"); 250: printf(" (expression)\n"); 251: printf(" END\n\n"); 252: 253: printf(" SELECT (expression test)\n"); 254: printf(" CASE (clause 1) THEN (expression 1) END\n"); 255: printf(" (expression)\n"); 256: printf(" CASE (clause 2) THEN (expression 2) END\n"); 257: printf(" END\n"); 258: 259: return; 260: } 261: else if ((*s_etat_processus).test_instruction == 'Y') 262: { 263: (*s_etat_processus).nombre_arguments = -1; 264: return; 265: } 266: 267: if (((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'I') 268: || ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'J')) 269: { 270: depilement_pile_systeme(s_etat_processus); 271: 272: if ((*s_etat_processus).erreur_systeme != d_es) 273: { 274: return; 275: } 276: } 277: else if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'D') 278: { 279: if ((*(*s_etat_processus).l_base_pile_systeme).clause != 'U') 280: { 281: (*s_etat_processus).erreur_execution = 282: d_ex_erreur_traitement_boucle; 283: return; 284: } 285: 286: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 287: &s_objet) == d_erreur) 288: { 289: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 290: return; 291: } 292: 293: if (((*s_objet).type == INT) || 294: ((*s_objet).type == REL)) 295: { 296: if ((*s_objet).type == INT) 297: { 298: condition = ((*((integer8 *) (*s_objet).objet)) == 0) 299: ? d_faux : d_vrai; 300: } 301: else 302: { 303: condition = ((*((real8 *) (*s_objet).objet)) == 0) 304: ? d_faux : d_vrai; 305: } 306: 307: if (condition == d_faux) 308: { 309: if ((*s_etat_processus).mode_execution_programme == 'Y') 310: { 311: (*s_etat_processus).position_courante = 312: (*(*s_etat_processus).l_base_pile_systeme) 313: .adresse_retour; 314: } 315: else 316: { 317: (*s_etat_processus).expression_courante = 318: (*(*s_etat_processus).l_base_pile_systeme) 319: .pointeur_objet_retour; 320: } 321: } 322: else 323: { 324: depilement_pile_systeme(s_etat_processus); 325: 326: if ((*s_etat_processus).erreur_systeme != d_es) 327: { 328: return; 329: } 330: } 331: } 332: else 333: { 334: liberation(s_etat_processus, s_objet); 335: 336: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 337: return; 338: } 339: 340: liberation(s_etat_processus, s_objet); 341: } 342: else if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'W') 343: { 344: if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'W') 345: { 346: if ((*s_etat_processus).mode_execution_programme == 'Y') 347: { 348: (*s_etat_processus).position_courante = 349: (*(*s_etat_processus).l_base_pile_systeme) 350: .adresse_retour; 351: } 352: else 353: { 354: (*s_etat_processus).expression_courante = 355: (*(*s_etat_processus).l_base_pile_systeme) 356: .pointeur_objet_retour; 357: } 358: } 359: else 360: { 361: depilement_pile_systeme(s_etat_processus); 362: 363: if ((*s_etat_processus).erreur_systeme != d_es) 364: { 365: return; 366: } 367: } 368: } 369: else if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'C') 370: { 371: depilement_pile_systeme(s_etat_processus); 372: 373: if ((*s_etat_processus).erreur_systeme != d_es) 374: { 375: return; 376: } 377: } 378: else if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'K') 379: { 380: l_element_courant = (*(*s_etat_processus).l_base_pile_systeme).suivant; 381: 382: while(l_element_courant != NULL) 383: { 384: switch((*l_element_courant).clause) 385: { 386: case 'K' : 387: case 'Q' : 388: case 'C' : 389: { 390: if ((*l_element_courant).clause == 'Q') 391: { 392: (*l_element_courant).clause = 'C'; 393: } 394: else 395: { 396: (*l_element_courant).clause = (*(*s_etat_processus) 397: .l_base_pile_systeme).clause; 398: } 399: 400: l_element_courant = NULL; 401: break; 402: } 403: 404: default : 405: { 406: l_element_courant = (*l_element_courant).suivant; 407: break; 408: } 409: } 410: } 411: 412: depilement_pile_systeme(s_etat_processus); 413: 414: if ((*s_etat_processus).erreur_systeme != d_es) 415: { 416: return; 417: } 418: } 419: else 420: { 421: (*s_etat_processus).erreur_systeme = d_es_end_incoherent; 422: } 423: 424: return; 425: } 426: 427: 428: /* 429: ================================================================================ 430: Fonction 'else' 431: ================================================================================ 432: Entrées : structure processus 433: -------------------------------------------------------------------------------- 434: Sorties : 435: -------------------------------------------------------------------------------- 436: Effets de bord : néant 437: ================================================================================ 438: */ 439: 440: void 441: instruction_else(struct_processus *s_etat_processus) 442: { 443: logical1 drapeau_fin; 444: logical1 execution; 445: 446: struct_liste_chainee *s_registre; 447: 448: unsigned char *instruction_majuscule; 449: unsigned char *tampon; 450: 451: unsigned long niveau; 452: 453: void (*fonction)(); 454: 455: (*s_etat_processus).erreur_execution = d_ex; 456: 457: if ((*s_etat_processus).affichage_arguments == 'Y') 458: { 459: printf("\n ELSE "); 460: 461: if ((*s_etat_processus).langue == 'F') 462: { 463: printf("(structure de contrôle)\n\n"); 464: printf(" Utilisation :\n\n"); 465: } 466: else 467: { 468: printf("(control statement)\n\n"); 469: printf(" Usage:\n\n"); 470: } 471: 472: printf(" IF\n"); 473: printf(" (expression test 1)\n"); 474: printf(" THEN\n"); 475: printf(" (expression 1)\n"); 476: printf(" [ELSEIF\n"); 477: printf(" (expression test 2)\n"); 478: printf(" THEN\n"); 479: printf(" (expression 2)]\n"); 480: printf(" ...\n"); 481: printf(" ELSE\n"); 482: printf(" (expression n)\n"); 483: printf(" END\n"); 484: 485: return; 486: } 487: else if ((*s_etat_processus).test_instruction == 'Y') 488: { 489: (*s_etat_processus).nombre_arguments = -1; 490: return; 491: } 492: 493: if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'T') 494: { 495: niveau = 0; 496: drapeau_fin = d_faux; 497: 498: if ((*s_etat_processus).mode_execution_programme == 'Y') 499: { 500: tampon = (*s_etat_processus).instruction_courante; 501: 502: do 503: { 504: if (recherche_instruction_suivante(s_etat_processus) 505: == d_erreur) 506: { 507: if ((*s_etat_processus).instruction_courante != NULL) 508: { 509: free((*s_etat_processus).instruction_courante); 510: } 511: 512: (*s_etat_processus).instruction_courante = tampon; 513: (*s_etat_processus).erreur_execution = 514: d_ex_erreur_traitement_condition; 515: return; 516: } 517: 518: if ((instruction_majuscule = conversion_majuscule( 519: (*s_etat_processus).instruction_courante)) == NULL) 520: { 521: free((*s_etat_processus).instruction_courante); 522: (*s_etat_processus).instruction_courante = tampon; 523: (*s_etat_processus).erreur_systeme = 524: d_es_allocation_memoire; 525: return; 526: } 527: 528: if (niveau == 0) 529: { 530: if (strcmp(instruction_majuscule, "END") == 0) 531: { 532: (*s_etat_processus).position_courante -= (strlen( 533: instruction_majuscule) + 1); 534: drapeau_fin = d_vrai; 535: } 536: else 537: { 538: drapeau_fin = d_faux; 539: } 540: } 541: else 542: { 543: drapeau_fin = d_faux; 544: } 545: 546: if ((strcmp(instruction_majuscule, "CASE") == 0) || 547: (strcmp(instruction_majuscule, "DO") == 0) || 548: (strcmp(instruction_majuscule, "IF") == 0) || 549: (strcmp(instruction_majuscule, "IFERR") == 0) || 550: (strcmp(instruction_majuscule, "SELECT") == 0) || 551: (strcmp(instruction_majuscule, "WHILE") == 0)) 552: { 553: niveau++; 554: } 555: else if (strcmp(instruction_majuscule, "END") == 0) 556: { 557: niveau--; 558: } 559: 560: free(instruction_majuscule); 561: free((*s_etat_processus).instruction_courante); 562: } while(drapeau_fin == d_faux); 563: 564: (*s_etat_processus).instruction_courante = tampon; 565: } 566: else 567: { 568: /* 569: * Vérification du pointeur de prédiction de saut. 570: */ 571: 572: if (pthread_mutex_lock(&((*(*(*s_etat_processus) 573: .expression_courante).donnee).mutex)) != 0) 574: { 575: (*s_etat_processus).erreur_systeme = d_es_processus; 576: return; 577: } 578: 579: if ((*((struct_fonction *) (*(*(*s_etat_processus) 580: .expression_courante).donnee).objet)).prediction_saut 581: != NULL) 582: { 583: s_registre = (*s_etat_processus).expression_courante; 584: 585: (*s_etat_processus).expression_courante = 586: (struct_liste_chainee *) 587: (*((struct_fonction *) (*(*(*s_etat_processus) 588: .expression_courante).donnee).objet)) 589: .prediction_saut; 590: fonction = (*((struct_fonction *) 591: (*(*(*s_etat_processus).expression_courante) 592: .donnee).objet)).fonction; 593: execution = (*((struct_fonction *) 594: (*(*s_registre).donnee).objet)).prediction_execution; 595: 596: if (pthread_mutex_unlock(&((*(*s_registre).donnee).mutex)) != 0) 597: { 598: (*s_etat_processus).erreur_systeme = d_es_processus; 599: return; 600: } 601: 602: if (execution == d_vrai) 603: { 604: fonction(s_etat_processus); 605: } 606: } 607: else 608: { 609: if (pthread_mutex_unlock(&((*(*(*s_etat_processus) 610: .expression_courante).donnee).mutex)) != 0) 611: { 612: (*s_etat_processus).erreur_systeme = d_es_processus; 613: return; 614: } 615: 616: s_registre = (*s_etat_processus).expression_courante; 617: execution = d_faux; 618: 619: do 620: { 621: if (((*s_etat_processus).expression_courante = 622: (*(*s_etat_processus).expression_courante).suivant) 623: == NULL) 624: { 625: (*s_etat_processus).erreur_execution = 626: d_ex_erreur_traitement_condition; 627: return; 628: } 629: 630: if ((*(*(*s_etat_processus).expression_courante) 631: .donnee).type == FCT) 632: { 633: fonction = (*((struct_fonction *) 634: (*(*(*s_etat_processus).expression_courante) 635: .donnee).objet)).fonction; 636: 637: if (niveau == 0) 638: { 639: if (fonction == instruction_end) 640: { 641: fonction(s_etat_processus); 642: execution = d_vrai; 643: drapeau_fin = d_vrai; 644: } 645: else 646: { 647: drapeau_fin = d_faux; 648: } 649: } 650: else 651: { 652: drapeau_fin = d_faux; 653: } 654: 655: if ((fonction == instruction_case) || 656: (fonction == instruction_do) || 657: (fonction == instruction_if) || 658: (fonction == instruction_iferr) || 659: (fonction == instruction_select) || 660: (fonction == instruction_while)) 661: { 662: niveau++; 663: } 664: else if (fonction == instruction_end) 665: { 666: niveau--; 667: } 668: } 669: } while(drapeau_fin == d_faux); 670: 671: if (pthread_mutex_lock(&((*(*(*s_etat_processus) 672: .expression_courante).donnee).mutex)) != 0) 673: { 674: (*s_etat_processus).erreur_systeme = d_es_processus; 675: return; 676: } 677: 678: (*((struct_fonction *) (*(*s_registre).donnee).objet)) 679: .prediction_saut = (*s_etat_processus) 680: .expression_courante; 681: (*((struct_fonction *) (*(*s_registre).donnee).objet)) 682: .prediction_execution = execution; 683: 684: if (pthread_mutex_unlock(&((*(*(*s_etat_processus) 685: .expression_courante).donnee).mutex)) != 0) 686: { 687: (*s_etat_processus).erreur_systeme = d_es_processus; 688: return; 689: } 690: } 691: } 692: } 693: else if ((*(*s_etat_processus).l_base_pile_systeme).clause != 'E') 694: { 695: (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_condition; 696: return; 697: } 698: else 699: { 700: (*(*s_etat_processus).l_base_pile_systeme).clause = 'Z'; 701: } 702: 703: return; 704: } 705: 706: 707: /* 708: ================================================================================ 709: Fonction 'elseif' 710: ================================================================================ 711: Entrées : structure processus 712: -------------------------------------------------------------------------------- 713: Sorties : 714: -------------------------------------------------------------------------------- 715: Effets de bord : néant 716: ================================================================================ 717: */ 718: 719: void 720: instruction_elseif(struct_processus *s_etat_processus) 721: { 722: logical1 drapeau_fin; 723: logical1 execution; 724: 725: struct_liste_chainee *s_registre; 726: 727: unsigned char *instruction_majuscule; 728: unsigned char *tampon; 729: 730: unsigned long niveau; 731: 732: void (*fonction)(); 733: 734: (*s_etat_processus).erreur_execution = d_ex; 735: 736: if ((*s_etat_processus).affichage_arguments == 'Y') 737: { 738: printf("\n ELSEIF "); 739: 740: if ((*s_etat_processus).langue == 'F') 741: { 742: printf("(structure de contrôle)\n\n"); 743: printf(" Utilisation :\n\n"); 744: } 745: else 746: { 747: printf("(control statement)\n\n"); 748: printf(" Usage:\n\n"); 749: } 750: 751: printf(" IF\n"); 752: printf(" (expression test 1)\n"); 753: printf(" THEN\n"); 754: printf(" (expression 1)\n"); 755: printf(" ELSEIF\n"); 756: printf(" (expression test 2)\n"); 757: printf(" THEN\n"); 758: printf(" (expression 2)\n"); 759: printf(" ...\n"); 760: printf(" [ELSE\n"); 761: printf(" (expression n)]\n"); 762: printf(" END\n\n"); 763: 764: return; 765: } 766: else if ((*s_etat_processus).test_instruction == 'Y') 767: { 768: (*s_etat_processus).nombre_arguments = -1; 769: return; 770: } 771: 772: if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture != 'I') 773: { 774: (*s_etat_processus).erreur_execution = 775: d_ex_erreur_traitement_condition; 776: return; 777: } 778: 779: if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'T') 780: { 781: /* 782: * On saute au END car le test précédent était vrai. 783: */ 784: 785: niveau = 0; 786: drapeau_fin = d_faux; 787: 788: if ((*s_etat_processus).mode_execution_programme == 'Y') 789: { 790: tampon = (*s_etat_processus).instruction_courante; 791: 792: do 793: { 794: if (recherche_instruction_suivante(s_etat_processus) 795: == d_erreur) 796: { 797: if ((*s_etat_processus).instruction_courante != NULL) 798: { 799: free((*s_etat_processus).instruction_courante); 800: } 801: 802: (*s_etat_processus).instruction_courante = tampon; 803: (*s_etat_processus).erreur_execution = 804: d_ex_erreur_traitement_condition; 805: return; 806: } 807: 808: if ((instruction_majuscule = conversion_majuscule( 809: (*s_etat_processus).instruction_courante)) == NULL) 810: { 811: free((*s_etat_processus).instruction_courante); 812: (*s_etat_processus).instruction_courante = tampon; 813: (*s_etat_processus).erreur_systeme = 814: d_es_allocation_memoire; 815: return; 816: } 817: 818: if (niveau == 0) 819: { 820: if (strcmp(instruction_majuscule, "END") == 0) 821: { 822: (*s_etat_processus).position_courante -= (strlen( 823: instruction_majuscule) + 1); 824: drapeau_fin = d_vrai; 825: } 826: else 827: { 828: drapeau_fin = d_faux; 829: } 830: } 831: else 832: { 833: drapeau_fin = d_faux; 834: } 835: 836: if ((strcmp(instruction_majuscule, "CASE") == 0) || 837: (strcmp(instruction_majuscule, "DO") == 0) || 838: (strcmp(instruction_majuscule, "IF") == 0) || 839: (strcmp(instruction_majuscule, "IFERR") == 0) || 840: (strcmp(instruction_majuscule, "SELECT") == 0) || 841: (strcmp(instruction_majuscule, "WHILE") == 0)) 842: { 843: niveau++; 844: } 845: else if (strcmp(instruction_majuscule, "END") == 0) 846: { 847: niveau--; 848: } 849: 850: free(instruction_majuscule); 851: free((*s_etat_processus).instruction_courante); 852: } while(drapeau_fin == d_faux); 853: 854: (*s_etat_processus).instruction_courante = tampon; 855: } 856: else 857: { 858: /* 859: * Vérification du pointeur de prédiction de saut 860: */ 861: 862: if (pthread_mutex_lock(&((*(*(*s_etat_processus) 863: .expression_courante).donnee).mutex)) != 0) 864: { 865: (*s_etat_processus).erreur_systeme = d_es_processus; 866: return; 867: } 868: 869: if ((*((struct_fonction *) (*(*(*s_etat_processus) 870: .expression_courante).donnee).objet)).prediction_saut 871: != NULL) 872: { 873: s_registre = (*s_etat_processus).expression_courante; 874: 875: (*s_etat_processus).expression_courante = 876: (struct_liste_chainee *) 877: (*((struct_fonction *) (*(*(*s_etat_processus) 878: .expression_courante).donnee).objet)) 879: .prediction_saut; 880: fonction = (*((struct_fonction *) 881: (*(*(*s_etat_processus).expression_courante) 882: .donnee).objet)).fonction; 883: execution = (*((struct_fonction *) 884: (*(*s_registre).donnee).objet)).prediction_execution; 885: 886: if (pthread_mutex_unlock(&((*(*s_registre).donnee).mutex)) != 0) 887: { 888: (*s_etat_processus).erreur_systeme = d_es_processus; 889: return; 890: } 891: 892: if (execution == d_vrai) 893: { 894: fonction(s_etat_processus); 895: } 896: } 897: else 898: { 899: if (pthread_mutex_unlock(&((*(*(*s_etat_processus) 900: .expression_courante).donnee).mutex)) != 0) 901: { 902: (*s_etat_processus).erreur_systeme = d_es_processus; 903: return; 904: } 905: 906: s_registre = (*s_etat_processus).expression_courante; 907: execution = d_faux; 908: 909: do 910: { 911: if (((*s_etat_processus).expression_courante = 912: (*(*s_etat_processus).expression_courante).suivant) 913: == NULL) 914: { 915: (*s_etat_processus).erreur_execution = 916: d_ex_erreur_traitement_condition; 917: return; 918: } 919: 920: if ((*(*(*s_etat_processus).expression_courante) 921: .donnee).type == FCT) 922: { 923: fonction = (*((struct_fonction *) 924: (*(*(*s_etat_processus).expression_courante) 925: .donnee).objet)).fonction; 926: 927: if (niveau == 0) 928: { 929: if (fonction == instruction_end) 930: { 931: instruction_end(s_etat_processus); 932: execution = d_vrai; 933: drapeau_fin = d_vrai; 934: } 935: else 936: { 937: drapeau_fin = d_faux; 938: } 939: } 940: else 941: { 942: drapeau_fin = d_faux; 943: } 944: 945: if ((fonction == instruction_case) || 946: (fonction == instruction_do) || 947: (fonction == instruction_if) || 948: (fonction == instruction_iferr) || 949: (fonction == instruction_select) || 950: (fonction == instruction_while)) 951: { 952: niveau++; 953: } 954: else if (fonction == instruction_end) 955: { 956: niveau--; 957: } 958: } 959: } while(drapeau_fin == d_faux); 960: 961: if (pthread_mutex_lock(&((*(*(*s_etat_processus) 962: .expression_courante).donnee).mutex)) != 0) 963: { 964: (*s_etat_processus).erreur_systeme = d_es_processus; 965: return; 966: } 967: 968: (*((struct_fonction *) (*(*s_registre).donnee).objet)) 969: .prediction_saut = (*s_etat_processus) 970: .expression_courante; 971: (*((struct_fonction *) (*(*s_registre).donnee).objet)) 972: .prediction_execution = execution; 973: 974: if (pthread_mutex_unlock(&((*(*(*s_etat_processus) 975: .expression_courante).donnee).mutex)) != 0) 976: { 977: (*s_etat_processus).erreur_systeme = d_es_processus; 978: return; 979: } 980: } 981: } 982: } 983: else 984: { 985: /* 986: * On teste à nouveau... 987: */ 988: 989: (*(*s_etat_processus).l_base_pile_systeme).clause = 'I'; 990: } 991: 992: return; 993: } 994: 995: 996: /* 997: ================================================================================ 998: Fonction 'e' 999: ================================================================================ 1000: Entrées : structure processus 1001: -------------------------------------------------------------------------------- 1002: Sorties : 1003: -------------------------------------------------------------------------------- 1004: Effets de bord : néant 1005: ================================================================================ 1006: */ 1007: 1008: void 1009: instruction_sensible_e(struct_processus *s_etat_processus) 1010: { 1011: if (strcmp((*s_etat_processus).instruction_courante, "e") == 0) 1012: { 1013: instruction_e(s_etat_processus); 1014: } 1015: else 1016: { 1017: (*s_etat_processus).instruction_valide = 'N'; 1018: } 1019: 1020: return; 1021: } 1022: 1023: void 1024: instruction_e(struct_processus *s_etat_processus) 1025: { 1026: struct_objet *s_objet; 1027: 1028: (*s_etat_processus).erreur_execution = d_ex; 1029: 1030: if ((*s_etat_processus).affichage_arguments == 'Y') 1031: { 1032: printf("\n e "); 1033: 1034: if ((*s_etat_processus).langue == 'F') 1035: { 1036: printf("(base de logarithmes népériens)\n\n"); 1037: } 1038: else 1039: { 1040: printf("(base of natural logarithm)\n\n"); 1041: } 1042: 1043: printf("-> 1: %s\n", d_REL); 1044: 1045: return; 1046: } 1047: else if ((*s_etat_processus).test_instruction == 'Y') 1048: { 1049: (*s_etat_processus).constante_symbolique = 'Y'; 1050: (*s_etat_processus).nombre_arguments = -1; 1051: return; 1052: } 1053: 1054: /* Indicateur 35 armé => évaluation symbolique */ 1055: if (test_cfsf(s_etat_processus, 35) == d_vrai) 1056: { 1057: if ((s_objet = allocation(s_etat_processus, NOM)) == NULL) 1058: { 1059: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1060: return; 1061: } 1062: 1063: if (((*((struct_nom *) (*s_objet).objet)).nom = 1064: malloc(2 * sizeof(unsigned char))) == NULL) 1065: { 1066: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1067: return; 1068: } 1069: 1070: strcpy((*((struct_nom *) (*s_objet).objet)).nom, "e"); 1071: (*((struct_nom *) (*s_objet).objet)).symbole = d_faux; 1072: } 1073: else 1074: { 1075: if ((s_objet = allocation(s_etat_processus, REL)) == NULL) 1076: { 1077: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1078: return; 1079: } 1080: 1081: (*((real8 *) (*s_objet).objet)) = exp((real8) 1); 1082: } 1083: 1084: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1085: s_objet) == d_erreur) 1086: { 1087: return; 1088: } 1089: 1090: return; 1091: } 1092: 1093: 1094: /* 1095: ================================================================================ 1096: Fonction 'eng' 1097: ================================================================================ 1098: Entrées : pointeur sur une struct_processus 1099: -------------------------------------------------------------------------------- 1100: Sorties : 1101: -------------------------------------------------------------------------------- 1102: Effets de bord : néant 1103: ================================================================================ 1104: */ 1105: 1106: void 1107: instruction_eng(struct_processus *s_etat_processus) 1108: { 1109: struct_objet *s_objet_argument; 1110: struct_objet *s_objet; 1111: 1112: logical1 i43; 1113: logical1 i44; 1114: 1115: unsigned char *valeur_binaire; 1116: 1117: unsigned long i; 1118: unsigned long j; 1119: 1120: (*s_etat_processus).erreur_execution = d_ex; 1121: 1122: if ((*s_etat_processus).affichage_arguments == 'Y') 1123: { 1124: printf("\n ENG "); 1125: 1126: if ((*s_etat_processus).langue == 'F') 1127: { 1128: printf("(notation ingénieur)\n\n"); 1129: printf(" Aucun argument\n"); 1130: } 1131: else 1132: { 1133: printf("(engineer notation)\n\n"); 1134: printf(" No argument\n"); 1135: } 1136: 1137: return; 1138: } 1139: else if ((*s_etat_processus).test_instruction == 'Y') 1140: { 1141: (*s_etat_processus).nombre_arguments = -1; 1142: return; 1143: } 1144: 1145: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1146: { 1147: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1148: { 1149: return; 1150: } 1151: } 1152: 1153: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1154: &s_objet_argument) == d_erreur) 1155: { 1156: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1157: return; 1158: } 1159: 1160: if ((*s_objet_argument).type == INT) 1161: { 1162: if (((*((integer8 *) (*s_objet_argument).objet)) >= 0) && 1163: ((*((integer8 *) (*s_objet_argument).objet)) <= 15)) 1164: { 1165: if ((s_objet = allocation(s_etat_processus, BIN)) == NULL) 1166: { 1167: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1168: return; 1169: } 1170: 1171: (*((logical8 *) (*s_objet).objet)) = 1172: (*((integer8 *) (*s_objet_argument).objet)); 1173: 1174: i43 = test_cfsf(s_etat_processus, 43); 1175: i44 = test_cfsf(s_etat_processus, 44); 1176: 1177: sf(s_etat_processus, 44); 1178: cf(s_etat_processus, 43); 1179: 1180: if ((valeur_binaire = formateur(s_etat_processus, 0, s_objet)) 1181: == NULL) 1182: { 1183: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1184: return; 1185: } 1186: 1187: if (i43 == d_vrai) 1188: { 1189: sf(s_etat_processus, 43); 1190: } 1191: else 1192: { 1193: cf(s_etat_processus, 43); 1194: } 1195: 1196: if (i44 == d_vrai) 1197: { 1198: sf(s_etat_processus, 44); 1199: } 1200: else 1201: { 1202: cf(s_etat_processus, 44); 1203: } 1204: 1205: for(j = 53, i = strlen(valeur_binaire) - 2; i >= 2; i--) 1206: { 1207: if (valeur_binaire[i] == '0') 1208: { 1209: cf(s_etat_processus, j++); 1210: } 1211: else 1212: { 1213: sf(s_etat_processus, j++); 1214: } 1215: } 1216: 1217: for(; j <= 56; cf(s_etat_processus, j++)); 1218: 1219: sf(s_etat_processus, 49); 1220: sf(s_etat_processus, 50); 1221: 1222: free(valeur_binaire); 1223: liberation(s_etat_processus, s_objet); 1224: } 1225: else 1226: { 1227: liberation(s_etat_processus, s_objet_argument); 1228: 1229: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1230: return; 1231: } 1232: } 1233: else 1234: { 1235: liberation(s_etat_processus, s_objet_argument); 1236: 1237: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1238: return; 1239: } 1240: 1241: liberation(s_etat_processus, s_objet_argument); 1242: 1243: return; 1244: } 1245: 1246: 1247: /* 1248: ================================================================================ 1249: Fonction 'exp' 1250: ================================================================================ 1251: Entrées : pointeur sur une struct_processus 1252: -------------------------------------------------------------------------------- 1253: Sorties : 1254: -------------------------------------------------------------------------------- 1255: Effets de bord : néant 1256: ================================================================================ 1257: */ 1258: 1259: void 1260: instruction_exp(struct_processus *s_etat_processus) 1261: { 1262: struct_liste_chainee *l_element_courant; 1263: struct_liste_chainee *l_element_precedent; 1264: 1265: struct_objet *s_copie_argument; 1266: struct_objet *s_objet_argument; 1267: struct_objet *s_objet_resultat; 1268: 1269: (*s_etat_processus).erreur_execution = d_ex; 1270: 1271: if ((*s_etat_processus).affichage_arguments == 'Y') 1272: { 1273: printf("\n EXP "); 1274: 1275: if ((*s_etat_processus).langue == 'F') 1276: { 1277: printf("(exponentielle)\n\n"); 1278: } 1279: else 1280: { 1281: printf("(exponential)\n\n"); 1282: } 1283: 1284: printf(" 1: %s, %s\n", d_INT, d_REL); 1285: printf("-> 1: %s\n\n", d_REL); 1286: 1287: printf(" 1: %s\n", d_CPL); 1288: printf("-> 1: %s\n\n", d_CPL); 1289: 1290: printf(" 1: %s, %s\n", d_NOM, d_ALG); 1291: printf("-> 1: %s\n\n", d_ALG); 1292: 1293: printf(" 1: %s\n", d_RPN); 1294: printf("-> 1: %s\n", d_RPN); 1295: 1296: return; 1297: } 1298: else if ((*s_etat_processus).test_instruction == 'Y') 1299: { 1300: (*s_etat_processus).nombre_arguments = 1; 1301: return; 1302: } 1303: 1304: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1305: { 1306: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1307: { 1308: return; 1309: } 1310: } 1311: 1312: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1313: &s_objet_argument) == d_erreur) 1314: { 1315: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1316: return; 1317: } 1318: 1319: /* 1320: -------------------------------------------------------------------------------- 1321: Exponentielle d'un entier 1322: -------------------------------------------------------------------------------- 1323: */ 1324: 1325: if ((*s_objet_argument).type == INT) 1326: { 1327: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) 1328: { 1329: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1330: return; 1331: } 1332: 1333: (*((real8 *) (*s_objet_resultat).objet)) = 1334: exp((real8) (*((integer8 *) (*s_objet_argument).objet))); 1335: } 1336: 1337: /* 1338: -------------------------------------------------------------------------------- 1339: Exponentielle d'un réel 1340: -------------------------------------------------------------------------------- 1341: */ 1342: 1343: else if ((*s_objet_argument).type == REL) 1344: { 1345: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) 1346: { 1347: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1348: return; 1349: } 1350: 1351: (*((real8 *) (*s_objet_resultat).objet)) = 1352: exp(((*((real8 *) (*s_objet_argument).objet)))); 1353: } 1354: 1355: /* 1356: -------------------------------------------------------------------------------- 1357: Exponentielle d'un complexe 1358: -------------------------------------------------------------------------------- 1359: */ 1360: 1361: else if ((*s_objet_argument).type == CPL) 1362: { 1363: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) 1364: { 1365: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1366: return; 1367: } 1368: 1369: f77expc_((struct_complexe16 *) (*s_objet_argument).objet, 1370: (struct_complexe16 *) (*s_objet_resultat).objet); 1371: } 1372: 1373: /* 1374: -------------------------------------------------------------------------------- 1375: Exponentielle d'un nom 1376: -------------------------------------------------------------------------------- 1377: */ 1378: 1379: else if ((*s_objet_argument).type == NOM) 1380: { 1381: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL) 1382: { 1383: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1384: return; 1385: } 1386: 1387: if (((*s_objet_resultat).objet = 1388: allocation_maillon(s_etat_processus)) == NULL) 1389: { 1390: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1391: return; 1392: } 1393: 1394: l_element_courant = (*s_objet_resultat).objet; 1395: 1396: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1397: == NULL) 1398: { 1399: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1400: return; 1401: } 1402: 1403: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1404: .nombre_arguments = 0; 1405: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1406: .fonction = instruction_vers_niveau_superieur; 1407: 1408: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1409: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 1410: { 1411: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1412: return; 1413: } 1414: 1415: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1416: .nom_fonction, "<<"); 1417: 1418: if (((*l_element_courant).suivant = 1419: allocation_maillon(s_etat_processus)) == NULL) 1420: { 1421: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1422: return; 1423: } 1424: 1425: l_element_courant = (*l_element_courant).suivant; 1426: (*l_element_courant).donnee = s_objet_argument; 1427: 1428: if (((*l_element_courant).suivant = 1429: allocation_maillon(s_etat_processus)) == NULL) 1430: { 1431: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1432: return; 1433: } 1434: 1435: l_element_courant = (*l_element_courant).suivant; 1436: 1437: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1438: == NULL) 1439: { 1440: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1441: return; 1442: } 1443: 1444: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1445: .nombre_arguments = 1; 1446: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1447: .fonction = instruction_exp; 1448: 1449: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1450: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) 1451: { 1452: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1453: return; 1454: } 1455: 1456: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1457: .nom_fonction, "EXP"); 1458: 1459: if (((*l_element_courant).suivant = 1460: allocation_maillon(s_etat_processus)) == NULL) 1461: { 1462: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1463: return; 1464: } 1465: 1466: l_element_courant = (*l_element_courant).suivant; 1467: 1468: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1469: == NULL) 1470: { 1471: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1472: return; 1473: } 1474: 1475: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1476: .nombre_arguments = 0; 1477: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1478: .fonction = instruction_vers_niveau_inferieur; 1479: 1480: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1481: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 1482: { 1483: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1484: return; 1485: } 1486: 1487: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1488: .nom_fonction, ">>"); 1489: 1490: (*l_element_courant).suivant = NULL; 1491: s_objet_argument = NULL; 1492: } 1493: 1494: /* 1495: -------------------------------------------------------------------------------- 1496: Exponentielle d'une expression 1497: -------------------------------------------------------------------------------- 1498: */ 1499: 1500: else if (((*s_objet_argument).type == ALG) || 1501: ((*s_objet_argument).type == RPN)) 1502: { 1503: if ((s_copie_argument = copie_objet(s_etat_processus, 1504: s_objet_argument, 'N')) == NULL) 1505: { 1506: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1507: return; 1508: } 1509: 1510: l_element_courant = (struct_liste_chainee *) 1511: (*s_copie_argument).objet; 1512: l_element_precedent = l_element_courant; 1513: 1514: while((*l_element_courant).suivant != NULL) 1515: { 1516: l_element_precedent = l_element_courant; 1517: l_element_courant = (*l_element_courant).suivant; 1518: } 1519: 1520: if (((*l_element_precedent).suivant = 1521: allocation_maillon(s_etat_processus)) == NULL) 1522: { 1523: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1524: return; 1525: } 1526: 1527: if (((*(*l_element_precedent).suivant).donnee = 1528: allocation(s_etat_processus, FCT)) == NULL) 1529: { 1530: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1531: return; 1532: } 1533: 1534: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1535: .donnee).objet)).nombre_arguments = 1; 1536: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1537: .donnee).objet)).fonction = instruction_exp; 1538: 1539: if (((*((struct_fonction *) (*(*(*l_element_precedent) 1540: .suivant).donnee).objet)).nom_fonction = 1541: malloc(4 * sizeof(unsigned char))) == NULL) 1542: { 1543: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1544: return; 1545: } 1546: 1547: strcpy((*((struct_fonction *) (*(*(*l_element_precedent) 1548: .suivant).donnee).objet)).nom_fonction, "EXP"); 1549: 1550: (*(*l_element_precedent).suivant).suivant = l_element_courant; 1551: 1552: s_objet_resultat = s_copie_argument; 1553: } 1554: 1555: /* 1556: -------------------------------------------------------------------------------- 1557: Fonction exponentielle impossible à réaliser 1558: -------------------------------------------------------------------------------- 1559: */ 1560: 1561: else 1562: { 1563: liberation(s_etat_processus, s_objet_argument); 1564: 1565: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1566: return; 1567: } 1568: 1569: liberation(s_etat_processus, s_objet_argument); 1570: 1571: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1572: s_objet_resultat) == d_erreur) 1573: { 1574: return; 1575: } 1576: 1577: return; 1578: } 1579: 1580: 1581: /* 1582: ================================================================================ 1583: Fonction 'exp' (-1) 1584: ================================================================================ 1585: Entrées : pointeur sur une struct_processus 1586: -------------------------------------------------------------------------------- 1587: Sorties : 1588: -------------------------------------------------------------------------------- 1589: Effets de bord : néant 1590: ================================================================================ 1591: */ 1592: 1593: void 1594: instruction_expm(struct_processus *s_etat_processus) 1595: { 1596: struct_liste_chainee *l_element_courant; 1597: struct_liste_chainee *l_element_precedent; 1598: 1599: struct_objet *s_copie_argument; 1600: struct_objet *s_objet_argument; 1601: struct_objet *s_objet_resultat; 1602: 1603: (*s_etat_processus).erreur_execution = d_ex; 1604: 1605: if ((*s_etat_processus).affichage_arguments == 'Y') 1606: { 1607: printf("\n EXPM "); 1608: 1609: if ((*s_etat_processus).langue == 'F') 1610: { 1611: printf("(exponentielle moins un)\n\n"); 1612: } 1613: else 1614: { 1615: printf("(exp - 1)\n\n"); 1616: } 1617: 1618: printf(" 1: %s, %s\n", d_INT, d_REL); 1619: printf("-> 1: %s\n\n", d_REL); 1620: 1621: printf(" 1: %s\n", d_CPL); 1622: printf("-> 1: %s\n\n", d_CPL); 1623: 1624: printf(" 1: %s, %s\n", d_NOM, d_ALG); 1625: printf("-> 1: %s\n\n", d_ALG); 1626: 1627: printf(" 1: %s\n", d_RPN); 1628: printf("-> 1: %s\n", d_RPN); 1629: 1630: return; 1631: } 1632: else if ((*s_etat_processus).test_instruction == 'Y') 1633: { 1634: (*s_etat_processus).nombre_arguments = 1; 1635: return; 1636: } 1637: 1638: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1639: { 1640: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1641: { 1642: return; 1643: } 1644: } 1645: 1646: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1647: &s_objet_argument) == d_erreur) 1648: { 1649: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1650: return; 1651: } 1652: 1653: /* 1654: -------------------------------------------------------------------------------- 1655: Exponentielle (-1) d'un entier 1656: -------------------------------------------------------------------------------- 1657: */ 1658: 1659: if ((*s_objet_argument).type == INT) 1660: { 1661: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) 1662: { 1663: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1664: return; 1665: } 1666: 1667: (*((real8 *) (*s_objet_resultat).objet)) = 1668: expm1((real8) (*((integer8 *) (*s_objet_argument).objet))); 1669: } 1670: 1671: /* 1672: -------------------------------------------------------------------------------- 1673: Exponentielle (-1) d'un réel 1674: -------------------------------------------------------------------------------- 1675: */ 1676: 1677: else if ((*s_objet_argument).type == REL) 1678: { 1679: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) 1680: { 1681: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1682: return; 1683: } 1684: 1685: (*((real8 *) (*s_objet_resultat).objet)) = 1686: expm1(((*((real8 *) (*s_objet_argument).objet)))); 1687: } 1688: 1689: /* 1690: -------------------------------------------------------------------------------- 1691: Exponentielle (-1) d'un nom 1692: -------------------------------------------------------------------------------- 1693: */ 1694: 1695: else if ((*s_objet_argument).type == NOM) 1696: { 1697: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL) 1698: { 1699: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1700: return; 1701: } 1702: 1703: if (((*s_objet_resultat).objet = 1704: allocation_maillon(s_etat_processus)) == NULL) 1705: { 1706: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1707: return; 1708: } 1709: 1710: l_element_courant = (*s_objet_resultat).objet; 1711: 1712: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1713: == NULL) 1714: { 1715: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1716: return; 1717: } 1718: 1719: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1720: .nombre_arguments = 0; 1721: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1722: .fonction = instruction_vers_niveau_superieur; 1723: 1724: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1725: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 1726: { 1727: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1728: return; 1729: } 1730: 1731: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1732: .nom_fonction, "<<"); 1733: 1734: if (((*l_element_courant).suivant = 1735: allocation_maillon(s_etat_processus)) == NULL) 1736: { 1737: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1738: return; 1739: } 1740: 1741: l_element_courant = (*l_element_courant).suivant; 1742: (*l_element_courant).donnee = s_objet_argument; 1743: 1744: if (((*l_element_courant).suivant = 1745: allocation_maillon(s_etat_processus)) == NULL) 1746: { 1747: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1748: return; 1749: } 1750: 1751: l_element_courant = (*l_element_courant).suivant; 1752: 1753: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1754: == NULL) 1755: { 1756: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1757: return; 1758: } 1759: 1760: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1761: .nombre_arguments = 1; 1762: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1763: .fonction = instruction_expm; 1764: 1765: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1766: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) 1767: { 1768: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1769: return; 1770: } 1771: 1772: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1773: .nom_fonction, "EXPM"); 1774: 1775: if (((*l_element_courant).suivant = 1776: allocation_maillon(s_etat_processus)) == NULL) 1777: { 1778: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1779: return; 1780: } 1781: 1782: l_element_courant = (*l_element_courant).suivant; 1783: 1784: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1785: == NULL) 1786: { 1787: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1788: return; 1789: } 1790: 1791: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1792: .nombre_arguments = 0; 1793: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1794: .fonction = instruction_vers_niveau_inferieur; 1795: 1796: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1797: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 1798: { 1799: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1800: return; 1801: } 1802: 1803: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1804: .nom_fonction, ">>"); 1805: 1806: (*l_element_courant).suivant = NULL; 1807: s_objet_argument = NULL; 1808: } 1809: 1810: /* 1811: -------------------------------------------------------------------------------- 1812: Exponentielle (-1) d'une expression 1813: -------------------------------------------------------------------------------- 1814: */ 1815: 1816: else if (((*s_objet_argument).type == ALG) || 1817: ((*s_objet_argument).type == RPN)) 1818: { 1819: if ((s_copie_argument = copie_objet(s_etat_processus, 1820: s_objet_argument, 'N')) == NULL) 1821: { 1822: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1823: return; 1824: } 1825: 1826: l_element_courant = (struct_liste_chainee *) 1827: (*s_copie_argument).objet; 1828: l_element_precedent = l_element_courant; 1829: 1830: while((*l_element_courant).suivant != NULL) 1831: { 1832: l_element_precedent = l_element_courant; 1833: l_element_courant = (*l_element_courant).suivant; 1834: } 1835: 1836: if (((*l_element_precedent).suivant = 1837: allocation_maillon(s_etat_processus)) == NULL) 1838: { 1839: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1840: return; 1841: } 1842: 1843: if (((*(*l_element_precedent).suivant).donnee = 1844: allocation(s_etat_processus, FCT)) == NULL) 1845: { 1846: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1847: return; 1848: } 1849: 1850: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1851: .donnee).objet)).nombre_arguments = 1; 1852: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1853: .donnee).objet)).fonction = instruction_expm; 1854: 1855: if (((*((struct_fonction *) (*(*(*l_element_precedent) 1856: .suivant).donnee).objet)).nom_fonction = 1857: malloc(5 * sizeof(unsigned char))) == NULL) 1858: { 1859: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1860: return; 1861: } 1862: 1863: strcpy((*((struct_fonction *) (*(*(*l_element_precedent) 1864: .suivant).donnee).objet)).nom_fonction, "EXPM"); 1865: 1866: (*(*l_element_precedent).suivant).suivant = l_element_courant; 1867: 1868: s_objet_resultat = s_copie_argument; 1869: } 1870: 1871: /* 1872: -------------------------------------------------------------------------------- 1873: Fonction exponentielle (-1) impossible à réaliser 1874: -------------------------------------------------------------------------------- 1875: */ 1876: 1877: else 1878: { 1879: liberation(s_etat_processus, s_objet_argument); 1880: 1881: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1882: return; 1883: } 1884: 1885: liberation(s_etat_processus, s_objet_argument); 1886: 1887: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1888: s_objet_resultat) == d_erreur) 1889: { 1890: return; 1891: } 1892: 1893: return; 1894: } 1895: 1896: // vim: ts=4