![]() ![]() | ![]() |
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 'type' 29: ================================================================================ 30: Entrées : structure processus 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_type(struct_processus *s_etat_processus) 40: { 41: struct_objet *s_objet_argument; 42: struct_objet *s_objet_resultat; 43: 44: (*s_etat_processus).erreur_execution = d_ex; 45: 46: if ((*s_etat_processus).affichage_arguments == 'Y') 47: { 48: printf("\n TYPE "); 49: 50: if ((*s_etat_processus).langue == 'F') 51: { 52: printf("(type d'objet)\n\n"); 53: } 54: else 55: { 56: printf("(object type)\n\n"); 57: } 58: 59: printf(" 1: %s, %s, %s, %s, %s, %s,\n" 60: " %s, %s, %s, %s, %s,\n" 61: " %s, %s, %s, %s, %s,\n" 62: " %s, %s, %s, %s\n", 63: d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX, 64: d_TAB, 65: d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SLB, d_SCK, 66: d_PRC); 67: printf("-> 1: %s\n\n", d_INT); 68: 69: if ((*s_etat_processus).langue == 'F') 70: { 71: printf(" Valeurs renvoyées : \n\n"); 72: printf(" 0 : scalaire (entier ou réel)\n"); 73: printf(" 1 : complexe\n"); 74: printf(" 2 : chaîne de caractères\n"); 75: printf(" 3 : vecteur ou matrice de scalaires\n"); 76: printf(" 4 : vecteur ou matrice de complexes\n"); 77: printf(" 5 : liste\n"); 78: printf(" 6 : adresse\n"); 79: printf(" 7 : nom\n"); 80: printf(" 8 : expression en notation polonaire inversée\n"); 81: printf(" 9 : expression algébrique\n"); 82: printf(" 10 : entier binaire\n"); 83: printf(" 11 : descripteur de fichier\n"); 84: printf(" 12 : descripteur de bibliothèque partagée\n"); 85: printf(" 13 : descripteur de socket\n"); 86: printf(" 14 : processus\n"); 87: printf(" 15 : fonction\n"); 88: printf(" 16 : table\n"); 89: } 90: else 91: { 92: printf(" Returned values : \n\n"); 93: printf(" 0 : scalar, integer or real number\n"); 94: printf(" 1 : complex\n"); 95: printf(" 2 : string\n"); 96: printf(" 3 : scalar vector or scalar matrix\n"); 97: printf(" 4 : complex vector or complex matrix\n"); 98: printf(" 5 : list\n"); 99: printf(" 6 : address\n"); 100: printf(" 7 : name\n"); 101: printf(" 8 : RPN expression\n"); 102: printf(" 9 : algebraic expression\n"); 103: printf(" 10 : binary integer\n"); 104: printf(" 11 : file descriptor\n"); 105: printf(" 12 : shared library descriptor\n"); 106: printf(" 13 : socket descriptor\n"); 107: printf(" 14 : process\n"); 108: printf(" 15 : function\n"); 109: printf(" 16 : table\n"); 110: } 111: 112: return; 113: } 114: else if ((*s_etat_processus).test_instruction == 'Y') 115: { 116: (*s_etat_processus).nombre_arguments = -1; 117: return; 118: } 119: 120: if (test_cfsf(s_etat_processus, 31) == d_vrai) 121: { 122: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 123: { 124: return; 125: } 126: } 127: 128: if (depilement(s_etat_processus, &((*s_etat_processus) 129: .l_base_pile), &s_objet_argument) == d_erreur) 130: { 131: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 132: return; 133: } 134: 135: if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL) 136: { 137: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 138: return; 139: } 140: 141: if (((*s_objet_argument).type == INT) || 142: ((*s_objet_argument).type == REL)) 143: { 144: (*((integer8 *) (*s_objet_resultat).objet)) = 0; 145: } 146: else if ((*s_objet_argument).type == CPL) 147: { 148: (*((integer8 *) (*s_objet_resultat).objet)) = 1; 149: } 150: else if ((*s_objet_argument).type == CHN) 151: { 152: (*((integer8 *) (*s_objet_resultat).objet)) = 2; 153: } 154: else if (((*s_objet_argument).type == VIN) || 155: ((*s_objet_argument).type == VRL) || 156: ((*s_objet_argument).type == MIN) || 157: ((*s_objet_argument).type == MRL)) 158: { 159: (*((integer8 *) (*s_objet_resultat).objet)) = 3; 160: } 161: else if (((*s_objet_argument).type == VCX) || 162: ((*s_objet_argument).type == MCX)) 163: { 164: (*((integer8 *) (*s_objet_resultat).objet)) = 4; 165: } 166: else if ((*s_objet_argument).type == LST) 167: { 168: (*((integer8 *) (*s_objet_resultat).objet)) = 5; 169: } 170: else if ((*s_objet_argument).type == ADR) 171: { 172: (*((integer8 *) (*s_objet_resultat).objet)) = 6; 173: } 174: else if ((*s_objet_argument).type == NOM) 175: { 176: (*((integer8 *) (*s_objet_resultat).objet)) = 7; 177: } 178: else if ((*s_objet_argument).type == RPN) 179: { 180: (*((integer8 *) (*s_objet_resultat).objet)) = 8; 181: } 182: else if ((*s_objet_argument).type == ALG) 183: { 184: (*((integer8 *) (*s_objet_resultat).objet)) = 9; 185: } 186: else if ((*s_objet_argument).type == BIN) 187: { 188: (*((integer8 *) (*s_objet_resultat).objet)) = 10; 189: } 190: else if ((*s_objet_argument).type == FCH) 191: { 192: (*((integer8 *) (*s_objet_resultat).objet)) = 11; 193: } 194: else if ((*s_objet_argument).type == SLB) 195: { 196: (*((integer8 *) (*s_objet_resultat).objet)) = 12; 197: } 198: else if ((*s_objet_argument).type == SCK) 199: { 200: (*((integer8 *) (*s_objet_resultat).objet)) = 13; 201: } 202: else if ((*s_objet_argument).type == PRC) 203: { 204: (*((integer8 *) (*s_objet_resultat).objet)) = 14; 205: } 206: else if ((*s_objet_argument).type == FCT) 207: { 208: (*((integer8 *) (*s_objet_resultat).objet)) = 15; 209: } 210: else if ((*s_objet_argument).type == TBL) 211: { 212: (*((integer8 *) (*s_objet_resultat).objet)) = 16; 213: } 214: else 215: { 216: /* 217: * Les autres types de données sont des types internes 218: */ 219: 220: liberation(s_etat_processus, s_objet_argument); 221: 222: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 223: return; 224: } 225: 226: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 227: s_objet_resultat) == d_erreur) 228: { 229: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 230: return; 231: } 232: 233: liberation(s_etat_processus, s_objet_argument); 234: 235: return; 236: } 237: 238: 239: /* 240: ================================================================================ 241: Fonction 'then' 242: ================================================================================ 243: Entrées : structure processus 244: -------------------------------------------------------------------------------- 245: Sorties : 246: -------------------------------------------------------------------------------- 247: Effets de bord : néant 248: ================================================================================ 249: */ 250: 251: void 252: instruction_then(struct_processus *s_etat_processus) 253: { 254: logical1 condition; 255: logical1 drapeau_fin; 256: logical1 execution; 257: 258: struct_liste_chainee *s_registre; 259: 260: struct_liste_pile_systeme *l_element_courant; 261: 262: struct_objet *s_objet; 263: 264: unsigned char *instruction_majuscule; 265: unsigned char *tampon; 266: 267: unsigned long niveau; 268: 269: void (*fonction)(); 270: 271: (*s_etat_processus).erreur_execution = d_ex; 272: 273: if ((*s_etat_processus).affichage_arguments == 'Y') 274: { 275: printf("\n THEN "); 276: 277: if ((*s_etat_processus).langue == 'F') 278: { 279: printf("(structure de contrôle)\n\n"); 280: printf(" Utilisation :\n\n"); 281: } 282: else 283: { 284: printf("(control statement)\n\n"); 285: printf(" Usage:\n\n"); 286: } 287: 288: printf(" IF(ERR)\n"); 289: printf(" (expression test 1)\n"); 290: printf(" THEN\n"); 291: printf(" (expression 1)\n"); 292: printf(" [ELSEIF\n"); 293: printf(" (expression test 2)\n"); 294: printf(" THEN\n"); 295: printf(" (expression 2)]\n"); 296: printf(" ...\n"); 297: printf(" [ELSE\n"); 298: printf(" (expression n)]\n"); 299: printf(" END\n\n"); 300: 301: printf(" SELECT (expression test)\n"); 302: printf(" CASE (clause 1) THEN (expression 1) END\n"); 303: printf(" CASE (clause 2) THEN (expression 2) END\n"); 304: printf(" ...\n"); 305: printf(" CASE (clause n) THEN (expression n) END\n"); 306: printf(" DEFAULT\n"); 307: printf(" (expression)\n"); 308: printf(" END\n\n"); 309: 310: printf(" SELECT (expression test)\n"); 311: printf(" CASE (clause 1) THEN (expression 1) END\n"); 312: printf(" (expression)\n"); 313: printf(" CASE (clause 2) THEN (expression 2) END\n"); 314: printf(" END\n"); 315: 316: return; 317: } 318: else if ((*s_etat_processus).test_instruction == 'Y') 319: { 320: (*s_etat_processus).nombre_arguments = -1; 321: return; 322: } 323: 324: if (((*(*s_etat_processus).l_base_pile_systeme).clause != 'I') && 325: ((*(*s_etat_processus).l_base_pile_systeme).clause != 'T') && 326: ((*(*s_etat_processus).l_base_pile_systeme).clause != 'R') && 327: ((*(*s_etat_processus).l_base_pile_systeme).clause != 'X') && 328: ((*(*s_etat_processus).l_base_pile_systeme).clause != 'C') && 329: ((*(*s_etat_processus).l_base_pile_systeme).clause != 'K')) 330: { 331: (*s_etat_processus).erreur_execution = d_ex_erreur_traitement_condition; 332: return; 333: } 334: 335: /* 336: * Traitement des erreurs 337: */ 338: 339: if (((*(*s_etat_processus).l_base_pile_systeme).clause == 'R') || 340: ((*(*s_etat_processus).l_base_pile_systeme).clause == 'X')) 341: { 342: if ((s_objet = allocation(s_etat_processus, INT)) == NULL) 343: { 344: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 345: return; 346: } 347: 348: if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'R') 349: { 350: 351: /* 352: * Erreur à traiter : on saute jusques au ELSE ou au END 353: * correspondant. 354: */ 355: 356: (*((integer8 *) (*s_objet).objet)) = 0; 357: } 358: else 359: { 360: (*((integer8 *) (*s_objet).objet)) = -1; 361: } 362: 363: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 364: s_objet) == d_erreur) 365: { 366: return; 367: } 368: 369: (*s_etat_processus).arret_si_exception = (*(*s_etat_processus) 370: .l_base_pile_systeme).arret_si_exception; 371: } 372: 373: /* 374: * Traitement standard de l'instruction 'THEN' 375: */ 376: 377: if (test_cfsf(s_etat_processus, 31) == d_vrai) 378: { 379: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 380: { 381: return; 382: } 383: } 384: 385: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 386: &s_objet) == d_erreur) 387: { 388: return; 389: } 390: 391: if (((*s_objet).type == INT) || ((*s_objet).type == REL)) 392: { 393: if ((*s_objet).type == INT) 394: { 395: condition = ((*((integer8 *) (*s_objet).objet)) == 0) 396: ? d_faux : d_vrai; 397: } 398: else 399: { 400: condition = ((*((real8 *) (*s_objet).objet)) == 0) 401: ? d_faux : d_vrai; 402: } 403: 404: if (condition == d_vrai) 405: { 406: 407: /* 408: * condition == d_vrai : exécution de ce qui se trouve entre 409: * THEN et ELSE ou END. 410: */ 411: 412: if (((*(*s_etat_processus).l_base_pile_systeme).clause == 413: 'I') || ((*(*s_etat_processus).l_base_pile_systeme).clause 414: == 'X')) 415: { 416: (*(*s_etat_processus).l_base_pile_systeme).clause = 'T'; 417: } 418: else 419: { 420: if ((*s_etat_processus).l_base_pile_systeme == NULL) 421: { 422: (*s_etat_processus).erreur_systeme = d_es_pile_vide; 423: return; 424: } 425: 426: l_element_courant = (*(*s_etat_processus).l_base_pile_systeme) 427: .suivant; 428: 429: while(l_element_courant != NULL) 430: { 431: if ((*l_element_courant).clause == 'K') 432: { 433: (*l_element_courant).clause = 'Q'; 434: break; 435: } 436: 437: l_element_courant = (*l_element_courant).suivant; 438: } 439: } 440: } 441: else 442: { 443: /* 444: * condition == d_faux : saut à END ou exécution de ce qui se 445: * trouve entre ELSE et END 446: */ 447: 448: if ((*(*s_etat_processus).l_base_pile_systeme).clause != 'T') 449: { 450: /* 451: * Traitement de ELSEIF 452: */ 453: 454: if (((*(*s_etat_processus).l_base_pile_systeme).clause != 455: 'K') && ((*(*s_etat_processus).l_base_pile_systeme) 456: .clause != 'C')) 457: { 458: (*(*s_etat_processus).l_base_pile_systeme).clause = 'E'; 459: } 460: } 461: 462: niveau = 0; 463: drapeau_fin = d_faux; 464: 465: if ((*s_etat_processus).mode_execution_programme == 'Y') 466: { 467: tampon = (*s_etat_processus).instruction_courante; 468: 469: do 470: { 471: if (recherche_instruction_suivante(s_etat_processus) 472: == d_erreur) 473: { 474: liberation(s_etat_processus, s_objet); 475: 476: if ((*s_etat_processus).instruction_courante != NULL) 477: { 478: free((*s_etat_processus).instruction_courante); 479: } 480: 481: (*s_etat_processus).instruction_courante = tampon; 482: (*s_etat_processus).erreur_execution = 483: d_ex_erreur_traitement_condition; 484: return; 485: } 486: 487: if ((instruction_majuscule = conversion_majuscule( 488: (*s_etat_processus).instruction_courante)) == NULL) 489: { 490: liberation(s_etat_processus, s_objet); 491: 492: free((*s_etat_processus).instruction_courante); 493: (*s_etat_processus).instruction_courante = tampon; 494: (*s_etat_processus).erreur_systeme = 495: d_es_allocation_memoire; 496: return; 497: } 498: 499: if (niveau == 0) 500: { 501: if (((*(*s_etat_processus).l_base_pile_systeme) 502: .clause != 'K') && ((*(*s_etat_processus) 503: .l_base_pile_systeme) .clause != 'C')) 504: { 505: 506: /* 507: * Traitement de IF/THEN/ELSEIF/THEN/ELSE/END 508: */ 509: 510: if ((strcmp(instruction_majuscule, "END") == 0) || 511: (strcmp(instruction_majuscule, "ELSE") 512: == 0) || (strcmp(instruction_majuscule, 513: "ELSEIF") == 0)) 514: { 515: (*s_etat_processus).position_courante 516: -= (strlen(instruction_majuscule) + 1); 517: drapeau_fin = d_vrai; 518: } 519: else 520: { 521: drapeau_fin = d_faux; 522: } 523: } 524: else 525: { 526: /* 527: * Traitement de CASE/THEN/END 528: */ 529: 530: if (strcmp(instruction_majuscule, "ELSE") == 0) 531: { 532: liberation(s_etat_processus, s_objet); 533: 534: free((*s_etat_processus).instruction_courante); 535: free(instruction_majuscule); 536: 537: (*s_etat_processus).instruction_courante = 538: tampon; 539: (*s_etat_processus).erreur_execution = 540: d_ex_erreur_traitement_condition; 541: return; 542: } 543: else if (strcmp(instruction_majuscule, "END") == 0) 544: { 545: instruction_end(s_etat_processus); 546: drapeau_fin = d_vrai; 547: } 548: else 549: { 550: drapeau_fin = d_faux; 551: } 552: } 553: } 554: else 555: { 556: drapeau_fin = d_faux; 557: } 558: 559: if ((strcmp(instruction_majuscule, "CASE") == 0) || 560: (strcmp(instruction_majuscule, "DO") == 0) || 561: (strcmp(instruction_majuscule, "IF") == 0) || 562: (strcmp(instruction_majuscule, "IFERR") == 0) || 563: (strcmp(instruction_majuscule, "SELECT") == 0) || 564: (strcmp(instruction_majuscule, "WHILE") == 0)) 565: { 566: niveau++; 567: } 568: else if (strcmp(instruction_majuscule, "END") == 0) 569: { 570: niveau--; 571: } 572: 573: free(instruction_majuscule); 574: free((*s_etat_processus).instruction_courante); 575: } while(drapeau_fin == d_faux); 576: 577: (*s_etat_processus).instruction_courante = tampon; 578: } 579: else 580: { 581: /* 582: * Vérification du pointeur de prédiction de saut. 583: */ 584: 585: if (pthread_mutex_lock(&((*(*(*s_etat_processus) 586: .expression_courante).donnee).mutex)) != 0) 587: { 588: (*s_etat_processus).erreur_systeme = d_es_processus; 589: return; 590: } 591: 592: if ((*((struct_fonction *) (*(*(*s_etat_processus) 593: .expression_courante).donnee).objet)).prediction_saut 594: != NULL) 595: { 596: s_registre = (*s_etat_processus).expression_courante; 597: 598: (*s_etat_processus).expression_courante = 599: (struct_liste_chainee *) 600: (*((struct_fonction *) (*(*(*s_etat_processus) 601: .expression_courante).donnee).objet)) 602: .prediction_saut; 603: fonction = (*((struct_fonction *) 604: (*(*(*s_etat_processus).expression_courante) 605: .donnee).objet)).fonction; 606: execution = (*((struct_fonction *) 607: (*(*s_registre).donnee).objet)) 608: .prediction_execution; 609: 610: if (pthread_mutex_unlock(&((*(*s_registre).donnee).mutex)) 611: != 0) 612: { 613: (*s_etat_processus).erreur_systeme = d_es_processus; 614: return; 615: } 616: 617: if (execution == d_vrai) 618: { 619: fonction(s_etat_processus); 620: } 621: } 622: else 623: { 624: if (pthread_mutex_unlock(&((*(*(*s_etat_processus) 625: .expression_courante).donnee).mutex)) != 0) 626: { 627: (*s_etat_processus).erreur_systeme = d_es_processus; 628: return; 629: } 630: 631: s_registre = (*s_etat_processus).expression_courante; 632: execution = d_faux; 633: 634: do 635: { 636: if (((*s_etat_processus).expression_courante = 637: (*(*s_etat_processus).expression_courante) 638: .suivant) == NULL) 639: { 640: liberation(s_etat_processus, s_objet); 641: (*s_etat_processus).erreur_execution = 642: d_ex_erreur_traitement_condition; 643: return; 644: } 645: 646: if ((*(*(*s_etat_processus).expression_courante) 647: .donnee).type == FCT) 648: { 649: fonction = (*((struct_fonction *) 650: (*(*(*s_etat_processus).expression_courante) 651: .donnee).objet)).fonction; 652: 653: if (niveau == 0) 654: { 655: if (((*(*s_etat_processus).l_base_pile_systeme) 656: .clause != 'K') && 657: ((*(*s_etat_processus) 658: .l_base_pile_systeme).clause != 'C')) 659: { 660: /* 661: * Traitement de IF/THEN/ELSEIF/THEN/ 662: * ELSE/END 663: */ 664: 665: if ((fonction == instruction_end) || 666: (fonction == instruction_else) || 667: (fonction == instruction_elseif)) 668: { 669: fonction(s_etat_processus); 670: execution = d_vrai; 671: drapeau_fin = d_vrai; 672: } 673: else 674: { 675: drapeau_fin = d_faux; 676: } 677: } 678: else 679: { 680: /* 681: * Traitement de CASE/THEN/END 682: */ 683: 684: if (fonction == instruction_else) 685: { 686: liberation(s_etat_processus, s_objet); 687: 688: if ((drapeau_fin == d_faux) && 689: ((*s_etat_processus) 690: .expression_courante != NULL)) 691: { 692: (*s_etat_processus) 693: .expression_courante 694: = (*(*s_etat_processus) 695: .expression_courante) 696: .suivant; 697: } 698: 699: (*s_etat_processus).erreur_execution = 700: d_ex_erreur_traitement_condition; 701: return; 702: } 703: else if (fonction == instruction_end) 704: { 705: fonction(s_etat_processus); 706: execution = d_vrai; 707: drapeau_fin = d_vrai; 708: } 709: else 710: { 711: drapeau_fin = d_faux; 712: } 713: } 714: } 715: else 716: { 717: drapeau_fin = d_faux; 718: } 719: 720: if ((fonction == instruction_case) || 721: (fonction == instruction_do) || 722: (fonction == instruction_if) || 723: (fonction == instruction_iferr) || 724: (fonction == instruction_select) || 725: (fonction == instruction_while)) 726: { 727: niveau++; 728: } 729: else if (fonction == instruction_end) 730: { 731: niveau--; 732: } 733: } 734: } while(drapeau_fin == d_faux); 735: 736: if (pthread_mutex_lock(&((*(*(*s_etat_processus) 737: .expression_courante).donnee).mutex)) != 0) 738: { 739: (*s_etat_processus).erreur_systeme = d_es_processus; 740: return; 741: } 742: 743: (*((struct_fonction *) (*(*s_registre).donnee).objet)) 744: .prediction_saut = (*s_etat_processus) 745: .expression_courante; 746: (*((struct_fonction *) (*(*s_registre).donnee).objet)) 747: .prediction_execution = execution; 748: 749: if (pthread_mutex_unlock(&((*(*(*s_etat_processus) 750: .expression_courante).donnee).mutex)) != 0) 751: { 752: (*s_etat_processus).erreur_systeme = d_es_processus; 753: return; 754: } 755: } 756: } 757: } 758: } 759: else 760: { 761: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 762: return; 763: } 764: 765: liberation(s_etat_processus, s_objet); 766: return; 767: } 768: 769: 770: /* 771: ================================================================================ 772: Fonction 'tan' 773: ================================================================================ 774: Entrées : pointeur sur une structure struct_processus 775: -------------------------------------------------------------------------------- 776: Sorties : 777: -------------------------------------------------------------------------------- 778: Effets de bord : néant 779: ================================================================================ 780: */ 781: 782: void 783: instruction_tan(struct_processus *s_etat_processus) 784: { 785: real8 angle; 786: 787: integer4 erreur; 788: 789: struct_liste_chainee *l_element_courant; 790: struct_liste_chainee *l_element_precedent; 791: 792: struct_objet *s_copie_argument; 793: struct_objet *s_objet_argument; 794: struct_objet *s_objet_resultat; 795: 796: (*s_etat_processus).erreur_execution = d_ex; 797: 798: if ((*s_etat_processus).affichage_arguments == 'Y') 799: { 800: printf("\n TAN "); 801: 802: if ((*s_etat_processus).langue == 'F') 803: { 804: printf("(tangente)\n\n"); 805: } 806: else 807: { 808: printf("(tangent)\n\n"); 809: } 810: 811: printf(" 1: %s, %s\n", d_INT, d_REL); 812: printf("-> 1: %s\n\n", d_REL); 813: 814: printf(" 1: %s\n", d_CPL); 815: printf("-> 1: %s\n\n", d_CPL); 816: 817: printf(" 1: %s, %s\n", d_NOM, d_ALG); 818: printf("-> 1: %s\n\n", d_ALG); 819: 820: printf(" 1: %s\n", d_RPN); 821: printf("-> 1: %s\n", d_RPN); 822: 823: return; 824: } 825: else if ((*s_etat_processus).test_instruction == 'Y') 826: { 827: (*s_etat_processus).nombre_arguments = 1; 828: return; 829: } 830: 831: if (test_cfsf(s_etat_processus, 31) == d_vrai) 832: { 833: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 834: { 835: return; 836: } 837: } 838: 839: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 840: &s_objet_argument) == d_erreur) 841: { 842: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 843: return; 844: } 845: 846: /* 847: -------------------------------------------------------------------------------- 848: Tangente d'un entier ou d'un réel 849: -------------------------------------------------------------------------------- 850: */ 851: 852: if (((*s_objet_argument).type == INT) || 853: ((*s_objet_argument).type == REL)) 854: { 855: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) 856: { 857: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 858: return; 859: } 860: 861: if ((*s_objet_argument).type == INT) 862: { 863: angle = (real8) (*((integer8 *) (*s_objet_argument).objet)); 864: } 865: else 866: { 867: angle = (*((real8 *) (*s_objet_argument).objet)); 868: } 869: 870: if (test_cfsf(s_etat_processus, 60) == d_faux) 871: { 872: conversion_degres_vers_radians(&angle); 873: } 874: 875: if ((cos(angle) == 0) && (test_cfsf(s_etat_processus, 59) == d_vrai)) 876: { 877: liberation(s_etat_processus, s_objet_argument); 878: liberation(s_etat_processus, s_objet_resultat); 879: 880: (*s_etat_processus).exception = d_ep_division_par_zero; 881: return; 882: } 883: 884: (*((real8 *) (*s_objet_resultat).objet)) = tan(angle); 885: } 886: 887: /* 888: -------------------------------------------------------------------------------- 889: Tangente d'un complexe 890: -------------------------------------------------------------------------------- 891: */ 892: 893: else if ((*s_objet_argument).type == CPL) 894: { 895: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) 896: { 897: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 898: return; 899: } 900: 901: f77tan_((struct_complexe16 *) (*s_objet_argument).objet, 902: (struct_complexe16 *) (*s_objet_resultat).objet, &erreur); 903: 904: if (erreur != 0) 905: { 906: liberation(s_etat_processus, s_objet_argument); 907: liberation(s_etat_processus, s_objet_resultat); 908: 909: (*s_etat_processus).exception = d_ep_division_par_zero; 910: return; 911: } 912: } 913: 914: /* 915: -------------------------------------------------------------------------------- 916: Tangente d'un nom 917: -------------------------------------------------------------------------------- 918: */ 919: 920: else if ((*s_objet_argument).type == NOM) 921: { 922: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL) 923: { 924: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 925: return; 926: } 927: 928: if (((*s_objet_resultat).objet = 929: allocation_maillon(s_etat_processus)) == NULL) 930: { 931: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 932: return; 933: } 934: 935: l_element_courant = (*s_objet_resultat).objet; 936: 937: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 938: == NULL) 939: { 940: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 941: return; 942: } 943: 944: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 945: .nombre_arguments = 0; 946: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 947: .fonction = instruction_vers_niveau_superieur; 948: 949: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 950: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 951: { 952: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 953: return; 954: } 955: 956: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 957: .nom_fonction, "<<"); 958: 959: if (((*l_element_courant).suivant = 960: allocation_maillon(s_etat_processus)) == NULL) 961: { 962: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 963: return; 964: } 965: 966: l_element_courant = (*l_element_courant).suivant; 967: (*l_element_courant).donnee = s_objet_argument; 968: 969: if (((*l_element_courant).suivant = 970: allocation_maillon(s_etat_processus)) == NULL) 971: { 972: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 973: return; 974: } 975: 976: l_element_courant = (*l_element_courant).suivant; 977: 978: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 979: == NULL) 980: { 981: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 982: return; 983: } 984: 985: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 986: .nombre_arguments = 1; 987: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 988: .fonction = instruction_tan; 989: 990: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 991: .nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL) 992: { 993: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 994: return; 995: } 996: 997: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 998: .nom_fonction, "TAN"); 999: 1000: if (((*l_element_courant).suivant = 1001: allocation_maillon(s_etat_processus)) == NULL) 1002: { 1003: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1004: return; 1005: } 1006: 1007: l_element_courant = (*l_element_courant).suivant; 1008: 1009: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1010: == NULL) 1011: { 1012: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1013: return; 1014: } 1015: 1016: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1017: .nombre_arguments = 0; 1018: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1019: .fonction = instruction_vers_niveau_inferieur; 1020: 1021: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1022: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 1023: { 1024: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1025: return; 1026: } 1027: 1028: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1029: .nom_fonction, ">>"); 1030: 1031: (*l_element_courant).suivant = NULL; 1032: s_objet_argument = NULL; 1033: } 1034: 1035: /* 1036: -------------------------------------------------------------------------------- 1037: Tangente d'une expression 1038: -------------------------------------------------------------------------------- 1039: */ 1040: 1041: else if (((*s_objet_argument).type == ALG) || 1042: ((*s_objet_argument).type == RPN)) 1043: { 1044: if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument, 1045: 'N')) == NULL) 1046: { 1047: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1048: return; 1049: } 1050: 1051: l_element_courant = (struct_liste_chainee *) 1052: (*s_copie_argument).objet; 1053: l_element_precedent = l_element_courant; 1054: 1055: while((*l_element_courant).suivant != NULL) 1056: { 1057: l_element_precedent = l_element_courant; 1058: l_element_courant = (*l_element_courant).suivant; 1059: } 1060: 1061: if (((*l_element_precedent).suivant = 1062: allocation_maillon(s_etat_processus)) == NULL) 1063: { 1064: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1065: return; 1066: } 1067: 1068: if (((*(*l_element_precedent).suivant).donnee = 1069: allocation(s_etat_processus, FCT)) == NULL) 1070: { 1071: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1072: return; 1073: } 1074: 1075: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1076: .donnee).objet)).nombre_arguments = 1; 1077: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1078: .donnee).objet)).fonction = instruction_tan; 1079: 1080: if (((*((struct_fonction *) (*(*(*l_element_precedent) 1081: .suivant).donnee).objet)).nom_fonction = 1082: malloc(4 * sizeof(unsigned char))) == NULL) 1083: { 1084: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1085: return; 1086: } 1087: 1088: strcpy((*((struct_fonction *) (*(*(*l_element_precedent) 1089: .suivant).donnee).objet)).nom_fonction, "TAN"); 1090: 1091: (*(*l_element_precedent).suivant).suivant = l_element_courant; 1092: 1093: s_objet_resultat = s_copie_argument; 1094: } 1095: 1096: /* 1097: -------------------------------------------------------------------------------- 1098: Réalisation impossible de la fonction tangente 1099: -------------------------------------------------------------------------------- 1100: */ 1101: 1102: else 1103: { 1104: liberation(s_etat_processus, s_objet_argument); 1105: 1106: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1107: return; 1108: } 1109: 1110: liberation(s_etat_processus, s_objet_argument); 1111: 1112: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1113: s_objet_resultat) == d_erreur) 1114: { 1115: return; 1116: } 1117: 1118: return; 1119: } 1120: 1121: 1122: /* 1123: ================================================================================ 1124: Fonction 'tanh' 1125: ================================================================================ 1126: Entrées : pointeur sur une structure struct_processus 1127: -------------------------------------------------------------------------------- 1128: Sorties : 1129: -------------------------------------------------------------------------------- 1130: Effets de bord : néant 1131: ================================================================================ 1132: */ 1133: 1134: void 1135: instruction_tanh(struct_processus *s_etat_processus) 1136: { 1137: real8 argument; 1138: 1139: integer4 erreur; 1140: 1141: struct_liste_chainee *l_element_courant; 1142: struct_liste_chainee *l_element_precedent; 1143: 1144: struct_objet *s_copie_argument; 1145: struct_objet *s_objet_argument; 1146: struct_objet *s_objet_resultat; 1147: 1148: (*s_etat_processus).erreur_execution = d_ex; 1149: 1150: if ((*s_etat_processus).affichage_arguments == 'Y') 1151: { 1152: printf("\n TANH "); 1153: 1154: if ((*s_etat_processus).langue == 'F') 1155: { 1156: printf("(tangente hyperbolique)\n\n"); 1157: } 1158: else 1159: { 1160: printf("(hyperbolic tangent)\n\n"); 1161: } 1162: 1163: printf(" 1: %s, %s\n", d_INT, d_REL); 1164: printf("-> 1: %s\n\n", d_INT); 1165: 1166: printf(" 1: %s\n", d_CPL); 1167: printf("-> 1: %s\n\n", d_CPL); 1168: 1169: printf(" 1: %s, %s\n", d_NOM, d_ALG); 1170: printf("-> 1: %s\n\n", d_ALG); 1171: 1172: printf(" 1: %s\n", d_RPN); 1173: printf("-> 1: %s\n", d_RPN); 1174: 1175: return; 1176: } 1177: else if ((*s_etat_processus).test_instruction == 'Y') 1178: { 1179: (*s_etat_processus).nombre_arguments = 1; 1180: return; 1181: } 1182: 1183: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1184: { 1185: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 1186: { 1187: return; 1188: } 1189: } 1190: 1191: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1192: &s_objet_argument) == d_erreur) 1193: { 1194: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1195: return; 1196: } 1197: 1198: /* 1199: -------------------------------------------------------------------------------- 1200: Tangente hyperbolique d'un entier ou d'un réel 1201: -------------------------------------------------------------------------------- 1202: */ 1203: 1204: if (((*s_objet_argument).type == INT) || 1205: ((*s_objet_argument).type == REL)) 1206: { 1207: if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL) 1208: { 1209: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1210: return; 1211: } 1212: 1213: if ((*s_objet_argument).type == INT) 1214: { 1215: argument = (real8) (*((integer8 *) (*s_objet_argument).objet)); 1216: } 1217: else 1218: { 1219: argument = (*((real8 *) (*s_objet_argument).objet)); 1220: } 1221: 1222: (*((real8 *) (*s_objet_resultat).objet)) = tanh(argument); 1223: } 1224: 1225: /* 1226: -------------------------------------------------------------------------------- 1227: Tangente hyperbolique d'un complexe 1228: -------------------------------------------------------------------------------- 1229: */ 1230: 1231: else if ((*s_objet_argument).type == CPL) 1232: { 1233: if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL) 1234: { 1235: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1236: return; 1237: } 1238: 1239: f77tanh_((struct_complexe16 *) (*s_objet_argument).objet, 1240: (struct_complexe16 *) (*s_objet_resultat).objet, &erreur); 1241: 1242: if (erreur != 0) 1243: { 1244: liberation(s_etat_processus, s_objet_argument); 1245: liberation(s_etat_processus, s_objet_resultat); 1246: 1247: (*s_etat_processus).exception = d_ep_division_par_zero; 1248: return; 1249: } 1250: } 1251: 1252: /* 1253: -------------------------------------------------------------------------------- 1254: Tangente hyperbolique d'un nom 1255: -------------------------------------------------------------------------------- 1256: */ 1257: 1258: else if ((*s_objet_argument).type == NOM) 1259: { 1260: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL) 1261: { 1262: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1263: return; 1264: } 1265: 1266: if (((*s_objet_resultat).objet = 1267: allocation_maillon(s_etat_processus)) == NULL) 1268: { 1269: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1270: return; 1271: } 1272: 1273: l_element_courant = (*s_objet_resultat).objet; 1274: 1275: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1276: == NULL) 1277: { 1278: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1279: return; 1280: } 1281: 1282: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1283: .nombre_arguments = 0; 1284: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1285: .fonction = instruction_vers_niveau_superieur; 1286: 1287: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1288: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 1289: { 1290: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1291: return; 1292: } 1293: 1294: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1295: .nom_fonction, "<<"); 1296: 1297: if (((*l_element_courant).suivant = 1298: allocation_maillon(s_etat_processus)) == NULL) 1299: { 1300: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1301: return; 1302: } 1303: 1304: l_element_courant = (*l_element_courant).suivant; 1305: (*l_element_courant).donnee = s_objet_argument; 1306: 1307: if (((*l_element_courant).suivant = 1308: allocation_maillon(s_etat_processus)) == NULL) 1309: { 1310: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1311: return; 1312: } 1313: 1314: l_element_courant = (*l_element_courant).suivant; 1315: 1316: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1317: == NULL) 1318: { 1319: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1320: return; 1321: } 1322: 1323: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1324: .nombre_arguments = 1; 1325: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1326: .fonction = instruction_tanh; 1327: 1328: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1329: .nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL) 1330: { 1331: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1332: return; 1333: } 1334: 1335: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1336: .nom_fonction, "TANH"); 1337: 1338: if (((*l_element_courant).suivant = 1339: allocation_maillon(s_etat_processus)) == NULL) 1340: { 1341: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1342: return; 1343: } 1344: 1345: l_element_courant = (*l_element_courant).suivant; 1346: 1347: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1348: == NULL) 1349: { 1350: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1351: return; 1352: } 1353: 1354: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1355: .nombre_arguments = 0; 1356: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1357: .fonction = instruction_vers_niveau_inferieur; 1358: 1359: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1360: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 1361: { 1362: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1363: return; 1364: } 1365: 1366: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1367: .nom_fonction, ">>"); 1368: 1369: (*l_element_courant).suivant = NULL; 1370: s_objet_argument = NULL; 1371: } 1372: 1373: /* 1374: -------------------------------------------------------------------------------- 1375: Tangente hyperbolique d'une expression 1376: -------------------------------------------------------------------------------- 1377: */ 1378: 1379: else if (((*s_objet_argument).type == ALG) || 1380: ((*s_objet_argument).type == RPN)) 1381: { 1382: if ((s_copie_argument = copie_objet(s_etat_processus, s_objet_argument, 1383: 'N')) == NULL) 1384: { 1385: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1386: return; 1387: } 1388: 1389: l_element_courant = (struct_liste_chainee *) 1390: (*s_copie_argument).objet; 1391: l_element_precedent = l_element_courant; 1392: 1393: while((*l_element_courant).suivant != NULL) 1394: { 1395: l_element_precedent = l_element_courant; 1396: l_element_courant = (*l_element_courant).suivant; 1397: } 1398: 1399: if (((*l_element_precedent).suivant = 1400: allocation_maillon(s_etat_processus)) == NULL) 1401: { 1402: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1403: return; 1404: } 1405: 1406: if (((*(*l_element_precedent).suivant).donnee = 1407: allocation(s_etat_processus, FCT)) == NULL) 1408: { 1409: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1410: return; 1411: } 1412: 1413: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1414: .donnee).objet)).nombre_arguments = 1; 1415: (*((struct_fonction *) (*(*(*l_element_precedent).suivant) 1416: .donnee).objet)).fonction = instruction_tanh; 1417: 1418: if (((*((struct_fonction *) (*(*(*l_element_precedent) 1419: .suivant).donnee).objet)).nom_fonction = 1420: malloc(5 * sizeof(unsigned char))) == NULL) 1421: { 1422: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1423: return; 1424: } 1425: 1426: strcpy((*((struct_fonction *) (*(*(*l_element_precedent) 1427: .suivant).donnee).objet)).nom_fonction, "TANH"); 1428: 1429: (*(*l_element_precedent).suivant).suivant = l_element_courant; 1430: 1431: s_objet_resultat = s_copie_argument; 1432: } 1433: 1434: /* 1435: -------------------------------------------------------------------------------- 1436: Réalisation impossible de la fonction tangente hyperbolique 1437: -------------------------------------------------------------------------------- 1438: */ 1439: 1440: else 1441: { 1442: liberation(s_etat_processus, s_objet_argument); 1443: 1444: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1445: return; 1446: } 1447: 1448: liberation(s_etat_processus, s_objet_argument); 1449: 1450: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1451: s_objet_resultat) == d_erreur) 1452: { 1453: return; 1454: } 1455: 1456: return; 1457: } 1458: 1459: 1460: /* 1461: ================================================================================ 1462: Fonction 'true' 1463: ================================================================================ 1464: Entrées : structure processus 1465: -------------------------------------------------------------------------------- 1466: Sorties : 1467: -------------------------------------------------------------------------------- 1468: Effets de bord : néant 1469: ================================================================================ 1470: */ 1471: 1472: void 1473: instruction_true(struct_processus *s_etat_processus) 1474: { 1475: struct_objet *s_objet; 1476: 1477: if ((*s_etat_processus).affichage_arguments == 'Y') 1478: { 1479: printf("\n TRUE "); 1480: 1481: if ((*s_etat_processus).langue == 'F') 1482: { 1483: printf("(valeur vraie)\n\n"); 1484: } 1485: else 1486: { 1487: printf("(true value)\n\n"); 1488: } 1489: 1490: printf("-> 1: %s\n", d_INT); 1491: 1492: return; 1493: } 1494: else if ((*s_etat_processus).test_instruction == 'Y') 1495: { 1496: (*s_etat_processus).nombre_arguments = -1; 1497: return; 1498: } 1499: 1500: if ((s_objet = allocation(s_etat_processus, INT)) == NULL) 1501: { 1502: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1503: return; 1504: } 1505: 1506: (*((integer8 *) (*s_objet).objet)) = -1; 1507: 1508: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1509: s_objet) == d_erreur) 1510: { 1511: return; 1512: } 1513: 1514: return; 1515: } 1516: 1517: // vim: ts=4