![]() ![]() | ![]() |
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 'slice' 29: ================================================================================ 30: Entrées : 31: -------------------------------------------------------------------------------- 32: Sorties : 33: -------------------------------------------------------------------------------- 34: Effets de bord : néant 35: ================================================================================ 36: */ 37: 38: void 39: instruction_slice(struct_processus *s_etat_processus) 40: { 41: (*s_etat_processus).erreur_execution = d_ex; 42: 43: if ((*s_etat_processus).affichage_arguments == 'Y') 44: { 45: printf("\n SLICE "); 46: 47: if ((*s_etat_processus).langue == 'F') 48: { 49: printf("(graphique tridimensionnel avec courbes de niveau)\n\n"); 50: printf(" Aucun argument\n"); 51: } 52: else 53: { 54: printf("(3D graph with contour lines)\n\n"); 55: printf(" No argument\n"); 56: } 57: 58: return; 59: } 60: else if ((*s_etat_processus).test_instruction == 'Y') 61: { 62: (*s_etat_processus).nombre_arguments = -1; 63: return; 64: } 65: 66: # ifndef GNUPLOT_SUPPORT 67: if ((*s_etat_processus).langue == 'F') 68: { 69: printf("+++Attention : Support de GnuPlot non compilé !\n"); 70: } 71: else 72: { 73: printf("+++Warning : GnuPlot not available !\n"); 74: } 75: 76: fflush(stdout); 77: 78: return; 79: # endif 80: 81: strcpy((*s_etat_processus).type_trace_eq, "COURBES DE NIVEAU"); 82: 83: return; 84: } 85: 86: 87: /* 88: ================================================================================ 89: Fonction 'slicescale' 90: ================================================================================ 91: Entrées : 92: -------------------------------------------------------------------------------- 93: Sorties : 94: -------------------------------------------------------------------------------- 95: Effets de bord : néant 96: ================================================================================ 97: */ 98: 99: void 100: instruction_slicescale(struct_processus *s_etat_processus) 101: { 102: int automatique; 103: int discret; 104: int incremental; 105: 106: long nombre_arguments; 107: 108: struct_liste_chainee *l_element_courant; 109: struct_liste_chainee *l_element_courant_resultat; 110: 111: struct_objet *s_objet_argument; 112: struct_objet *s_objet_auxiliaire; 113: struct_objet *s_objet_resultat; 114: 115: unsigned char *tampon; 116: 117: (*s_etat_processus).erreur_execution = d_ex; 118: 119: if ((*s_etat_processus).affichage_arguments == 'Y') 120: { 121: printf("\n SLICESCALE "); 122: 123: if ((*s_etat_processus).langue == 'F') 124: { 125: printf("(définition des courbes de niveau)\n\n"); 126: } 127: else 128: { 129: printf("(definition of contour lines)\n\n"); 130: } 131: 132: printf(" 1: %s\n\n", d_LST); 133: 134: if ((*s_etat_processus).langue == 'F') 135: { 136: printf(" Utilisation :\n\n"); 137: } 138: else 139: { 140: printf(" Usage:\n\n"); 141: } 142: 143: printf(" { { Xmin Xmax} { Ymin Ymax } { Zmin Zmax} } SCALE\n"); 144: printf(" To be fixed!\n"); 145: /* 146: AUTOMATIC 147: DISCRETE 148: INCREMENTAL 149: */ 150: 151: return; 152: } 153: else if ((*s_etat_processus).test_instruction == 'Y') 154: { 155: (*s_etat_processus).nombre_arguments = -1; 156: return; 157: } 158: 159: if (test_cfsf(s_etat_processus, 31) == d_vrai) 160: { 161: if (empilement_pile_last(s_etat_processus, 1) == d_erreur) 162: { 163: return; 164: } 165: } 166: 167: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 168: &s_objet_argument) == d_erreur) 169: { 170: (*s_etat_processus).erreur_execution = d_ex_manque_argument; 171: return; 172: } 173: 174: if ((*s_objet_argument).type == LST) 175: { 176: l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet; 177: 178: automatique = 0; 179: discret = 0; 180: incremental = 0; 181: 182: nombre_arguments = 0; 183: 184: while(l_element_courant != NULL) 185: { 186: if ((*(*l_element_courant).donnee).type == CHN) 187: { 188: if ((tampon = conversion_majuscule((unsigned char *) 189: (*(*l_element_courant).donnee).objet)) == NULL) 190: { 191: (*s_etat_processus).erreur_systeme = 192: d_es_allocation_memoire; 193: return; 194: } 195: 196: if (strcmp(tampon, "AUTOMATIC") == 0) 197: { 198: automatique++; 199: } 200: else if (strcmp(tampon, "DISCRETE") == 0) 201: { 202: discret++; 203: } 204: else if (strcmp(tampon, "INCREMENTAL") == 0) 205: { 206: incremental++; 207: } 208: else 209: { 210: free(tampon); 211: liberation(s_etat_processus, s_objet_argument); 212: 213: (*s_etat_processus).erreur_execution = 214: d_ex_argument_invalide; 215: return; 216: } 217: 218: free(tampon); 219: } 220: 221: l_element_courant = (*l_element_courant).suivant; 222: nombre_arguments++; 223: } 224: 225: if ((automatique + discret + incremental) == 1) 226: { 227: if (automatique == 1) 228: { 229: if (nombre_arguments > 2) 230: { 231: liberation(s_etat_processus, s_objet_argument); 232: 233: (*s_etat_processus).erreur_execution = 234: d_ex_argument_invalide; 235: return; 236: } 237: } 238: else if (discret == 1) 239: { 240: if (nombre_arguments < 2) 241: { 242: liberation(s_etat_processus, s_objet_argument); 243: 244: (*s_etat_processus).erreur_execution = 245: d_ex_argument_invalide; 246: return; 247: } 248: } 249: else if (incremental == 1) 250: { 251: if ((nombre_arguments < 3) || (nombre_arguments > 4)) 252: { 253: liberation(s_etat_processus, s_objet_argument); 254: 255: (*s_etat_processus).erreur_execution = 256: d_ex_argument_invalide; 257: return; 258: } 259: } 260: else 261: { 262: liberation(s_etat_processus, s_objet_argument); 263: 264: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 265: return; 266: } 267: 268: if ((s_objet_resultat = allocation(s_etat_processus, LST)) 269: == NULL) 270: { 271: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 272: return; 273: } 274: 275: if (((*s_objet_resultat).objet = 276: allocation_maillon(s_etat_processus)) == NULL) 277: { 278: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 279: return; 280: } 281: 282: l_element_courant_resultat = (*s_objet_resultat).objet; 283: (*l_element_courant_resultat).suivant = NULL; 284: 285: if (((*l_element_courant_resultat).donnee = 286: allocation(s_etat_processus, CHN)) == NULL) 287: { 288: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 289: return; 290: } 291: 292: if (automatique == 1) 293: { 294: if (((*(*l_element_courant_resultat).donnee).objet = malloc( 295: 10 * sizeof(unsigned char))) == NULL) 296: { 297: (*s_etat_processus).erreur_systeme = 298: d_es_allocation_memoire; 299: return; 300: } 301: 302: strcpy((*(*l_element_courant_resultat).donnee).objet, 303: "AUTOMATIC"); 304: } 305: else if (discret == 1) 306: { 307: if (((*(*l_element_courant_resultat).donnee).objet = malloc( 308: 9 * sizeof(unsigned char))) == NULL) 309: { 310: (*s_etat_processus).erreur_systeme = 311: d_es_allocation_memoire; 312: return; 313: } 314: 315: strcpy((*(*l_element_courant_resultat).donnee).objet, 316: "DISCRETE"); 317: } 318: else 319: { 320: if (((*(*l_element_courant_resultat).donnee).objet = malloc( 321: 12 * sizeof(unsigned char))) == NULL) 322: { 323: (*s_etat_processus).erreur_systeme = 324: d_es_allocation_memoire; 325: return; 326: } 327: 328: strcpy((*(*l_element_courant_resultat).donnee).objet, 329: "INCREMENTAL"); 330: } 331: 332: // Récupération des paramètres numériques 333: 334: l_element_courant = (struct_liste_chainee *) 335: (*s_objet_argument).objet; 336: 337: while(l_element_courant != NULL) 338: { 339: if ((*(*l_element_courant).donnee).type != CHN) 340: { 341: if (((*(*l_element_courant).donnee).type == ALG) || 342: ((*(*l_element_courant).donnee).type == RPN) || 343: ((*(*l_element_courant).donnee).type == NOM)) 344: { 345: if (evaluation(s_etat_processus, 346: (*l_element_courant).donnee, 'N') 347: == d_erreur) 348: { 349: liberation(s_etat_processus, s_objet_argument); 350: liberation(s_etat_processus, s_objet_resultat); 351: 352: return; 353: } 354: 355: if (depilement(s_etat_processus, 356: &((*s_etat_processus).l_base_pile), 357: &s_objet_auxiliaire) == d_erreur) 358: { 359: liberation(s_etat_processus, s_objet_argument); 360: liberation(s_etat_processus, s_objet_resultat); 361: 362: (*s_etat_processus).erreur_execution = 363: d_ex_manque_argument; 364: return; 365: } 366: 367: liberation(s_etat_processus, 368: (*l_element_courant).donnee); 369: (*l_element_courant).donnee = s_objet_auxiliaire; 370: } 371: 372: if (((*(*l_element_courant).donnee).type == INT) || 373: ((*(*l_element_courant).donnee).type == REL)) 374: { 375: if (((*l_element_courant_resultat).suivant = 376: allocation_maillon(s_etat_processus)) == NULL) 377: { 378: (*s_etat_processus).erreur_systeme = 379: d_es_allocation_memoire; 380: return; 381: } 382: 383: l_element_courant_resultat = 384: (*l_element_courant_resultat).suivant; 385: (*l_element_courant_resultat).suivant = NULL; 386: 387: if (((*l_element_courant_resultat).donnee = 388: copie_objet(s_etat_processus, 389: (*l_element_courant).donnee, 'O')) 390: == NULL) 391: { 392: (*s_etat_processus).erreur_systeme = 393: d_es_allocation_memoire; 394: return; 395: } 396: } 397: else 398: { 399: liberation(s_etat_processus, s_objet_argument); 400: liberation(s_etat_processus, s_objet_resultat); 401: 402: (*s_etat_processus).erreur_execution = 403: d_ex_erreur_type_argument; 404: return; 405: } 406: } 407: 408: l_element_courant = (*l_element_courant).suivant; 409: } 410: 411: liberation(s_etat_processus, 412: (*s_etat_processus).parametres_courbes_de_niveau); 413: (*s_etat_processus).parametres_courbes_de_niveau = 414: s_objet_resultat; 415: } 416: else 417: { 418: liberation(s_etat_processus, s_objet_argument); 419: 420: (*s_etat_processus).erreur_execution = d_ex_argument_invalide; 421: return; 422: } 423: } 424: else 425: { 426: liberation(s_etat_processus, s_objet_argument); 427: 428: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; 429: return; 430: } 431: 432: liberation(s_etat_processus, s_objet_argument); 433: 434: if (test_cfsf(s_etat_processus, 52) == d_faux) 435: { 436: if ((*s_etat_processus).fichiers_graphiques != NULL) 437: { 438: appel_gnuplot(s_etat_processus, 'N'); 439: } 440: } 441: 442: return; 443: } 444: 445: 446: /* 447: ================================================================================ 448: Fonction 'sx' 449: ================================================================================ 450: Entrées : pointeur sur une structure struct_processus 451: -------------------------------------------------------------------------------- 452: Sorties : 453: -------------------------------------------------------------------------------- 454: Effets de bord : néant 455: ================================================================================ 456: */ 457: 458: void 459: instruction_sx(struct_processus *s_etat_processus) 460: { 461: struct_objet *s_objet_statistique; 462: struct_objet *s_objet_resultat; 463: 464: struct_vecteur *resultat; 465: 466: unsigned long nombre_colonnes; 467: 468: (*s_etat_processus).erreur_execution = d_ex; 469: 470: if ((*s_etat_processus).affichage_arguments == 'Y') 471: { 472: printf("\n SX "); 473: 474: if ((*s_etat_processus).langue == 'F') 475: { 476: printf("(somme sur la colonne X)\n\n"); 477: } 478: else 479: { 480: printf("(sum on X column)\n\n"); 481: } 482: 483: printf("-> 1: %s, %s\n", d_INT, d_REL); 484: 485: return; 486: } 487: else if ((*s_etat_processus).test_instruction == 'Y') 488: { 489: (*s_etat_processus).nombre_arguments = -1; 490: return; 491: } 492: 493: if (test_cfsf(s_etat_processus, 31) == d_vrai) 494: { 495: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 496: { 497: return; 498: } 499: } 500: 501: /* 502: * Recherche d'une variable globale référencée par SIGMA 503: */ 504: 505: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux) 506: { 507: /* 508: * Aucune variable SIGMA 509: */ 510: 511: (*s_etat_processus).erreur_systeme = d_es; 512: 513: if ((*s_etat_processus).erreur_execution == d_ex) 514: { 515: (*s_etat_processus).erreur_execution = d_ex_absence_observations; 516: } 517: 518: return; 519: } 520: else 521: { 522: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet) 523: .type != MIN) && ((*(*(*s_etat_processus) 524: .pointeur_variable_courante).objet).type != MRL)) 525: { 526: (*s_etat_processus).erreur_execution = 527: d_ex_matrice_statistique_invalide; 528: return; 529: } 530: 531: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus) 532: .pointeur_variable_courante).objet).objet)) 533: .nombre_colonnes; 534: } 535: 536: if (((*s_etat_processus).colonne_statistique_1 < 1) || 537: ((*s_etat_processus).colonne_statistique_1 > (integer8) 538: nombre_colonnes)) 539: { 540: (*s_etat_processus).erreur_execution = d_ex_observations_inexistantes; 541: return; 542: } 543: 544: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante) 545: .objet; 546: 547: if (((*s_objet_statistique).type == MIN) || 548: ((*s_objet_statistique).type == MRL)) 549: { 550: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL) 551: { 552: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 553: return; 554: } 555: 556: if ((resultat = sommation_colonne_statistique( 557: (struct_matrice *) (*s_objet_statistique).objet, 558: (*s_etat_processus).colonne_statistique_1)) == NULL) 559: { 560: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 561: return; 562: } 563: 564: if ((*resultat).type == 'I') 565: { 566: (*s_objet_resultat).type = INT; 567: 568: if (((*s_objet_resultat).objet = malloc(sizeof(integer8))) == NULL) 569: { 570: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 571: return; 572: } 573: 574: (*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *) 575: (*resultat).tableau)); 576: } 577: else 578: { 579: (*s_objet_resultat).type = REL; 580: 581: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL) 582: { 583: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 584: return; 585: } 586: 587: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) 588: (*resultat).tableau)); 589: } 590: 591: free((*resultat).tableau); 592: free(resultat); 593: 594: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 595: s_objet_resultat) == d_erreur) 596: { 597: return; 598: } 599: } 600: else 601: { 602: (*s_etat_processus).erreur_execution = 603: d_ex_matrice_statistique_invalide; 604: return; 605: } 606: 607: return; 608: } 609: 610: 611: /* 612: ================================================================================ 613: Fonction 'sy' 614: ================================================================================ 615: Entrées : pointeur sur une structure struct_processus 616: -------------------------------------------------------------------------------- 617: Sorties : 618: -------------------------------------------------------------------------------- 619: Effets de bord : néant 620: ================================================================================ 621: */ 622: 623: void 624: instruction_sy(struct_processus *s_etat_processus) 625: { 626: struct_objet *s_objet_statistique; 627: struct_objet *s_objet_resultat; 628: 629: struct_vecteur *resultat; 630: 631: unsigned long nombre_colonnes; 632: 633: (*s_etat_processus).erreur_execution = d_ex; 634: 635: if ((*s_etat_processus).affichage_arguments == 'Y') 636: { 637: printf("\n SY "); 638: 639: if ((*s_etat_processus).langue == 'F') 640: { 641: printf("(somme sur la colonne Y)\n\n"); 642: } 643: else 644: { 645: printf("(sum on Y column)\n\n"); 646: } 647: 648: printf("-> 1: %s, %s\n", d_INT, d_REL); 649: 650: return; 651: } 652: else if ((*s_etat_processus).test_instruction == 'Y') 653: { 654: (*s_etat_processus).nombre_arguments = -1; 655: return; 656: } 657: 658: if (test_cfsf(s_etat_processus, 31) == d_vrai) 659: { 660: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 661: { 662: return; 663: } 664: } 665: 666: /* 667: * Recherche d'une variable globale référencée par SIGMA 668: */ 669: 670: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux) 671: { 672: /* 673: * Aucune variable SIGMA 674: */ 675: 676: (*s_etat_processus).erreur_systeme = d_es; 677: 678: if ((*s_etat_processus).erreur_execution == d_ex) 679: { 680: (*s_etat_processus).erreur_execution = d_ex_absence_observations; 681: } 682: 683: return; 684: } 685: else 686: { 687: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet) 688: .type != MIN) && ((*(*(*s_etat_processus) 689: .pointeur_variable_courante).objet).type != MRL)) 690: { 691: (*s_etat_processus).erreur_execution = 692: d_ex_matrice_statistique_invalide; 693: return; 694: } 695: 696: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus) 697: .pointeur_variable_courante).objet).objet)) 698: .nombre_colonnes; 699: } 700: 701: if (((*s_etat_processus).colonne_statistique_2 < 1) || 702: ((*s_etat_processus).colonne_statistique_2 > (integer8) 703: nombre_colonnes)) 704: { 705: (*s_etat_processus).erreur_execution = d_ex_observations_inexistantes; 706: return; 707: } 708: 709: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante) 710: .objet; 711: 712: if (((*s_objet_statistique).type == MIN) || 713: ((*s_objet_statistique).type == MRL)) 714: { 715: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL) 716: { 717: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 718: return; 719: } 720: 721: if ((resultat = sommation_colonne_statistique( 722: (struct_matrice *) (*s_objet_statistique).objet, 723: (*s_etat_processus).colonne_statistique_2)) == NULL) 724: { 725: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 726: return; 727: } 728: 729: if ((*resultat).type == 'I') 730: { 731: (*s_objet_resultat).type = INT; 732: 733: if (((*s_objet_resultat).objet = malloc(sizeof(integer8))) == NULL) 734: { 735: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 736: return; 737: } 738: 739: (*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *) 740: (*resultat).tableau)); 741: } 742: else 743: { 744: (*s_objet_resultat).type = REL; 745: 746: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL) 747: { 748: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 749: return; 750: } 751: 752: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) 753: (*resultat).tableau)); 754: } 755: 756: free((*resultat).tableau); 757: free(resultat); 758: 759: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 760: s_objet_resultat) == d_erreur) 761: { 762: return; 763: } 764: } 765: else 766: { 767: (*s_etat_processus).erreur_execution = 768: d_ex_matrice_statistique_invalide; 769: return; 770: } 771: 772: return; 773: } 774: 775: 776: /* 777: ================================================================================ 778: Fonction 'sxy' 779: ================================================================================ 780: Entrées : pointeur sur une structure struct_processus 781: -------------------------------------------------------------------------------- 782: Sorties : 783: -------------------------------------------------------------------------------- 784: Effets de bord : néant 785: ================================================================================ 786: */ 787: 788: void 789: instruction_sxy(struct_processus *s_etat_processus) 790: { 791: struct_objet *s_objet_statistique; 792: struct_objet *s_objet_resultat; 793: 794: struct_vecteur *resultat; 795: 796: unsigned long nombre_colonnes; 797: 798: (*s_etat_processus).erreur_execution = d_ex; 799: 800: if ((*s_etat_processus).affichage_arguments == 'Y') 801: { 802: printf("\n SXY "); 803: 804: if ((*s_etat_processus).langue == 'F') 805: { 806: printf("(somme des produits des colonne X et Y)\n\n"); 807: } 808: else 809: { 810: printf("(sum of X and Y colums products)\n\n"); 811: } 812: 813: printf("-> 1: %s, %s\n", d_INT, d_REL); 814: 815: return; 816: } 817: else if ((*s_etat_processus).test_instruction == 'Y') 818: { 819: (*s_etat_processus).nombre_arguments = -1; 820: return; 821: } 822: 823: if (test_cfsf(s_etat_processus, 31) == d_vrai) 824: { 825: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 826: { 827: return; 828: } 829: } 830: 831: /* 832: * Recherche d'une variable globale référencée par SIGMA 833: */ 834: 835: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux) 836: { 837: /* 838: * Aucune variable SIGMA 839: */ 840: 841: (*s_etat_processus).erreur_systeme = d_es; 842: 843: if ((*s_etat_processus).erreur_execution == d_ex) 844: { 845: (*s_etat_processus).erreur_execution = d_ex_absence_observations; 846: } 847: 848: return; 849: } 850: else 851: { 852: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet) 853: .type != MIN) && ((*(*(*s_etat_processus) 854: .pointeur_variable_courante).objet).type != MRL)) 855: { 856: (*s_etat_processus).erreur_execution = 857: d_ex_matrice_statistique_invalide; 858: return; 859: } 860: 861: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus) 862: .pointeur_variable_courante).objet).objet)) 863: .nombre_colonnes; 864: } 865: 866: if (((*s_etat_processus).colonne_statistique_1 < 1) || 867: ((*s_etat_processus).colonne_statistique_1 > (integer8) 868: nombre_colonnes) || ((*s_etat_processus).colonne_statistique_2 < 1) 869: || ((*s_etat_processus).colonne_statistique_2 > (integer8) 870: nombre_colonnes)) 871: { 872: (*s_etat_processus).erreur_execution = d_ex_observations_inexistantes; 873: return; 874: } 875: 876: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante) 877: .objet; 878: 879: if (((*s_objet_statistique).type == MIN) || 880: ((*s_objet_statistique).type == MRL)) 881: { 882: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL) 883: { 884: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 885: return; 886: } 887: 888: if ((resultat = sommation_produits_colonnes_statistiques( 889: (struct_matrice *) (*s_objet_statistique).objet, 890: (*s_etat_processus).colonne_statistique_1, 891: (*s_etat_processus).colonne_statistique_2)) == NULL) 892: { 893: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 894: return; 895: } 896: 897: if ((*resultat).type == 'I') 898: { 899: (*s_objet_resultat).type = INT; 900: 901: if (((*s_objet_resultat).objet = malloc(sizeof(integer8))) == NULL) 902: { 903: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 904: return; 905: } 906: 907: (*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *) 908: (*resultat).tableau)); 909: } 910: else 911: { 912: (*s_objet_resultat).type = REL; 913: 914: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL) 915: { 916: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 917: return; 918: } 919: 920: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) 921: (*resultat).tableau)); 922: } 923: 924: free((*resultat).tableau); 925: free(resultat); 926: 927: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 928: s_objet_resultat) == d_erreur) 929: { 930: return; 931: } 932: } 933: else 934: { 935: (*s_etat_processus).erreur_execution = 936: d_ex_matrice_statistique_invalide; 937: return; 938: } 939: 940: return; 941: } 942: 943: 944: /* 945: ================================================================================ 946: Fonction 'sx2' 947: ================================================================================ 948: Entrées : pointeur sur une structure struct_processus 949: -------------------------------------------------------------------------------- 950: Sorties : 951: -------------------------------------------------------------------------------- 952: Effets de bord : néant 953: ================================================================================ 954: */ 955: 956: void 957: instruction_sx2(struct_processus *s_etat_processus) 958: { 959: struct_objet *s_objet_statistique; 960: struct_objet *s_objet_resultat; 961: 962: struct_vecteur *resultat; 963: 964: unsigned long nombre_colonnes; 965: 966: (*s_etat_processus).erreur_execution = d_ex; 967: 968: if ((*s_etat_processus).affichage_arguments == 'Y') 969: { 970: printf("\n SX2 "); 971: 972: if ((*s_etat_processus).langue == 'F') 973: { 974: printf("(somme des carrés de la colonne X)\n\n"); 975: } 976: else 977: { 978: printf("(sum of column X squares)\n\n"); 979: } 980: 981: printf("-> 1: %s, %s\n", d_INT, d_REL); 982: 983: return; 984: } 985: else if ((*s_etat_processus).test_instruction == 'Y') 986: { 987: (*s_etat_processus).nombre_arguments = -1; 988: return; 989: } 990: 991: if (test_cfsf(s_etat_processus, 31) == d_vrai) 992: { 993: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 994: { 995: return; 996: } 997: } 998: 999: /* 1000: * Recherche d'une variable globale référencée par SIGMA 1001: */ 1002: 1003: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux) 1004: { 1005: /* 1006: * Aucune variable SIGMA 1007: */ 1008: 1009: (*s_etat_processus).erreur_systeme = d_es; 1010: 1011: if ((*s_etat_processus).erreur_execution == d_ex) 1012: { 1013: (*s_etat_processus).erreur_execution = d_ex_absence_observations; 1014: } 1015: 1016: return; 1017: } 1018: else 1019: { 1020: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet) 1021: .type != MIN) && ((*(*(*s_etat_processus) 1022: .pointeur_variable_courante).objet).type != MRL)) 1023: { 1024: (*s_etat_processus).erreur_execution = 1025: d_ex_matrice_statistique_invalide; 1026: return; 1027: } 1028: 1029: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus) 1030: .pointeur_variable_courante).objet).objet)) 1031: .nombre_colonnes; 1032: } 1033: 1034: if (((*s_etat_processus).colonne_statistique_1 < 1) || 1035: ((*s_etat_processus).colonne_statistique_1 > (integer8) 1036: nombre_colonnes)) 1037: { 1038: (*s_etat_processus).erreur_execution = d_ex_observations_inexistantes; 1039: return; 1040: } 1041: 1042: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante) 1043: .objet; 1044: 1045: if (((*s_objet_statistique).type == MIN) || 1046: ((*s_objet_statistique).type == MRL)) 1047: { 1048: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL) 1049: { 1050: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1051: return; 1052: } 1053: 1054: if ((resultat = sommation_produits_colonnes_statistiques( 1055: (struct_matrice *) (*s_objet_statistique).objet, 1056: (*s_etat_processus).colonne_statistique_1, 1057: (*s_etat_processus).colonne_statistique_1)) == NULL) 1058: { 1059: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1060: return; 1061: } 1062: 1063: if ((*resultat).type == 'I') 1064: { 1065: (*s_objet_resultat).type = INT; 1066: 1067: if (((*s_objet_resultat).objet = malloc(sizeof(integer8))) == NULL) 1068: { 1069: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1070: return; 1071: } 1072: 1073: (*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *) 1074: (*resultat).tableau)); 1075: } 1076: else 1077: { 1078: (*s_objet_resultat).type = REL; 1079: 1080: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL) 1081: { 1082: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1083: return; 1084: } 1085: 1086: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) 1087: (*resultat).tableau)); 1088: } 1089: 1090: free((*resultat).tableau); 1091: free(resultat); 1092: 1093: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1094: s_objet_resultat) == d_erreur) 1095: { 1096: return; 1097: } 1098: } 1099: else 1100: { 1101: (*s_etat_processus).erreur_execution = 1102: d_ex_matrice_statistique_invalide; 1103: return; 1104: } 1105: 1106: return; 1107: } 1108: 1109: 1110: /* 1111: ================================================================================ 1112: Fonction 'sy2' 1113: ================================================================================ 1114: Entrées : pointeur sur une structure struct_processus 1115: -------------------------------------------------------------------------------- 1116: Sorties : 1117: -------------------------------------------------------------------------------- 1118: Effets de bord : néant 1119: ================================================================================ 1120: */ 1121: 1122: void 1123: instruction_sy2(struct_processus *s_etat_processus) 1124: { 1125: struct_objet *s_objet_statistique; 1126: struct_objet *s_objet_resultat; 1127: 1128: struct_vecteur *resultat; 1129: 1130: unsigned long nombre_colonnes; 1131: 1132: (*s_etat_processus).erreur_execution = d_ex; 1133: 1134: if ((*s_etat_processus).affichage_arguments == 'Y') 1135: { 1136: printf("\n SY2 "); 1137: 1138: if ((*s_etat_processus).langue == 'F') 1139: { 1140: printf("(somme des carrés de la colonne Y)\n\n"); 1141: } 1142: else 1143: { 1144: printf("(sum of column Y squares)\n\n"); 1145: } 1146: 1147: printf("-> 1: %s, %s\n", d_INT, d_REL); 1148: 1149: return; 1150: } 1151: else if ((*s_etat_processus).test_instruction == 'Y') 1152: { 1153: (*s_etat_processus).nombre_arguments = -1; 1154: return; 1155: } 1156: 1157: if (test_cfsf(s_etat_processus, 31) == d_vrai) 1158: { 1159: if (empilement_pile_last(s_etat_processus, 0) == d_erreur) 1160: { 1161: return; 1162: } 1163: } 1164: 1165: /* 1166: * Recherche d'une variable globale référencée par SIGMA 1167: */ 1168: 1169: if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux) 1170: { 1171: /* 1172: * Aucune variable SIGMA 1173: */ 1174: 1175: (*s_etat_processus).erreur_systeme = d_es; 1176: 1177: if ((*s_etat_processus).erreur_execution == d_ex) 1178: { 1179: (*s_etat_processus).erreur_execution = d_ex_absence_observations; 1180: } 1181: 1182: return; 1183: } 1184: else 1185: { 1186: if (((*(*(*s_etat_processus).pointeur_variable_courante).objet) 1187: .type != MIN) && ((*(*(*s_etat_processus) 1188: .pointeur_variable_courante).objet).type != MRL)) 1189: { 1190: (*s_etat_processus).erreur_execution = 1191: d_ex_matrice_statistique_invalide; 1192: return; 1193: } 1194: 1195: nombre_colonnes = (*((struct_matrice *) (*(*(*s_etat_processus) 1196: .pointeur_variable_courante).objet).objet)) 1197: .nombre_colonnes; 1198: } 1199: 1200: if (((*s_etat_processus).colonne_statistique_2 < 1) || 1201: ((*s_etat_processus).colonne_statistique_2 > (integer8) 1202: nombre_colonnes)) 1203: { 1204: (*s_etat_processus).erreur_execution = d_ex_observations_inexistantes; 1205: return; 1206: } 1207: 1208: s_objet_statistique = (*(*s_etat_processus).pointeur_variable_courante) 1209: .objet; 1210: 1211: if (((*s_objet_statistique).type == MIN) || 1212: ((*s_objet_statistique).type == MRL)) 1213: { 1214: if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL) 1215: { 1216: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1217: return; 1218: } 1219: 1220: if ((resultat = sommation_produits_colonnes_statistiques( 1221: (struct_matrice *) (*s_objet_statistique).objet, 1222: (*s_etat_processus).colonne_statistique_2, 1223: (*s_etat_processus).colonne_statistique_2)) == NULL) 1224: { 1225: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1226: return; 1227: } 1228: 1229: if ((*resultat).type == 'I') 1230: { 1231: (*s_objet_resultat).type = INT; 1232: 1233: if (((*s_objet_resultat).objet = malloc(sizeof(integer8))) == NULL) 1234: { 1235: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1236: return; 1237: } 1238: 1239: (*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *) 1240: (*resultat).tableau)); 1241: } 1242: else 1243: { 1244: (*s_objet_resultat).type = REL; 1245: 1246: if (((*s_objet_resultat).objet = malloc(sizeof(real8))) == NULL) 1247: { 1248: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; 1249: return; 1250: } 1251: 1252: (*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *) 1253: (*resultat).tableau)); 1254: } 1255: 1256: free((*resultat).tableau); 1257: free(resultat); 1258: 1259: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 1260: s_objet_resultat) == d_erreur) 1261: { 1262: return; 1263: } 1264: } 1265: else 1266: { 1267: (*s_etat_processus).erreur_execution = 1268: d_ex_matrice_statistique_invalide; 1269: return; 1270: } 1271: 1272: return; 1273: } 1274: 1275: // vim: ts=4