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