![]() ![]() | ![]() |
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 'trn' 29: ================================================================================ 30: Entrées : pointeur sur une structure struct_processus 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_trn(struct_processus *s_etat_processus) 40: { 41: struct_objet *s_objet_argument; 42: struct_objet *s_objet_resultat; 43: 44: logical1 argument_nom; 45: logical1 variable_partagee; 46: 47: unsigned long i; 48: unsigned long j; 49: 50: (*s_etat_processus).erreur_execution = d_ex; 51: 52: if ((*s_etat_processus).affichage_arguments == 'Y') 53: { 54: printf("\n TRN "); 55: 56: if ((*s_etat_processus).langue == 'F') 57: { 58: printf("(transposition)\n\n"); 59: } 60: else 61: { 62: printf("(transposition)\n\n"); 63: } 64: 65: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX); 66: printf("-> 1: %s, %s, %s\n\n", d_MIN, d_MRL, d_MCX); 67: 68: printf(" 1: %s\n", d_NOM); 69: 70: return; 71: } 72: else if ((*s_etat_processus).test_instruction == 'Y') 73: { 74: (*s_etat_processus).nombre_arguments = -1; 75: return; 76: } 77: 78: if (test_cfsf(s_etat_processus, 31) == d_vrai) 79: { 80: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 81: { 82: return; 83: } 84: } 85: 86: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 87: &s_objet_argument) == d_erreur) 88: { 89: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 90: return; 91: } 92: 93: variable_partagee = d_faux; 94: 95: if ((*s_objet_argument).type == NOM) 96: { 97: argument_nom = d_vrai; 98: 99: if (recherche_variable(s_etat_processus, (*((struct_nom *) 100: (*s_objet_argument).objet)).nom) == d_faux) 101: { 102: (*s_etat_processus).erreur_systeme = d_es; 103: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; 104: 105: liberation(s_etat_processus, s_objet_argument); 106: 107: return; 108: } 109: 110: liberation(s_etat_processus, s_objet_argument); 111: 112: if ((*(*s_etat_processus).pointeur_variable_courante) 113: .variable_verrouillee == d_vrai) 114: { 115: (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee; 116: return; 117: } 118: 119: if ((*(*s_etat_processus).pointeur_variable_courante).objet != NULL) 120: { 121: s_objet_argument = (*(*s_etat_processus).pointeur_variable_courante) 122: .objet; 123: } 124: else 125: { 126: if (pthread_mutex_lock(&((*(*s_etat_processus) 127: .s_liste_variables_partagees).mutex)) != 0) 128: { 129: (*s_etat_processus).erreur_systeme = d_es_processus; 130: return; 131: } 132: 133: if (recherche_variable_partagee(s_etat_processus, 134: (*(*s_etat_processus).pointeur_variable_courante).nom, 135: (*(*s_etat_processus).pointeur_variable_courante) 136: .variable_partagee, (*(*s_etat_processus) 137: .pointeur_variable_courante).origine) == d_faux) 138: { 139: if (pthread_mutex_unlock(&((*(*s_etat_processus) 140: .s_liste_variables_partagees).mutex)) != 0) 141: { 142: (*s_etat_processus).erreur_systeme = d_es_processus; 143: return; 144: } 145: 146: (*s_etat_processus).erreur_systeme = d_es; 147: (*s_etat_processus).erreur_execution = 148: d_ex_variable_non_definie; 149: 150: liberation(s_etat_processus, s_objet_argument); 151: 152: return; 153: } 154: 155: variable_partagee = d_vrai; 156: } 157: } 158: else 159: { 160: argument_nom = d_faux; 161: } 162: 163: /* 164: -------------------------------------------------------------------------------- 165: Matrice transposée d'une matrice entière 166: -------------------------------------------------------------------------------- 167: */ 168: 169: if ((*s_objet_argument).type == MIN) 170: { 171: if ((s_objet_resultat = allocation(s_etat_processus, MIN)) == NULL) 172: { 173: if (variable_partagee == d_vrai) 174: { 175: if (pthread_mutex_unlock(&((*(*s_etat_processus) 176: .s_liste_variables_partagees).mutex)) != 0) 177: { 178: (*s_etat_processus).erreur_systeme = d_es_processus; 179: return; 180: } 181: } 182: 183: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 184: return; 185: } 186: 187: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = 188: (*((struct_matrice *) (*s_objet_argument).objet)) 189: .nombre_colonnes; 190: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = 191: (*((struct_matrice *) (*s_objet_argument).objet)) 192: .nombre_lignes; 193: 194: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = 195: malloc((*((struct_matrice *) (*s_objet_resultat).objet)) 196: .nombre_lignes * sizeof(integer8 *))) == NULL) 197: { 198: if (variable_partagee == d_vrai) 199: { 200: if (pthread_mutex_unlock(&((*(*s_etat_processus) 201: .s_liste_variables_partagees).mutex)) != 0) 202: { 203: (*s_etat_processus).erreur_systeme = d_es_processus; 204: return; 205: } 206: } 207: 208: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 209: return; 210: } 211: 212: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet)) 213: .nombre_lignes; i++) 214: { 215: if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat) 216: .objet)).tableau)[i] = 217: malloc((*((struct_matrice *) (*s_objet_resultat).objet)) 218: .nombre_colonnes * sizeof(integer8))) == NULL) 219: { 220: if (variable_partagee == d_vrai) 221: { 222: if (pthread_mutex_unlock(&((*(*s_etat_processus) 223: .s_liste_variables_partagees).mutex)) != 0) 224: { 225: (*s_etat_processus).erreur_systeme = d_es_processus; 226: return; 227: } 228: } 229: 230: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 231: return; 232: } 233: 234: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet)) 235: .nombre_colonnes; j++) 236: { 237: ((integer8 **) (*((struct_matrice *) (*s_objet_resultat) 238: .objet)).tableau)[i][j] = 239: ((integer8 **) (*((struct_matrice *) 240: (*s_objet_argument).objet)).tableau)[j][i]; 241: } 242: } 243: } 244: 245: /* 246: -------------------------------------------------------------------------------- 247: Matrice tranposée d'une matrice réelle 248: -------------------------------------------------------------------------------- 249: */ 250: 251: else if ((*s_objet_argument).type == MRL) 252: { 253: if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL) 254: { 255: if (variable_partagee == d_vrai) 256: { 257: if (pthread_mutex_unlock(&((*(*s_etat_processus) 258: .s_liste_variables_partagees).mutex)) != 0) 259: { 260: (*s_etat_processus).erreur_systeme = d_es_processus; 261: return; 262: } 263: } 264: 265: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 266: return; 267: } 268: 269: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = 270: (*((struct_matrice *) (*s_objet_argument).objet)) 271: .nombre_colonnes; 272: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = 273: (*((struct_matrice *) (*s_objet_argument).objet)) 274: .nombre_lignes; 275: 276: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = 277: malloc((*((struct_matrice *) (*s_objet_resultat).objet)) 278: .nombre_lignes * sizeof(real8 *))) == NULL) 279: { 280: if (variable_partagee == d_vrai) 281: { 282: if (pthread_mutex_unlock(&((*(*s_etat_processus) 283: .s_liste_variables_partagees).mutex)) != 0) 284: { 285: (*s_etat_processus).erreur_systeme = d_es_processus; 286: return; 287: } 288: } 289: 290: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 291: return; 292: } 293: 294: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet)) 295: .nombre_lignes; i++) 296: { 297: if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat) 298: .objet)).tableau)[i] = 299: malloc((*((struct_matrice *) (*s_objet_resultat).objet)) 300: .nombre_colonnes * sizeof(real8))) == NULL) 301: { 302: if (variable_partagee == d_vrai) 303: { 304: if (pthread_mutex_unlock(&((*(*s_etat_processus) 305: .s_liste_variables_partagees).mutex)) != 0) 306: { 307: (*s_etat_processus).erreur_systeme = d_es_processus; 308: return; 309: } 310: } 311: 312: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 313: return; 314: } 315: 316: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet)) 317: .nombre_colonnes; j++) 318: { 319: ((real8 **) (*((struct_matrice *) (*s_objet_resultat) 320: .objet)).tableau)[i][j] = 321: ((real8 **) (*((struct_matrice *) 322: (*s_objet_argument).objet)).tableau)[j][i]; 323: } 324: } 325: } 326: 327: /* 328: -------------------------------------------------------------------------------- 329: Matrice transposée (et conjuguée) d'une matrice complexe 330: -------------------------------------------------------------------------------- 331: */ 332: 333: else if ((*s_objet_argument).type == MCX) 334: { 335: if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL) 336: { 337: if (variable_partagee == d_vrai) 338: { 339: if (pthread_mutex_unlock(&((*(*s_etat_processus) 340: .s_liste_variables_partagees).mutex)) != 0) 341: { 342: (*s_etat_processus).erreur_systeme = d_es_processus; 343: return; 344: } 345: } 346: 347: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 348: return; 349: } 350: 351: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes = 352: (*((struct_matrice *) (*s_objet_argument).objet)) 353: .nombre_colonnes; 354: (*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes = 355: (*((struct_matrice *) (*s_objet_argument).objet)) 356: .nombre_lignes; 357: 358: if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau = 359: malloc((*((struct_matrice *) (*s_objet_resultat).objet)) 360: .nombre_lignes * sizeof(struct_complexe16 *))) == NULL) 361: { 362: if (variable_partagee == d_vrai) 363: { 364: if (pthread_mutex_unlock(&((*(*s_etat_processus) 365: .s_liste_variables_partagees).mutex)) != 0) 366: { 367: (*s_etat_processus).erreur_systeme = d_es_processus; 368: return; 369: } 370: } 371: 372: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 373: return; 374: } 375: 376: for(i = 0; i < (*((struct_matrice *) (*s_objet_resultat).objet)) 377: .nombre_lignes; i++) 378: { 379: if ((((struct_complexe16 **) (*((struct_matrice *) 380: (*s_objet_resultat).objet)).tableau)[i] = 381: malloc((*((struct_matrice *) 382: (*s_objet_resultat).objet)).nombre_colonnes * 383: sizeof(struct_complexe16))) == NULL) 384: { 385: if (variable_partagee == d_vrai) 386: { 387: if (pthread_mutex_unlock(&((*(*s_etat_processus) 388: .s_liste_variables_partagees).mutex)) != 0) 389: { 390: (*s_etat_processus).erreur_systeme = d_es_processus; 391: return; 392: } 393: } 394: 395: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 396: return; 397: } 398: 399: for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet)) 400: .nombre_colonnes; j++) 401: { 402: ((struct_complexe16 **) (*((struct_matrice *) 403: (*s_objet_resultat).objet)).tableau)[i][j] 404: .partie_reelle = 405: ((struct_complexe16 **) (*((struct_matrice *) 406: (*s_objet_argument).objet)).tableau)[j][i] 407: .partie_reelle; 408: ((struct_complexe16 **) (*((struct_matrice *) 409: (*s_objet_resultat).objet)).tableau)[i][j] 410: .partie_imaginaire = 411: -((struct_complexe16 **) (*((struct_matrice *) 412: (*s_objet_argument).objet)).tableau)[j][i] 413: .partie_imaginaire; 414: } 415: } 416: } 417: 418: /* 419: -------------------------------------------------------------------------------- 420: Fonction transposée impossible à réaliser 421: -------------------------------------------------------------------------------- 422: */ 423: 424: else 425: { 426: if (argument_nom == d_faux) 427: { 428: liberation(s_etat_processus, s_objet_argument); 429: } 430: 431: if (variable_partagee == d_vrai) 432: { 433: if (pthread_mutex_unlock(&((*(*s_etat_processus) 434: .s_liste_variables_partagees).mutex)) != 0) 435: { 436: (*s_etat_processus).erreur_systeme = d_es_processus; 437: return; 438: } 439: } 440: 441: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 442: return; 443: } 444: 445: liberation(s_etat_processus, s_objet_argument); 446: 447: if (argument_nom == d_faux) 448: { 449: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 450: s_objet_resultat) == d_erreur) 451: { 452: return; 453: } 454: } 455: else 456: { 457: if (variable_partagee == d_vrai) 458: { 459: (*(*s_etat_processus).s_liste_variables_partagees).table 460: [(*(*s_etat_processus).s_liste_variables_partagees) 461: .position_variable].objet = s_objet_resultat; 462: 463: if (pthread_mutex_unlock(&((*(*s_etat_processus) 464: .s_liste_variables_partagees).mutex)) != 0) 465: { 466: (*s_etat_processus).erreur_systeme = d_es_processus; 467: return; 468: } 469: } 470: else 471: { 472: (*(*s_etat_processus).pointeur_variable_courante).objet = 473: s_objet_resultat; 474: } 475: } 476: 477: return; 478: } 479: 480: 481: /* 482: ================================================================================ 483: Fonction 'tot' 484: ================================================================================ 485: Entrées : pointeur sur une structure struct_processus 486: -------------------------------------------------------------------------------- 487: Sorties : 488: -------------------------------------------------------------------------------- 489: Effets de bord : néant 490: ================================================================================ 491: */ 492: 493: void 494: instruction_tot(struct_processus *s_etat_processus) 495: { 496: struct_objet *s_objet_statistique; 497: struct_objet *s_objet_resultat; 498: struct_objet *s_objet_temporaire; 499: 500: unsigned long nombre_colonnes; 501: 502: (*s_etat_processus).erreur_execution = d_ex; 503: 504: if ((*s_etat_processus).affichage_arguments == 'Y') 505: { 506: printf("\n TOT "); 507: 508: if ((*s_etat_processus).langue == 'F') 509: { 510: printf("(somme des colonnes statistiques)\n\n"); 511: } 512: else 513: { 514: printf("(sum of statistical columns)\n\n"); 515: } 516: 517: printf("-> 1: %s, %s, %s, %s\n", d_INT, d_REL, d_VIN, d_REL); 518: 519: return; 520: } 521: else if ((*s_etat_processus).test_instruction == 'Y') 522: { 523: (*s_etat_processus).nombre_arguments = -1; 524: return; 525: } 526: 527: if (test_cfsf(s_etat_processus, 31) == d_vrai) 528: { 529: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 530: { 531: return; 532: } 533: } 534: 535: /* 536: * Recherche d'une variable globale référencée par SIGMA 537: */ 538: 539: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux) 540: { 541: /* 542: * Aucune variable SIGMA 543: */ 544: 545: (*s_etat_processus).erreur_systeme = d_es; 546: 547: if ((*s_etat_processus).erreur_execution == d_ex) 548: { 549: (*s_etat_processus).erreur_execution = d_ex_absence_observations; 550: } 551: 552: return; 553: } 554: else 555: { 556: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet) 557: .type != MIN) && ((*(*(*s_etat_processus) 558: .pointeur_variable_courante).objet).type != MRL)) 559: { 560: (*s_etat_processus).erreur_execution = 561: d_ex_matrice_statistique_invalide; 562: return; 563: } 564: 565: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus) 566: .pointeur_variable_courante).objet).objet)).nombre_colonnes; 567: } 568: 569: if (nombre_colonnes == 0) 570: { 571: (*s_etat_processus).erreur_execution = 572: d_ex_matrice_statistique_invalide; 573: return; 574: } 575: 576: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante) 577: .objet; 578: 579: if (((*s_objet_statistique).type == MIN) || 580: ((*s_objet_statistique).type == MRL)) 581: { 582: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL) 583: { 584: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 585: return; 586: } 587: 588: if (((*s_objet_resultat).objet = sommation_statistique( 589: (struct_matrice *) (*s_objet_statistique).objet)) == NULL) 590: { 591: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 592: return; 593: } 594: 595: if (nombre_colonnes == 1) 596: { 597: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I') 598: { 599: (*s_objet_resultat).type = VIN; 600: s_objet_temporaire = s_objet_resultat; 601: 602: if ((s_objet_resultat = allocation(s_etat_processus, INT)) 603: == NULL) 604: { 605: (*s_etat_processus).erreur_systeme = 606: d_es_allocation_memoire; 607: return; 608: } 609: 610: (*((integer8 *) (*s_objet_resultat).objet)) = 611: ((integer8 *) (*((struct_vecteur *) 612: (*s_objet_temporaire).objet)).tableau)[0]; 613: 614: liberation(s_etat_processus, s_objet_temporaire); 615: } 616: else 617: { 618: (*s_objet_resultat).type = VRL; 619: s_objet_temporaire = s_objet_resultat; 620: 621: if ((s_objet_resultat = allocation(s_etat_processus, REL)) 622: == NULL) 623: { 624: (*s_etat_processus).erreur_systeme = 625: d_es_allocation_memoire; 626: return; 627: } 628: 629: (*((real8 *) (*s_objet_resultat).objet)) = 630: ((real8 *) (*((struct_vecteur *) 631: (*s_objet_temporaire).objet)).tableau)[0]; 632: 633: liberation(s_etat_processus, s_objet_temporaire); 634: } 635: } 636: else 637: { 638: if ((*((struct_vecteur *) (*s_objet_resultat).objet)).type == 'I') 639: { 640: (*s_objet_resultat).type = VIN; 641: } 642: else 643: { 644: (*s_objet_resultat).type = VRL; 645: } 646: } 647: 648: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 649: s_objet_resultat) == d_erreur) 650: { 651: return; 652: } 653: } 654: else 655: { 656: (*s_etat_processus).erreur_execution = 657: d_ex_matrice_statistique_invalide; 658: return; 659: } 660: 661: return; 662: } 663: 664: 665: /* 666: ================================================================================ 667: Fonction 'title' 668: ================================================================================ 669: Entrées : 670: -------------------------------------------------------------------------------- 671: Sorties : 672: -------------------------------------------------------------------------------- 673: Effets de bord : néant 674: ================================================================================ 675: */ 676: 677: void 678: instruction_title(struct_processus *s_etat_processus) 679: { 680: struct_objet *s_objet; 681: 682: (*s_etat_processus).erreur_execution = d_ex; 683: 684: if ((*s_etat_processus).affichage_arguments == 'Y') 685: { 686: printf("\n TITLE "); 687: 688: if ((*s_etat_processus).langue == 'F') 689: { 690: printf("(titre d'un graphique)\n\n"); 691: } 692: else 693: { 694: printf("(title of graphic)\n\n"); 695: } 696: 697: printf(" 1: %s\n", d_CHN); 698: 699: return; 700: } 701: else if ((*s_etat_processus).test_instruction == 'Y') 702: { 703: (*s_etat_processus).nombre_arguments = -1; 704: return; 705: } 706: 707: if (test_cfsf(s_etat_processus, 31) == d_vrai) 708: { 709: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 710: { 711: return; 712: } 713: } 714: 715: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 716: &s_objet) == d_erreur) 717: { 718: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 719: return; 720: } 721: 722: if ((*s_objet).type == CHN) 723: { 724: free((*s_etat_processus).titre); 725: 726: if (((*s_etat_processus).titre = malloc((strlen((unsigned char *) 727: (*s_objet).objet) + 1) * sizeof(unsigned char))) == NULL) 728: { 729: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 730: return; 731: } 732: 733: strcpy((*s_etat_processus).titre, (unsigned char *) (*s_objet).objet); 734: liberation(s_etat_processus, s_objet); 735: } 736: else 737: { 738: liberation(s_etat_processus, s_objet); 739: 740: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 741: return; 742: } 743: 744: if (test_cfsf(s_etat_processus, 52) == d_faux) 745: { 746: if ((*s_etat_processus).fichiers_graphiques != NULL) 747: { 748: appel_gnuplot(s_etat_processus, 'N'); 749: } 750: } 751: 752: return; 753: } 754: 755: 756: /* 757: ================================================================================ 758: Fonction 'time' 759: ================================================================================ 760: Entrées : 761: -------------------------------------------------------------------------------- 762: Sorties : 763: -------------------------------------------------------------------------------- 764: Effets de bord : néant 765: ================================================================================ 766: */ 767: 768: void 769: instruction_time(struct_processus *s_etat_processus) 770: { 771: struct rusage s_usage_processus_fils; 772: struct rusage s_usage_processus_pere; 773: 774: struct_liste_chainee *l_element_courant; 775: 776: struct_objet *s_objet; 777: 778: (*s_etat_processus).erreur_execution = d_ex; 779: 780: if ((*s_etat_processus).affichage_arguments == 'Y') 781: { 782: printf("\n TIME "); 783: 784: if ((*s_etat_processus).langue == 'F') 785: { 786: printf("(temps CPU)\n\n"); 787: } 788: else 789: { 790: printf("(CPU time)\n\n"); 791: } 792: 793: printf("-> 1: %s\n", d_LST); 794: 795: return; 796: } 797: else if ((*s_etat_processus).test_instruction == 'Y') 798: { 799: (*s_etat_processus).nombre_arguments = -1; 800: return; 801: } 802: 803: if (test_cfsf(s_etat_processus, 31) == d_vrai) 804: { 805: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 806: { 807: return; 808: } 809: } 810: 811: /* 812: * Lecture des différents temps 813: */ 814: 815: # ifndef OS2 816: if ((getrusage(RUSAGE_SELF, &s_usage_processus_pere)) != 0) 817: { 818: (*s_etat_processus).erreur_systeme = d_es_processus; 819: return; 820: } 821: 822: if ((getrusage(RUSAGE_CHILDREN, &s_usage_processus_fils)) != 0) 823: { 824: (*s_etat_processus).erreur_systeme = d_es_processus; 825: return; 826: } 827: # else 828: s_usage_processus_pere.ru_utime.tv_sec = 0; 829: s_usage_processus_pere.ru_utime.tv_usec = 0; 830: s_usage_processus_pere.ru_stime.tv_sec = 0; 831: s_usage_processus_pere.ru_stime.tv_usec = 0; 832: s_usage_processus_fils.ru_utime.tv_sec = 0; 833: s_usage_processus_fils.ru_utime.tv_usec = 0; 834: s_usage_processus_fils.ru_stime.tv_sec = 0; 835: s_usage_processus_fils.ru_stime.tv_usec = 0; 836: # endif 837: 838: /* 839: * Initialisation de la liste 840: */ 841: 842: if ((s_objet = allocation(s_etat_processus, LST)) == NULL) 843: { 844: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 845: return; 846: } 847: 848: /* 849: * User time du processus père (séquenceur) 850: */ 851: 852: if ((l_element_courant = allocation_maillon(s_etat_processus)) == NULL) 853: { 854: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 855: return; 856: } 857: 858: (*s_objet).objet = l_element_courant; 859: 860: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL)) 861: == NULL) 862: { 863: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 864: return; 865: } 866: 867: (*((real8 *) (*(*l_element_courant).donnee).objet)) = 868: s_usage_processus_pere.ru_utime.tv_sec + 869: (((real8) s_usage_processus_pere.ru_utime.tv_usec) / 870: ((real8) 1E6)); 871: 872: /* 873: * System time du processus père 874: */ 875: 876: if (((*l_element_courant).suivant = 877: allocation_maillon(s_etat_processus)) == NULL) 878: { 879: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 880: return; 881: } 882: 883: l_element_courant = (*l_element_courant).suivant; 884: 885: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL)) 886: == NULL) 887: { 888: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 889: return; 890: } 891: 892: (*((real8 *) (*(*l_element_courant).donnee).objet)) = 893: s_usage_processus_pere.ru_stime.tv_sec + 894: (((real8) s_usage_processus_pere.ru_stime.tv_usec) / 895: ((real8) 1E6)); 896: 897: /* 898: * User time des processus fils achevés 899: */ 900: 901: if (((*l_element_courant).suivant = 902: allocation_maillon(s_etat_processus)) == NULL) 903: { 904: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 905: return; 906: } 907: 908: l_element_courant = (*l_element_courant).suivant; 909: 910: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL)) 911: == NULL) 912: { 913: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 914: return; 915: } 916: 917: (*((real8 *) (*(*l_element_courant).donnee).objet)) = 918: s_usage_processus_fils.ru_utime.tv_sec + 919: (((real8) s_usage_processus_fils.ru_utime.tv_usec) / 920: ((real8) 1E6)); 921: 922: /* 923: * System time des processus fils achevés 924: */ 925: 926: if (((*l_element_courant).suivant = 927: allocation_maillon(s_etat_processus)) == NULL) 928: { 929: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 930: return; 931: } 932: 933: l_element_courant = (*l_element_courant).suivant; 934: 935: if (((*l_element_courant).donnee = allocation(s_etat_processus, REL)) 936: == NULL) 937: { 938: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 939: return; 940: } 941: 942: (*((real8 *) (*(*l_element_courant).donnee).objet)) = 943: s_usage_processus_fils.ru_stime.tv_sec + 944: (((real8) s_usage_processus_fils.ru_stime.tv_usec) / 945: ((real8) 1E6)); 946: 947: /* 948: * Fermeture de la liste 949: */ 950: 951: (*l_element_courant).suivant = NULL; 952: 953: /* 954: * Empilement du résultat 955: */ 956: 957: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 958: s_objet) == d_erreur) 959: { 960: return; 961: } 962: 963: return; 964: } 965: 966: 967: /* 968: ================================================================================ 969: Fonction 'taylr' 970: ================================================================================ 971: Entrées : 972: -------------------------------------------------------------------------------- 973: Sorties : 974: -------------------------------------------------------------------------------- 975: Effets de bord : néant 976: ================================================================================ 977: */ 978: 979: void 980: instruction_taylr(struct_processus *s_etat_processus) 981: { 982: integer8 i; 983: 984: logical1 last_valide; 985: logical1 zero; 986: 987: struct_liste_chainee *l_element_courant; 988: 989: struct_objet *s_objet_argument; 990: struct_objet *s_objet_argument_1; 991: struct_objet *s_objet_argument_2; 992: struct_objet *s_objet_argument_3; 993: struct_objet *s_objet_argument_4; 994: struct_objet *s_objet_resultat; 995: struct_objet *s_objet_variable_derivation; 996: 997: struct_variable s_variable; 998: 999: (*s_etat_processus).erreur_execution = d_ex; 1000: 1001: if ((*s_etat_processus).affichage_arguments == 'Y') 1002: { 1003: printf("\n TAYLR "); 1004: 1005: if ((*s_etat_processus).langue == 'F') 1006: { 1007: printf("(série de Taylor)\n\n"); 1008: } 1009: else 1010: { 1011: printf("(Taylor serie)\n\n"); 1012: } 1013: 1014: printf(" 4: %s\n", d_ALG); 1015: printf(" 3: %s\n", d_NOM); 1016: printf(" 2: %s, %s\n", d_INT, d_REL); 1017: printf(" 1: %s\n", d_INT); 1018: printf("-> 1: %s\n\n", d_ALG); 1019: 1020: return; 1021: } 1022: else if ((*s_etat_processus).test_instruction == 'Y') 1023: { 1024: (*s_etat_processus).nombre_arguments = -1; 1025: return; 1026: } 1027: 1028: if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai) 1029: { 1030: if (empilement_pile_last(s_etat_processus, 4) == d_erreur) 1031: { 1032: return; 1033: } 1034: } 1035: 1036: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1037: &s_objet_argument_1) == d_erreur) 1038: { 1039: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1040: return; 1041: } 1042: 1043: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1044: &s_objet_argument_2) == d_erreur) 1045: { 1046: liberation(s_etat_processus, s_objet_argument_1); 1047: 1048: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1049: return; 1050: } 1051: 1052: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1053: &s_objet_argument_3) == d_erreur) 1054: { 1055: liberation(s_etat_processus, s_objet_argument_1); 1056: liberation(s_etat_processus, s_objet_argument_2); 1057: 1058: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1059: return; 1060: } 1061: 1062: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1063: &s_objet_argument_4) == d_erreur) 1064: { 1065: liberation(s_etat_processus, s_objet_argument_1); 1066: liberation(s_etat_processus, s_objet_argument_2); 1067: liberation(s_etat_processus, s_objet_argument_3); 1068: liberation(s_etat_processus, s_objet_argument_4); 1069: 1070: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1071: return; 1072: } 1073: 1074: if (((*s_objet_argument_4).type == ALG) && 1075: ((*s_objet_argument_3).type == NOM) && 1076: (((*s_objet_argument_2).type == INT) || 1077: ((*s_objet_argument_2).type == REL)) && 1078: ((*s_objet_argument_1).type == INT)) 1079: { 1080: if ((*((integer8 *) (*s_objet_argument_1).objet)) <= 0) 1081: { 1082: liberation(s_etat_processus, s_objet_argument_1); 1083: liberation(s_etat_processus, s_objet_argument_2); 1084: liberation(s_etat_processus, s_objet_argument_3); 1085: liberation(s_etat_processus, s_objet_argument_4); 1086: 1087: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 1088: return; 1089: } 1090: 1091: if ((*s_objet_argument_2).type == REL) 1092: { 1093: if ((*((real8 *) (*s_objet_argument_2).objet)) == 0) 1094: { 1095: zero = d_vrai; 1096: } 1097: else 1098: { 1099: zero = d_faux; 1100: } 1101: } 1102: else 1103: { 1104: if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0) 1105: { 1106: zero = d_vrai; 1107: } 1108: else 1109: { 1110: zero = d_faux; 1111: } 1112: } 1113: 1114: /* 1115: * Conversion du drapeau symbole des variables symboliques 1116: */ 1117: 1118: l_element_courant = (*s_objet_argument_4).objet; 1119: 1120: while(l_element_courant != NULL) 1121: { 1122: if ((*(*l_element_courant).donnee).type == NOM) 1123: { 1124: if (strcmp((*((struct_nom *) (*(*l_element_courant).donnee) 1125: .objet)).nom, (*((struct_nom *) (*s_objet_argument_3) 1126: .objet)).nom) == 0) 1127: { 1128: (*((struct_nom *) (*(*l_element_courant).donnee).objet)) 1129: .symbole = d_faux; 1130: } 1131: } 1132: 1133: l_element_courant = (*l_element_courant).suivant; 1134: } 1135: 1136: /* 1137: * Création de la variable locale et initialisation 1138: */ 1139: 1140: (*s_etat_processus).niveau_courant++; 1141: 1142: if ((s_variable.nom = malloc((strlen((*((struct_nom *) 1143: (*s_objet_argument_3).objet)).nom) + 1) * 1144: sizeof(unsigned char))) == NULL) 1145: { 1146: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1147: return; 1148: } 1149: 1150: s_variable.niveau = (*s_etat_processus).niveau_courant; 1151: strcpy(s_variable.nom, (*((struct_nom *) (*s_objet_argument_3) 1152: .objet)).nom); 1153: 1154: if ((s_variable.objet = copie_objet(s_etat_processus, 1155: s_objet_argument_2, 'O')) == NULL) 1156: { 1157: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1158: return; 1159: } 1160: 1161: if (creation_variable(s_etat_processus, &s_variable, 'V', 'P') 1162: == d_erreur) 1163: { 1164: return; 1165: } 1166: 1167: /* 1168: * Création de la série 1169: */ 1170: 1171: if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == NULL) 1172: { 1173: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1174: return; 1175: } 1176: 1177: if (((*s_objet_resultat).objet = 1178: allocation_maillon(s_etat_processus)) == NULL) 1179: { 1180: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1181: return; 1182: } 1183: 1184: l_element_courant = (*s_objet_resultat).objet; 1185: 1186: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1187: == NULL) 1188: { 1189: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1190: return; 1191: } 1192: 1193: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1194: .nombre_arguments = 0; 1195: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1196: .fonction = instruction_vers_niveau_superieur; 1197: 1198: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1199: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 1200: { 1201: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1202: return; 1203: } 1204: 1205: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1206: .nom_fonction, "<<"); 1207: 1208: if (last_valide == d_vrai) 1209: { 1210: cf(s_etat_processus, 31); 1211: } 1212: 1213: /* 1214: * Calcul de la série de Taylor 1215: * 1216: * s(x) = \sum_{i=0}{n} (1/i!)*((d^i f(x=a))/d(x^i)*(x-a)^i) 1217: */ 1218: 1219: for(i = 0; (i <= (*((integer8 *) (*s_objet_argument_1).objet))) && 1220: ((*s_etat_processus).var_volatile_requete_arret == 0); i++) 1221: { 1222: /* 1223: * Calcul de ((d^i f(x=a))/d(x^i)*(x-a)^i)/i! 1224: */ 1225: 1226: if (i != 0) 1227: { 1228: // Calcul de la valeur de la dérivée n-ième 1229: // Expression empilée puis dérivée et sauvegardée dans 1230: // s_argument_4. 1231: 1232: if (empilement(s_etat_processus, &((*s_etat_processus) 1233: .l_base_pile), s_objet_argument_4) == d_erreur) 1234: { 1235: if (last_valide == d_vrai) 1236: { 1237: sf(s_etat_processus, 31); 1238: } 1239: 1240: return; 1241: } 1242: 1243: if ((s_objet_variable_derivation = 1244: copie_objet(s_etat_processus, s_objet_argument_3, 'O')) 1245: == NULL) 1246: { 1247: (*s_etat_processus).erreur_systeme = 1248: d_es_allocation_memoire; 1249: return; 1250: } 1251: 1252: if (empilement(s_etat_processus, &((*s_etat_processus) 1253: .l_base_pile), s_objet_variable_derivation) == d_erreur) 1254: { 1255: if (last_valide == d_vrai) 1256: { 1257: sf(s_etat_processus, 31); 1258: } 1259: 1260: return; 1261: } 1262: 1263: instruction_der(s_etat_processus); 1264: 1265: if ((*s_etat_processus).erreur_execution != d_ex) 1266: { 1267: liberation(s_etat_processus, s_objet_argument_1); 1268: liberation(s_etat_processus, s_objet_argument_2); 1269: liberation(s_etat_processus, s_objet_argument_3); 1270: 1271: (*l_element_courant).suivant = NULL; 1272: 1273: liberation(s_etat_processus, s_objet_resultat); 1274: 1275: if (last_valide == d_vrai) 1276: { 1277: sf(s_etat_processus, 31); 1278: } 1279: 1280: return; 1281: } 1282: else if ((*s_etat_processus).erreur_systeme != d_es) 1283: { 1284: return; 1285: } 1286: 1287: if ((*s_etat_processus).var_volatile_requete_arret != 0) 1288: { 1289: /* 1290: * instruction_der() n'a rien renvoyé dans la pile. On 1291: * injecte une valeur nulle dans s_objet_argument_4. 1292: */ 1293: 1294: if ((s_objet_argument_4 = allocation(s_etat_processus, 1295: INT)) == NULL) 1296: { 1297: (*s_etat_processus).erreur_systeme = 1298: d_es_allocation_memoire; 1299: return; 1300: } 1301: } 1302: else if (depilement(s_etat_processus, &((*s_etat_processus) 1303: .l_base_pile), &s_objet_argument_4) == d_erreur) 1304: { 1305: liberation(s_etat_processus, s_objet_argument_1); 1306: liberation(s_etat_processus, s_objet_argument_2); 1307: liberation(s_etat_processus, s_objet_argument_3); 1308: 1309: (*l_element_courant).suivant = NULL; 1310: 1311: liberation(s_etat_processus, s_objet_resultat); 1312: 1313: if (last_valide == d_vrai) 1314: { 1315: sf(s_etat_processus, 31); 1316: } 1317: 1318: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1319: return; 1320: } 1321: } 1322: 1323: if (evaluation(s_etat_processus, s_objet_argument_4, 'E') 1324: == d_erreur) 1325: { 1326: liberation(s_etat_processus, s_objet_argument_1); 1327: liberation(s_etat_processus, s_objet_argument_2); 1328: liberation(s_etat_processus, s_objet_argument_3); 1329: liberation(s_etat_processus, s_objet_argument_4); 1330: 1331: (*l_element_courant).suivant = NULL; 1332: 1333: liberation(s_etat_processus, s_objet_resultat); 1334: 1335: if (last_valide == d_vrai) 1336: { 1337: sf(s_etat_processus, 31); 1338: } 1339: 1340: return; 1341: } 1342: 1343: // Division par i! 1344: 1345: if (i > 1) 1346: { 1347: 1348: if ((s_objet_argument = allocation(s_etat_processus, INT)) 1349: == NULL) 1350: { 1351: (*s_etat_processus).erreur_systeme = 1352: d_es_allocation_memoire; 1353: return; 1354: } 1355: 1356: (*((integer8 *) (*s_objet_argument).objet)) = i; 1357: 1358: if (empilement(s_etat_processus, &((*s_etat_processus) 1359: .l_base_pile), s_objet_argument) == d_erreur) 1360: { 1361: liberation(s_etat_processus, s_objet_argument_1); 1362: liberation(s_etat_processus, s_objet_argument_2); 1363: liberation(s_etat_processus, s_objet_argument_3); 1364: liberation(s_etat_processus, s_objet_argument_4); 1365: 1366: (*l_element_courant).suivant = NULL; 1367: 1368: liberation(s_etat_processus, s_objet_resultat); 1369: liberation(s_etat_processus, s_objet_argument); 1370: 1371: if (last_valide == d_vrai) 1372: { 1373: sf(s_etat_processus, 31); 1374: } 1375: 1376: return; 1377: } 1378: 1379: if (i > 2) 1380: { 1381: instruction_fact(s_etat_processus); 1382: 1383: if ((*s_etat_processus).erreur_execution != d_ex) 1384: { 1385: liberation(s_etat_processus, s_objet_argument_1); 1386: liberation(s_etat_processus, s_objet_argument_2); 1387: liberation(s_etat_processus, s_objet_argument_3); 1388: liberation(s_etat_processus, s_objet_argument_4); 1389: 1390: (*l_element_courant).suivant = NULL; 1391: 1392: liberation(s_etat_processus, s_objet_resultat); 1393: 1394: if (last_valide == d_vrai) 1395: { 1396: sf(s_etat_processus, 31); 1397: } 1398: 1399: return; 1400: } 1401: else if ((*s_etat_processus).erreur_systeme != d_es) 1402: { 1403: return; 1404: } 1405: } 1406: 1407: instruction_division(s_etat_processus); 1408: 1409: if ((*s_etat_processus).erreur_execution != d_ex) 1410: { 1411: liberation(s_etat_processus, s_objet_argument_1); 1412: liberation(s_etat_processus, s_objet_argument_2); 1413: liberation(s_etat_processus, s_objet_argument_3); 1414: liberation(s_etat_processus, s_objet_argument_4); 1415: 1416: (*l_element_courant).suivant = NULL; 1417: 1418: liberation(s_etat_processus, s_objet_resultat); 1419: 1420: if (last_valide == d_vrai) 1421: { 1422: sf(s_etat_processus, 31); 1423: } 1424: 1425: return; 1426: } 1427: else if ((*s_etat_processus).erreur_systeme != d_es) 1428: { 1429: return; 1430: } 1431: } 1432: 1433: if (((*l_element_courant).suivant = 1434: allocation_maillon(s_etat_processus)) == NULL) 1435: { 1436: (*s_etat_processus).erreur_systeme = 1437: d_es_allocation_memoire; 1438: return; 1439: } 1440: 1441: l_element_courant = (*l_element_courant).suivant; 1442: 1443: if (depilement(s_etat_processus, &((*s_etat_processus) 1444: .l_base_pile), &((*l_element_courant).donnee)) 1445: == d_erreur) 1446: { 1447: liberation(s_etat_processus, s_objet_argument_1); 1448: liberation(s_etat_processus, s_objet_argument_2); 1449: liberation(s_etat_processus, s_objet_argument_3); 1450: liberation(s_etat_processus, s_objet_argument_4); 1451: 1452: (*l_element_courant).donnee = NULL; 1453: (*l_element_courant).suivant = NULL; 1454: 1455: liberation(s_etat_processus, s_objet_resultat); 1456: 1457: if (last_valide == d_vrai) 1458: { 1459: sf(s_etat_processus, 31); 1460: } 1461: 1462: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1463: return; 1464: } 1465: 1466: /* 1467: * Multiplication par le terme (x-a)**i 1468: */ 1469: 1470: if (i != 0) 1471: { 1472: if (((*l_element_courant).suivant = 1473: allocation_maillon(s_etat_processus)) == NULL) 1474: { 1475: (*s_etat_processus).erreur_systeme = 1476: d_es_allocation_memoire; 1477: return; 1478: } 1479: 1480: l_element_courant = (*l_element_courant).suivant; 1481: 1482: if (((*l_element_courant).donnee = 1483: copie_objet(s_etat_processus, s_objet_argument_3, 'O')) 1484: == NULL) 1485: { 1486: (*s_etat_processus).erreur_systeme = 1487: d_es_allocation_memoire; 1488: return; 1489: } 1490: 1491: if (zero == d_faux) 1492: { 1493: if (((*l_element_courant).suivant = 1494: allocation_maillon(s_etat_processus)) == NULL) 1495: { 1496: (*s_etat_processus).erreur_systeme = 1497: d_es_allocation_memoire; 1498: return; 1499: } 1500: 1501: l_element_courant = (*l_element_courant).suivant; 1502: 1503: if (((*l_element_courant).donnee = 1504: copie_objet(s_etat_processus, s_objet_argument_2, 1505: 'O')) == NULL) 1506: { 1507: (*s_etat_processus).erreur_systeme = 1508: d_es_allocation_memoire; 1509: return; 1510: } 1511: 1512: if (((*l_element_courant).suivant = 1513: allocation_maillon(s_etat_processus)) == NULL) 1514: { 1515: (*s_etat_processus).erreur_systeme = 1516: d_es_allocation_memoire; 1517: return; 1518: } 1519: 1520: l_element_courant = (*l_element_courant).suivant; 1521: 1522: if (((*l_element_courant).donnee = 1523: allocation(s_etat_processus, FCT)) == NULL) 1524: { 1525: (*s_etat_processus).erreur_systeme = 1526: d_es_allocation_memoire; 1527: return; 1528: } 1529: 1530: (*((struct_fonction *) (*(*l_element_courant).donnee) 1531: .objet)).nombre_arguments = 0; 1532: (*((struct_fonction *) (*(*l_element_courant).donnee) 1533: .objet)).fonction = instruction_moins; 1534: 1535: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1536: .objet)).nom_fonction = malloc(2 * 1537: sizeof(unsigned char))) == NULL) 1538: { 1539: (*s_etat_processus).erreur_systeme = 1540: d_es_allocation_memoire; 1541: return; 1542: } 1543: 1544: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1545: .objet)).nom_fonction, "-"); 1546: } 1547: 1548: if (i > 1) 1549: { 1550: if (((*l_element_courant).suivant = 1551: allocation_maillon(s_etat_processus)) == NULL) 1552: { 1553: (*s_etat_processus).erreur_systeme = 1554: d_es_allocation_memoire; 1555: return; 1556: } 1557: 1558: l_element_courant = (*l_element_courant).suivant; 1559: 1560: if (((*l_element_courant).donnee = 1561: allocation(s_etat_processus, INT)) == NULL) 1562: { 1563: (*s_etat_processus).erreur_systeme = 1564: d_es_allocation_memoire; 1565: return; 1566: } 1567: 1568: (*((integer8 *) (*(*l_element_courant).donnee).objet)) = i; 1569: 1570: if (((*l_element_courant).suivant = 1571: allocation_maillon(s_etat_processus)) == NULL) 1572: { 1573: (*s_etat_processus).erreur_systeme = 1574: d_es_allocation_memoire; 1575: return; 1576: } 1577: 1578: l_element_courant = (*l_element_courant).suivant; 1579: 1580: if (((*l_element_courant).donnee = 1581: allocation(s_etat_processus, FCT)) == NULL) 1582: { 1583: (*s_etat_processus).erreur_systeme = 1584: d_es_allocation_memoire; 1585: return; 1586: } 1587: 1588: (*((struct_fonction *) (*(*l_element_courant).donnee) 1589: .objet)).nombre_arguments = 0; 1590: (*((struct_fonction *) (*(*l_element_courant).donnee) 1591: .objet)).fonction = instruction_puissance; 1592: 1593: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1594: .objet)).nom_fonction = malloc(2 * 1595: sizeof(unsigned char))) == NULL) 1596: { 1597: (*s_etat_processus).erreur_systeme = 1598: d_es_allocation_memoire; 1599: return; 1600: } 1601: 1602: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1603: .objet)).nom_fonction, "^"); 1604: } 1605: 1606: if (((*l_element_courant).suivant = 1607: allocation_maillon(s_etat_processus)) == NULL) 1608: { 1609: (*s_etat_processus).erreur_systeme = 1610: d_es_allocation_memoire; 1611: return; 1612: } 1613: 1614: l_element_courant = (*l_element_courant).suivant; 1615: 1616: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1617: FCT)) == NULL) 1618: { 1619: (*s_etat_processus).erreur_systeme = 1620: d_es_allocation_memoire; 1621: return; 1622: } 1623: 1624: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1625: .nombre_arguments = 0; 1626: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1627: .fonction = instruction_multiplication; 1628: 1629: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1630: .objet)).nom_fonction = malloc(2 * 1631: sizeof(unsigned char))) == NULL) 1632: { 1633: (*s_etat_processus).erreur_systeme = 1634: d_es_allocation_memoire; 1635: return; 1636: } 1637: 1638: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1639: .objet)).nom_fonction, "*"); 1640: 1641: if (((*l_element_courant).suivant = 1642: allocation_maillon(s_etat_processus)) == NULL) 1643: { 1644: (*s_etat_processus).erreur_systeme = 1645: d_es_allocation_memoire; 1646: return; 1647: } 1648: 1649: l_element_courant = (*l_element_courant).suivant; 1650: 1651: if (((*l_element_courant).donnee = allocation(s_etat_processus, 1652: FCT)) == NULL) 1653: { 1654: (*s_etat_processus).erreur_systeme = 1655: d_es_allocation_memoire; 1656: return; 1657: } 1658: 1659: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1660: .nombre_arguments = 0; 1661: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1662: .fonction = instruction_plus; 1663: 1664: if (((*((struct_fonction *) (*(*l_element_courant).donnee) 1665: .objet)).nom_fonction = malloc(2 * 1666: sizeof(unsigned char))) == NULL) 1667: { 1668: (*s_etat_processus).erreur_systeme = 1669: d_es_allocation_memoire; 1670: return; 1671: } 1672: 1673: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee) 1674: .objet)).nom_fonction, "+"); 1675: } 1676: } 1677: 1678: /* 1679: * Fermeture de l'expression 1680: */ 1681: 1682: if (last_valide == d_vrai) 1683: { 1684: sf(s_etat_processus, 31); 1685: } 1686: 1687: if (((*l_element_courant).suivant = 1688: allocation_maillon(s_etat_processus)) == NULL) 1689: { 1690: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1691: return; 1692: } 1693: 1694: l_element_courant = (*l_element_courant).suivant; 1695: 1696: if (((*l_element_courant).donnee = allocation(s_etat_processus, FCT)) 1697: == NULL) 1698: { 1699: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1700: return; 1701: } 1702: 1703: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1704: .nombre_arguments = 0; 1705: (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1706: .fonction = instruction_vers_niveau_inferieur; 1707: 1708: if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1709: .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL) 1710: { 1711: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1712: return; 1713: } 1714: 1715: strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) 1716: .nom_fonction, ">>"); 1717: 1718: (*l_element_courant).suivant = NULL; 1719: 1720: /* 1721: * Destruction de la variable locale 1722: */ 1723: 1724: (*s_etat_processus).niveau_courant--; 1725: 1726: if (retrait_variable(s_etat_processus, (*((struct_nom *) 1727: (*s_objet_argument_3).objet)).nom, 'L') == d_erreur) 1728: { 1729: liberation(s_etat_processus, s_objet_argument_1); 1730: liberation(s_etat_processus, s_objet_argument_2); 1731: liberation(s_etat_processus, s_objet_argument_3); 1732: liberation(s_etat_processus, s_objet_argument_4); 1733: liberation(s_etat_processus, s_objet_resultat); 1734: 1735: (*s_etat_processus).erreur_execution = d_ex_variable_non_definie; 1736: return; 1737: } 1738: } 1739: else 1740: { 1741: liberation(s_etat_processus, s_objet_argument_1); 1742: liberation(s_etat_processus, s_objet_argument_2); 1743: liberation(s_etat_processus, s_objet_argument_3); 1744: liberation(s_etat_processus, s_objet_argument_4); 1745: 1746: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 1747: return; 1748: } 1749: 1750: liberation(s_etat_processus, s_objet_argument_1); 1751: liberation(s_etat_processus, s_objet_argument_2); 1752: liberation(s_etat_processus, s_objet_argument_3); 1753: liberation(s_etat_processus, s_objet_argument_4); 1754: 1755: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1756: s_objet_resultat) == d_erreur) 1757: { 1758: return; 1759: } 1760: 1761: return; 1762: } 1763: 1764: 1765: /* 1766: ================================================================================ 1767: Fonction 'target' 1768: ================================================================================ 1769: Entrées : 1770: -------------------------------------------------------------------------------- 1771: Sorties : 1772: -------------------------------------------------------------------------------- 1773: Effets de bord : néant 1774: ================================================================================ 1775: */ 1776: 1777: void 1778: instruction_target(struct_processus *s_etat_processus) 1779: { 1780: struct_liste_chainee *l_element_courant; 1781: 1782: struct addrinfo *resolution; 1783: struct addrinfo *resolution_courante; 1784: 1785: struct_objet *s_objet_argument_1; 1786: struct_objet *s_objet_argument_2; 1787: 1788: unsigned long i; 1789: unsigned long nombre_elements; 1790: 1791: (*s_etat_processus).erreur_execution = d_ex; 1792: 1793: if ((*s_etat_processus).affichage_arguments == 'Y') 1794: { 1795: printf("\n TARGET "); 1796: 1797: if ((*s_etat_processus).langue == 'F') 1798: { 1799: printf("(cible d'une socket non connectée)\n\n"); 1800: } 1801: else 1802: { 1803: printf("(target of unconnected socket)\n\n"); 1804: } 1805: 1806: printf(" 2: %s, %s\n", d_CHN, d_LST); 1807: printf(" 1: %s\n", d_SCK); 1808: printf("-> 1: %s\n", d_SCK); 1809: 1810: return; 1811: } 1812: else if ((*s_etat_processus).test_instruction == 'Y') 1813: { 1814: (*s_etat_processus).nombre_arguments = -1; 1815: return; 1816: } 1817: 1818: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1819: { 1820: if (empilement_pile_last(s_etat_processus, 2) == d_erreur) 1821: { 1822: return; 1823: } 1824: } 1825: 1826: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1827: &s_objet_argument_1) == d_erreur) 1828: { 1829: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1830: return; 1831: } 1832: 1833: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1834: &s_objet_argument_2) == d_erreur) 1835: { 1836: liberation(s_etat_processus, s_objet_argument_1); 1837: 1838: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 1839: return; 1840: } 1841: 1842: if ((*s_objet_argument_1).type == SCK) 1843: { 1844: 1845: /* 1846: * Vérification du type de socket 1847: */ 1848: 1849: if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type, 1850: "STREAM") == 0) || (strcmp((*((struct_socket *) 1851: (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM") 1852: == 0)) 1853: { 1854: liberation(s_etat_processus, s_objet_argument_1); 1855: liberation(s_etat_processus, s_objet_argument_2); 1856: 1857: (*s_etat_processus).erreur_execution = 1858: d_ex_erreur_parametre_fichier; 1859: return; 1860: } 1861: 1862: if ((*s_objet_argument_2).type == CHN) 1863: { 1864: /* 1865: * La socket ne peut être que du domaine UNIX 1866: */ 1867: 1868: if ((*((struct_socket *) (*s_objet_argument_1).objet)).domaine 1869: != PF_UNIX) 1870: { 1871: liberation(s_etat_processus, s_objet_argument_1); 1872: liberation(s_etat_processus, s_objet_argument_2); 1873: 1874: (*s_etat_processus).erreur_execution = 1875: d_ex_erreur_parametre_fichier; 1876: return; 1877: } 1878: 1879: free((*((struct_socket *) (*s_objet_argument_1).objet)) 1880: .adresse_distante); 1881: 1882: if (((*((struct_socket *) (*s_objet_argument_1).objet)) 1883: .adresse_distante = transliteration(s_etat_processus, 1884: (unsigned char *) (*s_objet_argument_2).objet, 1885: d_locale, "UTF-8")) == NULL) 1886: { 1887: liberation(s_etat_processus, s_objet_argument_1); 1888: liberation(s_etat_processus, s_objet_argument_2); 1889: 1890: return; 1891: } 1892: } 1893: else if ((*s_objet_argument_2).type == LST) 1894: { 1895: l_element_courant = (struct_liste_chainee *) 1896: (*s_objet_argument_2).objet; 1897: nombre_elements = 0; 1898: 1899: while(l_element_courant != NULL) 1900: { 1901: nombre_elements++; 1902: l_element_courant = (*l_element_courant).suivant; 1903: } 1904: 1905: if (nombre_elements != 2) 1906: { 1907: liberation(s_etat_processus, s_objet_argument_1); 1908: liberation(s_etat_processus, s_objet_argument_2); 1909: 1910: (*s_etat_processus).erreur_execution = 1911: d_ex_erreur_parametre_fichier; 1912: return; 1913: } 1914: 1915: l_element_courant = (struct_liste_chainee *) 1916: (*s_objet_argument_2).objet; 1917: 1918: if ((*(*l_element_courant).donnee).type == VIN) 1919: { 1920: if ((*((struct_vecteur *) (*(*l_element_courant).donnee).objet)) 1921: .taille == 4) 1922: { 1923: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 1924: .domaine != PF_INET) 1925: { 1926: liberation(s_etat_processus, s_objet_argument_1); 1927: liberation(s_etat_processus, s_objet_argument_2); 1928: 1929: (*s_etat_processus).erreur_execution = 1930: d_ex_erreur_parametre_fichier; 1931: return; 1932: } 1933: 1934: free((*((struct_socket *) (*s_objet_argument_1).objet)) 1935: .adresse_distante); 1936: 1937: if (((*((struct_socket *) (*s_objet_argument_1) 1938: .objet)).adresse_distante = malloc(22 * 1939: sizeof(unsigned char))) == NULL) 1940: { 1941: (*s_etat_processus).erreur_systeme = 1942: d_es_allocation_memoire; 1943: return; 1944: } 1945: 1946: (*((struct_socket *) (*s_objet_argument_1).objet)) 1947: .adresse_distante[0] = d_code_fin_chaine; 1948: 1949: for(i = 0; i < 4; i++) 1950: { 1951: if ((((integer8 *) (*((struct_vecteur *) 1952: (*(*l_element_courant).donnee).objet)).tableau) 1953: [i] >= 0) && (((integer8 *) 1954: (*((struct_vecteur *) (*(*l_element_courant) 1955: .donnee).objet)).tableau)[i] <= 255)) 1956: { 1957: sprintf((*((struct_socket *) (*s_objet_argument_1) 1958: .objet)).adresse_distante, 1959: (i == 0) ? "%s%d" : "%s.%d", 1960: (*((struct_socket *) (*s_objet_argument_1) 1961: .objet)).adresse_distante, (int) 1962: ((integer8 *) (*((struct_vecteur *) 1963: (*(*l_element_courant).donnee).objet)) 1964: .tableau)[i]); 1965: } 1966: else 1967: { 1968: liberation(s_etat_processus, s_objet_argument_1); 1969: liberation(s_etat_processus, s_objet_argument_2); 1970: 1971: (*s_etat_processus).erreur_execution = 1972: d_ex_erreur_parametre_fichier; 1973: return; 1974: } 1975: } 1976: } 1977: else if ((*((struct_vecteur *) (*(*l_element_courant).donnee) 1978: .objet)).taille == 16) 1979: { 1980: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 1981: .domaine != PF_INET6) 1982: { 1983: liberation(s_etat_processus, s_objet_argument_1); 1984: liberation(s_etat_processus, s_objet_argument_2); 1985: 1986: (*s_etat_processus).erreur_execution = 1987: d_ex_erreur_parametre_fichier; 1988: return; 1989: } 1990: 1991: free((*((struct_socket *) (*s_objet_argument_1).objet)) 1992: .adresse_distante); 1993: 1994: if (((*((struct_socket *) (*s_objet_argument_1) 1995: .objet)).adresse_distante = malloc(55 * 1996: sizeof(unsigned char))) == NULL) 1997: { 1998: (*s_etat_processus).erreur_systeme = 1999: d_es_allocation_memoire; 2000: return; 2001: } 2002: 2003: (*((struct_socket *) (*s_objet_argument_1).objet)) 2004: .adresse_distante[0] = d_code_fin_chaine; 2005: 2006: for(i = 0; i < 16; i++) 2007: { 2008: if ((((integer8 *) (*((struct_vecteur *) 2009: (*(*l_element_courant).donnee).objet)).tableau) 2010: [i] >= 0) && (((integer8 *) 2011: (*((struct_vecteur *) (*(*l_element_courant) 2012: .donnee).objet)).tableau)[i] <= 255)) 2013: { 2014: sprintf((*((struct_socket *) (*s_objet_argument_1) 2015: .objet)).adresse_distante, 2016: (i == 0) ? "%s%d" : "%s:%X", 2017: (*((struct_socket *) (*s_objet_argument_1) 2018: .objet)).adresse_distante, (int) 2019: ((integer8 *) (*((struct_vecteur *) 2020: (*(*l_element_courant).donnee).objet)) 2021: .tableau)[i]); 2022: } 2023: else 2024: { 2025: liberation(s_etat_processus, s_objet_argument_1); 2026: liberation(s_etat_processus, s_objet_argument_2); 2027: 2028: (*s_etat_processus).erreur_execution = 2029: d_ex_erreur_parametre_fichier; 2030: return; 2031: } 2032: } 2033: } 2034: else 2035: { 2036: liberation(s_etat_processus, s_objet_argument_1); 2037: liberation(s_etat_processus, s_objet_argument_2); 2038: 2039: (*s_etat_processus).erreur_execution = 2040: d_ex_erreur_parametre_fichier; 2041: return; 2042: } 2043: } 2044: else if ((*(*l_element_courant).donnee).type == CHN) 2045: { 2046: resolution = NULL; 2047: 2048: if (getaddrinfo((unsigned char *) (*(*l_element_courant) 2049: .donnee).objet, NULL, NULL, &resolution) != 0) 2050: { 2051: liberation(s_etat_processus, s_objet_argument_1); 2052: liberation(s_etat_processus, s_objet_argument_2); 2053: 2054: if (resolution != NULL) 2055: { 2056: freeaddrinfo(resolution); 2057: } 2058: 2059: (*s_etat_processus).erreur_execution = 2060: d_ex_erreur_acces_fichier; 2061: return; 2062: } 2063: 2064: if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2065: .domaine == PF_INET) 2066: { // Résolution du nom en IPv4 2067: resolution_courante = resolution; 2068: 2069: while(resolution_courante != NULL) 2070: { 2071: if ((*resolution_courante).ai_family == AF_INET) 2072: { 2073: break; 2074: } 2075: 2076: resolution_courante = (*resolution_courante).ai_next; 2077: } 2078: 2079: if (resolution_courante == NULL) 2080: { 2081: liberation(s_etat_processus, s_objet_argument_1); 2082: liberation(s_etat_processus, s_objet_argument_2); 2083: 2084: freeaddrinfo(resolution); 2085: 2086: (*s_etat_processus).erreur_execution = 2087: d_ex_erreur_acces_fichier; 2088: return; 2089: } 2090: 2091: free((*((struct_socket *) (*s_objet_argument_1).objet)) 2092: .adresse_distante); 2093: 2094: if (((*((struct_socket *) (*s_objet_argument_1) 2095: .objet)).adresse_distante = malloc(22 * 2096: sizeof(unsigned char))) == NULL) 2097: { 2098: (*s_etat_processus).erreur_systeme = 2099: d_es_allocation_memoire; 2100: return; 2101: } 2102: 2103: sprintf((*((struct_socket *) (*s_objet_argument_1).objet)) 2104: .adresse_distante, "%d.%d.%d.%d", 2105: (ntohl((*((struct sockaddr_in *) 2106: (*resolution_courante).ai_addr)).sin_addr.s_addr) 2107: >> 24) & 0xFF, 2108: (ntohl((*((struct sockaddr_in *) 2109: (*resolution_courante).ai_addr)).sin_addr.s_addr) 2110: >> 16) & 0xFF, 2111: (ntohl((*((struct sockaddr_in *) 2112: (*resolution_courante).ai_addr)).sin_addr.s_addr) 2113: >> 8) & 0xFF, 2114: ntohl((*((struct sockaddr_in *) 2115: (*resolution_courante).ai_addr)).sin_addr.s_addr) 2116: & 0xFF); 2117: } 2118: else if ((*((struct_socket *) (*s_objet_argument_1).objet)) 2119: .domaine == PF_INET6) 2120: { // Résolution du nom en IPv6 2121: # ifdef IPV6 2122: resolution_courante = resolution; 2123: 2124: while(resolution_courante != NULL) 2125: { 2126: if ((*resolution_courante).ai_family == AF_INET6) 2127: { 2128: break; 2129: } 2130: 2131: resolution_courante = (*resolution_courante).ai_next; 2132: } 2133: 2134: if (resolution_courante == NULL) 2135: { 2136: liberation(s_etat_processus, s_objet_argument_1); 2137: liberation(s_etat_processus, s_objet_argument_2); 2138: 2139: freeaddrinfo(resolution); 2140: 2141: (*s_etat_processus).erreur_execution = 2142: d_ex_erreur_acces_fichier; 2143: return; 2144: } 2145: 2146: if (((*((struct_socket *) (*s_objet_argument_1) 2147: .objet)).adresse_distante = malloc(55 * 2148: sizeof(unsigned char))) == NULL) 2149: { 2150: (*s_etat_processus).erreur_systeme = 2151: d_es_allocation_memoire; 2152: return; 2153: } 2154: 2155: (*((struct_socket *) (*s_objet_argument_1).objet)) 2156: .adresse_distante[0] = d_code_fin_chaine; 2157: 2158: for(i = 0; i < 16; i++) 2159: { 2160: sprintf((*((struct_socket *) (*s_objet_argument_1) 2161: .objet)).adresse_distante, 2162: (i == 0) ? "%s%X" : "%s:%X", 2163: (*((struct_socket *) (*s_objet_argument_1) 2164: .objet)).adresse_distante, 2165: (*((struct sockaddr_in6 *) 2166: (*resolution_courante).ai_addr)).sin6_addr 2167: .s6_addr[i]); 2168: } 2169: # else 2170: if ((*s_etat_processus).langue == 'F') 2171: { 2172: printf("+++Attention : Support du protocole" 2173: " IPv6 indisponible\n"); 2174: } 2175: else 2176: { 2177: printf("+++Warning : IPv6 support " 2178: "unavailable\n"); 2179: } 2180: # endif 2181: } 2182: else 2183: { 2184: liberation(s_etat_processus, s_objet_argument_1); 2185: liberation(s_etat_processus, s_objet_argument_2); 2186: 2187: freeaddrinfo(resolution); 2188: 2189: (*s_etat_processus).erreur_execution = 2190: d_ex_erreur_parametre_fichier; 2191: return; 2192: } 2193: 2194: freeaddrinfo(resolution); 2195: } 2196: else 2197: { 2198: liberation(s_etat_processus, s_objet_argument_1); 2199: liberation(s_etat_processus, s_objet_argument_2); 2200: 2201: (*s_etat_processus).erreur_execution = 2202: d_ex_erreur_parametre_fichier; 2203: return; 2204: } 2205: 2206: l_element_courant = (*l_element_courant).suivant; 2207: 2208: if ((*(*l_element_courant).donnee).type == INT) 2209: { 2210: if (((*((integer8 *) (*(*l_element_courant).donnee).objet)) 2211: >= 0) && ((*((integer8 *) (*(*l_element_courant) 2212: .donnee).objet)) <= 65535)) 2213: { 2214: sprintf((*((struct_socket *) (*s_objet_argument_1) 2215: .objet)).adresse_distante, "%s(%u)", 2216: (*((struct_socket *) (*s_objet_argument_1) 2217: .objet)).adresse_distante, (unsigned int) 2218: (*((integer8 *) (*(*l_element_courant).donnee) 2219: .objet))); 2220: } 2221: else 2222: { 2223: liberation(s_etat_processus, s_objet_argument_1); 2224: liberation(s_etat_processus, s_objet_argument_2); 2225: 2226: (*s_etat_processus).erreur_execution = 2227: d_ex_erreur_parametre_fichier; 2228: return; 2229: } 2230: } 2231: else 2232: { 2233: liberation(s_etat_processus, s_objet_argument_1); 2234: liberation(s_etat_processus, s_objet_argument_2); 2235: 2236: (*s_etat_processus).erreur_execution = 2237: d_ex_erreur_parametre_fichier; 2238: return; 2239: } 2240: } 2241: else 2242: { 2243: liberation(s_etat_processus, s_objet_argument_1); 2244: liberation(s_etat_processus, s_objet_argument_2); 2245: 2246: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 2247: return; 2248: } 2249: } 2250: else 2251: { 2252: liberation(s_etat_processus, s_objet_argument_1); 2253: liberation(s_etat_processus, s_objet_argument_2); 2254: 2255: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 2256: return; 2257: } 2258: 2259: liberation(s_etat_processus, s_objet_argument_2); 2260: 2261: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2262: s_objet_argument_1) == d_erreur) 2263: { 2264: return; 2265: } 2266: 2267: return; 2268: } 2269: 2270: 2271: /* 2272: ================================================================================ 2273: Fonction 'tail' 2274: ================================================================================ 2275: Entrées : 2276: -------------------------------------------------------------------------------- 2277: Sorties : 2278: -------------------------------------------------------------------------------- 2279: Effets de bord : néant 2280: ================================================================================ 2281: */ 2282: 2283: void 2284: instruction_tail(struct_processus *s_etat_processus) 2285: { 2286: integer8 longueur; 2287: 2288: struct_liste_chainee *l_element_courant; 2289: 2290: struct_objet *s_objet_argument; 2291: struct_objet *s_objet_resultat; 2292: 2293: (*s_etat_processus).erreur_execution = d_ex; 2294: 2295: if ((*s_etat_processus).affichage_arguments == 'Y') 2296: { 2297: printf("\n TAIL "); 2298: 2299: if ((*s_etat_processus).langue == 'F') 2300: { 2301: printf("(remplace une liste par tous ses éléments hormis " 2302: "son premier)\n\n"); 2303: } 2304: else 2305: { 2306: printf("(replace a list by all but its first element)\n\n"); 2307: } 2308: 2309: printf(" 1: %s\n", d_LST); 2310: printf("-> 1: %s\n", d_LST); 2311: 2312: return; 2313: } 2314: else if ((*s_etat_processus).test_instruction == 'Y') 2315: { 2316: (*s_etat_processus).nombre_arguments = -1; 2317: return; 2318: } 2319: 2320: if (test_cfsf(s_etat_processus, 31) == d_vrai) 2321: { 2322: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 2323: { 2324: return; 2325: } 2326: } 2327: 2328: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2329: &s_objet_argument) == d_erreur) 2330: { 2331: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 2332: return; 2333: } 2334: 2335: if ((*s_objet_argument).type == LST) 2336: { 2337: l_element_courant = (*s_objet_argument).objet; 2338: longueur = 0; 2339: 2340: while(l_element_courant != NULL) 2341: { 2342: longueur++; 2343: l_element_courant = (*l_element_courant).suivant; 2344: } 2345: 2346: if (longueur == 0) 2347: { 2348: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 2349: == NULL) 2350: { 2351: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2352: return; 2353: } 2354: 2355: (*s_objet_resultat).objet = NULL; 2356: } 2357: else 2358: { 2359: if ((s_objet_resultat = copie_objet(s_etat_processus, 2360: s_objet_argument, 'N')) == NULL) 2361: { 2362: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 2363: return; 2364: } 2365: 2366: l_element_courant = (*s_objet_resultat).objet; 2367: 2368: (*s_objet_resultat).objet = (*((struct_liste_chainee *) 2369: (*s_objet_resultat).objet)).suivant; 2370: 2371: liberation(s_etat_processus, (*l_element_courant).donnee); 2372: free(l_element_courant); 2373: } 2374: } 2375: else 2376: { 2377: liberation(s_etat_processus, s_objet_argument); 2378: 2379: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 2380: return; 2381: } 2382: 2383: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 2384: s_objet_resultat) == d_erreur) 2385: { 2386: return; 2387: } 2388: 2389: liberation(s_etat_processus, s_objet_argument); 2390: 2391: return; 2392: } 2393: 2394: // vim: ts=4