Annotation of rpl/src/instructions_s5.c, revision 1.1
1.1 ! bertrand 1: /*
! 2: ================================================================================
! 3: RPL/2 (R) version 4.0.9
! 4: Copyright (C) 1989-2010 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 's+'
! 29: ================================================================================
! 30: Entrées : structure processus
! 31: --------------------------------------------------------------------------------
! 32: Sorties :
! 33: --------------------------------------------------------------------------------
! 34: Effets de bord : néant
! 35: ================================================================================
! 36: */
! 37:
! 38: void
! 39: instruction_s_plus(struct_processus *s_etat_processus)
! 40: {
! 41: long i;
! 42:
! 43: logical1 creation_variable_sigma;
! 44: logical1 presence_variable;
! 45:
! 46: struct_objet *s_copie;
! 47: struct_objet *s_copie_statistique;
! 48: struct_objet *s_objet;
! 49: struct_objet *s_objet_statistique;
! 50:
! 51: struct_variable s_variable;
! 52:
! 53: unsigned long j;
! 54: unsigned long k;
! 55: unsigned long nombre_colonnes;
! 56: unsigned long nombre_lignes;
! 57:
! 58: void *tampon;
! 59:
! 60: (*s_etat_processus).erreur_execution = d_ex;
! 61:
! 62: if ((*s_etat_processus).affichage_arguments == 'Y')
! 63: {
! 64: printf("\n S+ ");
! 65:
! 66: if ((*s_etat_processus).langue == 'F')
! 67: {
! 68: printf("(ajout d'une donnée dans la matrice statistique)\n\n");
! 69: }
! 70: else
! 71: {
! 72: printf("(add a data value in statistical matrix)\n\n");
! 73: }
! 74:
! 75: printf(" 1: %s, %s, %s, %s, %s, %s\n", d_INT, d_REL, d_VIN, d_VRL,
! 76: d_MIN, d_MRL);
! 77:
! 78: return;
! 79: }
! 80: else if ((*s_etat_processus).test_instruction == 'Y')
! 81: {
! 82: (*s_etat_processus).nombre_arguments = -1;
! 83: return;
! 84: }
! 85:
! 86: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 87: {
! 88: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
! 89: {
! 90: return;
! 91: }
! 92: }
! 93:
! 94: /*
! 95: * Recherche d'une variable globale référencée par SIGMA
! 96: */
! 97:
! 98: if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
! 99: {
! 100: /*
! 101: * Aucune variable SIGMA, donc il faut la créer en fonction
! 102: * de l'objet à introduire.
! 103: */
! 104:
! 105: (*s_etat_processus).erreur_systeme = d_es;
! 106: creation_variable_sigma = d_vrai;
! 107: nombre_colonnes = 0;
! 108: }
! 109: else
! 110: {
! 111: /*
! 112: * Il existe une variable locale SIGMA. Reste à vérifier l'existence
! 113: * d'une variable SIGMA globale...
! 114: */
! 115:
! 116: i = (*s_etat_processus).position_variable_courante;
! 117: presence_variable = d_faux;
! 118:
! 119: while(i >= 0)
! 120: {
! 121: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
! 122: ds_sdat) == 0) && ((*s_etat_processus)
! 123: .s_liste_variables[i].niveau == 1))
! 124: {
! 125: presence_variable = d_vrai;
! 126: break;
! 127: }
! 128:
! 129: i--;
! 130: }
! 131:
! 132: if (presence_variable == d_faux)
! 133: {
! 134: creation_variable_sigma = d_vrai;
! 135: nombre_colonnes = 0;
! 136: }
! 137: else
! 138: {
! 139: creation_variable_sigma = d_faux;
! 140:
! 141: (*s_etat_processus).position_variable_courante = i;
! 142:
! 143: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 144: .position_variable_courante].variable_verrouillee ==
! 145: d_vrai)
! 146: {
! 147: (*s_etat_processus).erreur_execution =
! 148: d_ex_variable_verrouillee;
! 149: return;
! 150: }
! 151:
! 152: if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
! 153: {
! 154: (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
! 155: return;
! 156: }
! 157:
! 158: if (((*((*s_etat_processus).s_liste_variables
! 159: [(*s_etat_processus).position_variable_courante].objet))
! 160: .type != MIN) && ((*((*s_etat_processus)
! 161: .s_liste_variables[(*s_etat_processus)
! 162: .position_variable_courante].objet)).type != MRL))
! 163: {
! 164: (*s_etat_processus).erreur_execution =
! 165: d_ex_matrice_statistique_invalide;
! 166: return;
! 167: }
! 168:
! 169: if ((s_copie_statistique = copie_objet(s_etat_processus,
! 170: (*s_etat_processus)
! 171: .s_liste_variables[(*s_etat_processus)
! 172: .position_variable_courante].objet, 'Q')) == NULL)
! 173: {
! 174: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 175: return;
! 176: }
! 177:
! 178: liberation(s_etat_processus, (*s_etat_processus).s_liste_variables
! 179: [(*s_etat_processus).position_variable_courante].objet);
! 180: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 181: .position_variable_courante].objet = s_copie_statistique;
! 182:
! 183: nombre_colonnes = (*((struct_matrice *) (*((*s_etat_processus)
! 184: .s_liste_variables[(*s_etat_processus)
! 185: .position_variable_courante].objet)).objet))
! 186: .nombre_colonnes;
! 187: }
! 188: }
! 189:
! 190: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 191: &s_objet) == d_erreur)
! 192: {
! 193: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 194: return;
! 195: }
! 196:
! 197: if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
! 198: {
! 199: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 200: return;
! 201: }
! 202:
! 203: liberation(s_etat_processus, s_objet);
! 204: s_objet = s_copie;
! 205:
! 206: /*
! 207: * Ajout d'un scalaire
! 208: */
! 209:
! 210: if (((*s_objet).type == INT) ||
! 211: ((*s_objet).type == REL))
! 212: {
! 213: if (creation_variable_sigma == d_vrai)
! 214: {
! 215: /*
! 216: * Création d'une matrice statistique 1*1
! 217: */
! 218:
! 219: if ((s_variable.nom = malloc(6 * sizeof(unsigned char))) == NULL)
! 220: {
! 221: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 222: return;
! 223: }
! 224:
! 225: strcpy(s_variable.nom, ds_sdat);
! 226: s_variable.niveau = 1;
! 227:
! 228: if ((*s_objet).type == INT)
! 229: {
! 230: if ((s_objet_statistique = allocation(s_etat_processus, MIN))
! 231: == NULL)
! 232: {
! 233: (*s_etat_processus).erreur_systeme =
! 234: d_es_allocation_memoire;
! 235: return;
! 236: }
! 237:
! 238: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 239: .tableau = malloc(sizeof(integer8 *))) == NULL)
! 240: {
! 241: (*s_etat_processus).erreur_systeme =
! 242: d_es_allocation_memoire;
! 243: return;
! 244: }
! 245:
! 246: ((integer8 **) (*((struct_matrice *) (*s_objet_statistique)
! 247: .objet)).tableau)[0] = (integer8 *) (*s_objet).objet;
! 248: }
! 249: else
! 250: {
! 251: if ((s_objet_statistique = allocation(s_etat_processus, MRL))
! 252: == NULL)
! 253: {
! 254: (*s_etat_processus).erreur_systeme =
! 255: d_es_allocation_memoire;
! 256: return;
! 257: }
! 258:
! 259: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 260: .tableau = malloc(sizeof(real8 *))) == NULL)
! 261: {
! 262: (*s_etat_processus).erreur_systeme =
! 263: d_es_allocation_memoire;
! 264: return;
! 265: }
! 266:
! 267: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 268: .objet)).tableau)[0] = (real8 *) (*s_objet).objet;
! 269: }
! 270:
! 271: (*((struct_matrice *) (*s_objet_statistique).objet))
! 272: .nombre_colonnes = 1;
! 273: (*((struct_matrice *) (*s_objet_statistique).objet))
! 274: .nombre_lignes = 1;
! 275:
! 276: free(s_objet);
! 277: s_objet = NULL;
! 278:
! 279: s_variable.objet = s_objet_statistique;
! 280:
! 281: if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')
! 282: == d_erreur)
! 283: {
! 284: return;
! 285: }
! 286: }
! 287: else
! 288: {
! 289: /*
! 290: * La variable existe déjà, il faut lui rajouter une ligne.
! 291: */
! 292:
! 293: if (nombre_colonnes != 1)
! 294: {
! 295: (*s_etat_processus).erreur_execution =
! 296: d_ex_dimensions_matrice_statistique;
! 297:
! 298: liberation(s_etat_processus, s_objet);
! 299: return;
! 300: }
! 301:
! 302: s_objet_statistique = ((*s_etat_processus).s_liste_variables
! 303: [(*s_etat_processus).position_variable_courante]).objet;
! 304:
! 305: if (((*s_objet_statistique).type == MIN) &&
! 306: ((*s_objet).type == INT))
! 307: {
! 308: tampon = (*((struct_matrice *) (*s_objet_statistique).objet))
! 309: .tableau;
! 310: (*((struct_matrice *) (*s_objet_statistique).objet))
! 311: .nombre_lignes++;
! 312:
! 313: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 314: .tableau = malloc((*((struct_matrice *)
! 315: (*s_objet_statistique).objet)).nombre_lignes *
! 316: sizeof(integer8 *))) == NULL)
! 317: {
! 318: (*s_etat_processus).erreur_systeme =
! 319: d_es_allocation_memoire;
! 320: return;
! 321: }
! 322:
! 323: for(i = 0; i < (long) ((*((struct_matrice *)
! 324: (*s_objet_statistique).objet)).nombre_lignes - 1); i++)
! 325: {
! 326: ((integer8 **) (*((struct_matrice *) (*s_objet_statistique)
! 327: .objet)).tableau)[i] = ((integer8 **) tampon)[i];
! 328: }
! 329:
! 330: free(tampon);
! 331:
! 332: ((integer8 **) (*((struct_matrice *) (*s_objet_statistique)
! 333: .objet)).tableau)[i] = (integer8 *) (*s_objet).objet;
! 334:
! 335: free(s_objet);
! 336: s_objet = NULL;
! 337: }
! 338: else if (((*s_objet_statistique).type == MRL) &&
! 339: ((*s_objet).type == REL))
! 340: {
! 341: tampon = (*((struct_matrice *) (*s_objet_statistique).objet))
! 342: .tableau;
! 343: (*((struct_matrice *) (*s_objet_statistique).objet))
! 344: .nombre_lignes++;
! 345:
! 346: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 347: .tableau = malloc((*((struct_matrice *)
! 348: (*s_objet_statistique).objet)).nombre_lignes *
! 349: sizeof(real8 *))) == NULL)
! 350: {
! 351: (*s_etat_processus).erreur_systeme =
! 352: d_es_allocation_memoire;
! 353: return;
! 354: }
! 355:
! 356: for(i = 0; i < (long) ((*((struct_matrice *)
! 357: (*s_objet_statistique).objet)).nombre_lignes - 1); i++)
! 358: {
! 359: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 360: .objet)).tableau)[i] = ((real8 **) tampon)[i];
! 361: }
! 362:
! 363: free(tampon);
! 364:
! 365: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 366: .objet)).tableau)[i] = (real8 *) (*s_objet).objet;
! 367:
! 368: free(s_objet);
! 369: s_objet = NULL;
! 370: }
! 371: else if (((*s_objet_statistique).type == MRL) &&
! 372: ((*s_objet).type == INT))
! 373: {
! 374: tampon = (*((struct_matrice *) (*s_objet_statistique).objet))
! 375: .tableau;
! 376: (*((struct_matrice *) (*s_objet_statistique).objet))
! 377: .nombre_lignes++;
! 378:
! 379: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 380: .tableau = malloc((*((struct_matrice *)
! 381: (*s_objet_statistique).objet)).nombre_lignes *
! 382: sizeof(real8 *))) == NULL)
! 383: {
! 384: (*s_etat_processus).erreur_systeme =
! 385: d_es_allocation_memoire;
! 386: return;
! 387: }
! 388:
! 389: for(i = 0; i < (long) ((*((struct_matrice *)
! 390: (*s_objet_statistique).objet)).nombre_lignes - 1); i++)
! 391: {
! 392: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 393: .objet)).tableau)[i] = ((real8 **) tampon)[i];
! 394: }
! 395:
! 396: free(tampon);
! 397:
! 398: if ((((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 399: .objet)).tableau)[i] = malloc(sizeof(real8)))
! 400: == NULL)
! 401: {
! 402: (*s_etat_processus).erreur_systeme =
! 403: d_es_allocation_memoire;
! 404: return;
! 405: }
! 406:
! 407: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 408: .objet)).tableau)[i][0] =
! 409: (real8) (*((integer8 *) (*s_objet).objet));
! 410: }
! 411: else
! 412: {
! 413: tampon = (*((struct_matrice *) (*s_objet_statistique).objet))
! 414: .tableau;
! 415: (*((struct_matrice *) (*s_objet_statistique).objet))
! 416: .nombre_lignes++;
! 417:
! 418: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 419: .tableau = malloc((*((struct_matrice *)
! 420: (*s_objet_statistique).objet)).nombre_lignes *
! 421: sizeof(real8 *))) == NULL)
! 422: {
! 423: (*s_etat_processus).erreur_systeme =
! 424: d_es_allocation_memoire;
! 425: return;
! 426: }
! 427:
! 428: for(i = 0; i < (long) ((*((struct_matrice *)
! 429: (*s_objet_statistique).objet)).nombre_lignes - 1); i++)
! 430: {
! 431: if ((((real8 **) (*((struct_matrice *)
! 432: (*s_objet_statistique).objet)).tableau)[i] =
! 433: malloc(sizeof(real8))) == NULL)
! 434: {
! 435: (*s_etat_processus).erreur_systeme =
! 436: d_es_allocation_memoire;
! 437: return;
! 438: }
! 439:
! 440: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 441: .objet)).tableau)[i][0] = (real8)
! 442: ((integer8 **) tampon)[i][0];
! 443:
! 444: free(((integer8 **) tampon)[i]);
! 445: }
! 446:
! 447: if ((((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 448: .objet)).tableau)[i] = malloc(sizeof(real8)))
! 449: == NULL)
! 450: {
! 451: (*s_etat_processus).erreur_systeme =
! 452: d_es_allocation_memoire;
! 453: return;
! 454: }
! 455:
! 456: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 457: .objet)).tableau)[i][0] = (*((real8 *)
! 458: (*s_objet).objet));
! 459:
! 460: (*((struct_matrice *) (*s_objet_statistique).objet)).type = 'R';
! 461: (*s_objet_statistique).type = MRL;
! 462:
! 463: free(tampon);
! 464: }
! 465: }
! 466: }
! 467:
! 468: /*
! 469: * Ajout d'un vecteur
! 470: */
! 471:
! 472: else if (((*s_objet).type == VIN) ||
! 473: ((*s_objet).type == VRL))
! 474: {
! 475: if (creation_variable_sigma == d_vrai)
! 476: {
! 477: /*
! 478: * Création d'une matrice statistique 1*NC
! 479: */
! 480:
! 481: if ((s_variable.nom = malloc(6 * sizeof(unsigned char))) == NULL)
! 482: {
! 483: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 484: return;
! 485: }
! 486:
! 487: strcpy(s_variable.nom, ds_sdat);
! 488: s_variable.niveau = 1;
! 489:
! 490: if ((*s_objet).type == VIN)
! 491: {
! 492: if ((s_objet_statistique = allocation(s_etat_processus, MIN))
! 493: == NULL)
! 494: {
! 495: (*s_etat_processus).erreur_systeme =
! 496: d_es_allocation_memoire;
! 497: return;
! 498: }
! 499:
! 500: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 501: .tableau = malloc(sizeof(integer8 **))) == NULL)
! 502: {
! 503: (*s_etat_processus).erreur_systeme =
! 504: d_es_allocation_memoire;
! 505: return;
! 506: }
! 507:
! 508: ((integer8 **) (*((struct_matrice *) (*s_objet_statistique)
! 509: .objet)).tableau)[0] = (*((struct_vecteur *)
! 510: (*s_objet).objet)).tableau;
! 511: }
! 512: else
! 513: {
! 514: if ((s_objet_statistique = allocation(s_etat_processus, MRL))
! 515: == NULL)
! 516: {
! 517: (*s_etat_processus).erreur_systeme =
! 518: d_es_allocation_memoire;
! 519: return;
! 520: }
! 521:
! 522: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 523: .tableau = malloc(sizeof(real8 **))) == NULL)
! 524: {
! 525: (*s_etat_processus).erreur_systeme =
! 526: d_es_allocation_memoire;
! 527: return;
! 528: }
! 529:
! 530: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 531: .objet)).tableau)[0] = (*((struct_vecteur *)
! 532: (*s_objet).objet)).tableau;
! 533: }
! 534:
! 535: (*((struct_matrice *) (*s_objet_statistique).objet))
! 536: .nombre_colonnes = (*((struct_vecteur *) (*s_objet).objet))
! 537: .taille;
! 538: (*((struct_matrice *) (*s_objet_statistique).objet))
! 539: .nombre_lignes = 1;
! 540:
! 541: free((struct_vecteur *) (*s_objet).objet);
! 542: free(s_objet);
! 543: s_objet = NULL;
! 544:
! 545: s_variable.objet = s_objet_statistique;
! 546:
! 547: if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')
! 548: == d_erreur)
! 549: {
! 550: return;
! 551: }
! 552: }
! 553: else
! 554: {
! 555: /*
! 556: * La variable existe déjà, il faut lui rajouter une ligne.
! 557: */
! 558:
! 559: if (nombre_colonnes != (*((struct_vecteur *) (*s_objet).objet))
! 560: .taille)
! 561: {
! 562: (*s_etat_processus).erreur_execution =
! 563: d_ex_dimensions_matrice_statistique;
! 564:
! 565: liberation(s_etat_processus, s_objet);
! 566: return;
! 567: }
! 568:
! 569: s_objet_statistique = ((*s_etat_processus).s_liste_variables
! 570: [(*s_etat_processus).position_variable_courante]).objet;
! 571:
! 572: if (((*s_objet_statistique).type == MIN) &&
! 573: ((*s_objet).type == VIN))
! 574: {
! 575: tampon = (*((struct_matrice *) (*s_objet_statistique).objet))
! 576: .tableau;
! 577: (*((struct_matrice *) (*s_objet_statistique).objet))
! 578: .nombre_lignes++;
! 579:
! 580: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 581: .tableau = malloc((*((struct_matrice *)
! 582: (*s_objet_statistique).objet)).nombre_lignes *
! 583: sizeof(integer8 *))) == NULL)
! 584: {
! 585: (*s_etat_processus).erreur_systeme =
! 586: d_es_allocation_memoire;
! 587: return;
! 588: }
! 589:
! 590: for(i = 0; i < (long) ((*((struct_matrice *)
! 591: (*s_objet_statistique).objet)).nombre_lignes - 1); i++)
! 592: {
! 593: ((integer8 **) (*((struct_matrice *) (*s_objet_statistique)
! 594: .objet)).tableau)[i] = ((integer8 **) tampon)[i];
! 595: }
! 596:
! 597: free(tampon);
! 598:
! 599: ((integer8 **) (*((struct_matrice *) (*s_objet_statistique)
! 600: .objet)).tableau)[i] = (integer8 *)
! 601: (*((struct_vecteur *) (*s_objet).objet)).tableau;
! 602:
! 603: free((struct_vecteur *) (*s_objet).objet);
! 604: free(s_objet);
! 605: s_objet = NULL;
! 606: }
! 607: else if (((*s_objet_statistique).type == MRL) &&
! 608: ((*s_objet).type == VRL))
! 609: {
! 610: tampon = (*((struct_matrice *) (*s_objet_statistique).objet))
! 611: .tableau;
! 612: (*((struct_matrice *) (*s_objet_statistique).objet))
! 613: .nombre_lignes++;
! 614:
! 615: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 616: .tableau = malloc((*((struct_matrice *)
! 617: (*s_objet_statistique).objet)).nombre_lignes *
! 618: sizeof(real8 *))) == NULL)
! 619: {
! 620: (*s_etat_processus).erreur_systeme =
! 621: d_es_allocation_memoire;
! 622: return;
! 623: }
! 624:
! 625: for(i = 0; i < (long) ((*((struct_matrice *)
! 626: (*s_objet_statistique).objet)).nombre_lignes - 1); i++)
! 627: {
! 628: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 629: .objet)).tableau)[i] = ((real8 **) tampon)[i];
! 630: }
! 631:
! 632: free(tampon);
! 633:
! 634: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 635: .objet)).tableau)[i] = (real8 *)
! 636: (*((struct_vecteur *) (*s_objet).objet)).tableau;
! 637:
! 638: free((struct_vecteur *) (*s_objet).objet);
! 639: free(s_objet);
! 640: s_objet = NULL;
! 641: }
! 642: else if (((*s_objet_statistique).type == MRL) &&
! 643: ((*s_objet).type == VIN))
! 644: {
! 645: tampon = (*((struct_matrice *) (*s_objet_statistique).objet))
! 646: .tableau;
! 647: (*((struct_matrice *) (*s_objet_statistique).objet))
! 648: .nombre_lignes++;
! 649:
! 650: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 651: .tableau = malloc((*((struct_matrice *)
! 652: (*s_objet_statistique).objet)).nombre_lignes *
! 653: sizeof(real8 *))) == NULL)
! 654: {
! 655: (*s_etat_processus).erreur_systeme =
! 656: d_es_allocation_memoire;
! 657: return;
! 658: }
! 659:
! 660: for(i = 0; i < (long) ((*((struct_matrice *)
! 661: (*s_objet_statistique).objet)).nombre_lignes - 1); i++)
! 662: {
! 663: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 664: .objet)).tableau)[i] = ((real8 **) tampon)[i];
! 665: }
! 666:
! 667: free(tampon);
! 668:
! 669: if ((((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 670: .objet)).tableau)[i] =
! 671: malloc(nombre_colonnes * sizeof(real8))) == NULL)
! 672: {
! 673: (*s_etat_processus).erreur_systeme =
! 674: d_es_allocation_memoire;
! 675: return;
! 676: }
! 677:
! 678: for(j = 0; j < nombre_colonnes; j++)
! 679: {
! 680: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 681: .objet)).tableau)[i][j] =
! 682: (real8) (((integer8 *) (*((struct_vecteur *)
! 683: (*s_objet).objet)).tableau)[j]);
! 684: }
! 685: }
! 686: else
! 687: {
! 688: tampon = (*((struct_matrice *) (*s_objet_statistique).objet))
! 689: .tableau;
! 690: (*((struct_matrice *) (*s_objet_statistique).objet))
! 691: .nombre_lignes++;
! 692:
! 693: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 694: .tableau = malloc((*((struct_matrice *)
! 695: (*s_objet_statistique).objet)).nombre_lignes *
! 696: sizeof(real8 *))) == NULL)
! 697: {
! 698: (*s_etat_processus).erreur_systeme =
! 699: d_es_allocation_memoire;
! 700: return;
! 701: }
! 702:
! 703: for(i = 0; i < (long) ((*((struct_matrice *)
! 704: (*s_objet_statistique).objet)).nombre_lignes - 1); i++)
! 705: {
! 706: if ((((real8 **) (*((struct_matrice *)
! 707: (*s_objet_statistique).objet)).tableau)[i] =
! 708: malloc(nombre_colonnes * sizeof(real8))) == NULL)
! 709: {
! 710: (*s_etat_processus).erreur_systeme =
! 711: d_es_allocation_memoire;
! 712: return;
! 713: }
! 714:
! 715: for(j = 0; j < nombre_colonnes; j++)
! 716: {
! 717: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 718: .objet)).tableau)[i][j] = (real8)
! 719: ((integer8 **) tampon)[i][j];
! 720: }
! 721:
! 722: free(((integer8 **) tampon)[i]);
! 723: }
! 724:
! 725: free(tampon);
! 726:
! 727: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 728: .objet)).tableau)[i] = (real8 *) (*((struct_vecteur *)
! 729: (*s_objet).objet)).tableau;
! 730:
! 731: free((struct_vecteur *) (*s_objet).objet);
! 732: free(s_objet);
! 733: s_objet = NULL;
! 734:
! 735: (*((struct_matrice *) (*s_objet_statistique).objet)).type = 'R';
! 736: (*s_objet_statistique).type = MRL;
! 737: }
! 738: }
! 739: }
! 740:
! 741: /*
! 742: * Ajout d'une matrice
! 743: */
! 744:
! 745: else if (((*s_objet).type == MIN) ||
! 746: ((*s_objet).type == MRL))
! 747: {
! 748: if (creation_variable_sigma == d_vrai)
! 749: {
! 750: /*
! 751: * Création d'une matrice statistique NL*NC
! 752: */
! 753:
! 754: if ((s_variable.nom = malloc(6 * sizeof(unsigned char))) == NULL)
! 755: {
! 756: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 757: return;
! 758: }
! 759:
! 760: strcpy(s_variable.nom, ds_sdat);
! 761: s_variable.niveau = 1;
! 762:
! 763: if ((*s_objet).type == MIN)
! 764: {
! 765: if ((s_objet_statistique = allocation(s_etat_processus, MIN))
! 766: == NULL)
! 767: {
! 768: (*s_etat_processus).erreur_systeme =
! 769: d_es_allocation_memoire;
! 770: return;
! 771: }
! 772:
! 773: (*s_objet_statistique).objet = (*s_objet).objet;
! 774: }
! 775: else
! 776: {
! 777: if ((s_objet_statistique = allocation(s_etat_processus, MRL))
! 778: == NULL)
! 779: {
! 780: (*s_etat_processus).erreur_systeme =
! 781: d_es_allocation_memoire;
! 782: return;
! 783: }
! 784:
! 785: (*s_objet_statistique).objet = (*s_objet).objet;
! 786: }
! 787:
! 788: free(s_objet);
! 789: s_objet = NULL;
! 790:
! 791: s_variable.objet = s_objet_statistique;
! 792:
! 793: if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')
! 794: == d_erreur)
! 795: {
! 796: return;
! 797: }
! 798: }
! 799: else
! 800: {
! 801: /*
! 802: * La variable existe déjà, il faut lui rajouter le nombre
! 803: * de lignes de la matrice passée en argument.
! 804: */
! 805:
! 806: if (nombre_colonnes != (*((struct_matrice *) (*s_objet).objet))
! 807: .nombre_colonnes)
! 808: {
! 809: (*s_etat_processus).erreur_execution =
! 810: d_ex_dimensions_matrice_statistique;
! 811:
! 812: liberation(s_etat_processus, s_objet);
! 813: return;
! 814: }
! 815:
! 816: s_objet_statistique = ((*s_etat_processus).s_liste_variables
! 817: [(*s_etat_processus).position_variable_courante]).objet;
! 818:
! 819: nombre_lignes = (*((struct_matrice *) (*s_objet).objet))
! 820: .nombre_lignes;
! 821:
! 822: if (((*s_objet_statistique).type == MIN) &&
! 823: ((*s_objet).type == MIN))
! 824: {
! 825: tampon = (*((struct_matrice *) (*s_objet_statistique).objet))
! 826: .tableau;
! 827: (*((struct_matrice *) (*s_objet_statistique).objet))
! 828: .nombre_lignes += nombre_lignes;
! 829:
! 830: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 831: .tableau = malloc((*((struct_matrice *)
! 832: (*s_objet_statistique).objet)).nombre_lignes *
! 833: sizeof(integer8 *))) == NULL)
! 834: {
! 835: (*s_etat_processus).erreur_systeme =
! 836: d_es_allocation_memoire;
! 837: return;
! 838: }
! 839:
! 840: for(i = 0; i < (long) ((*((struct_matrice *)
! 841: (*s_objet_statistique).objet)).nombre_lignes
! 842: - nombre_lignes); i++)
! 843: {
! 844: ((integer8 **) (*((struct_matrice *) (*s_objet_statistique)
! 845: .objet)).tableau)[i] = ((integer8 **) tampon)[i];
! 846: }
! 847:
! 848: free(tampon);
! 849:
! 850: for(k = 0; i < (long) ((*((struct_matrice *)
! 851: (*s_objet_statistique).objet)).nombre_lignes); i++, k++)
! 852: {
! 853: ((integer8 **) (*((struct_matrice *) (*s_objet_statistique)
! 854: .objet)).tableau)[i] = ((integer8 **)
! 855: (*((struct_matrice *) (*s_objet).objet))
! 856: .tableau)[k];
! 857: }
! 858:
! 859: free((integer8 **) (*((struct_matrice *) (*s_objet).objet))
! 860: .tableau);
! 861: free((struct_matrice *) (*s_objet).objet);
! 862: free(s_objet);
! 863: s_objet = NULL;
! 864: }
! 865: else if (((*s_objet_statistique).type == MRL) &&
! 866: ((*s_objet).type == MRL))
! 867: {
! 868: tampon = (*((struct_matrice *) (*s_objet_statistique).objet))
! 869: .tableau;
! 870: (*((struct_matrice *) (*s_objet_statistique).objet))
! 871: .nombre_lignes += nombre_lignes;
! 872:
! 873: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 874: .tableau = malloc((*((struct_matrice *)
! 875: (*s_objet_statistique).objet)).nombre_lignes *
! 876: sizeof(real8 *))) == NULL)
! 877: {
! 878: (*s_etat_processus).erreur_systeme =
! 879: d_es_allocation_memoire;
! 880: return;
! 881: }
! 882:
! 883: for(i = 0; i < (long) ((*((struct_matrice *)
! 884: (*s_objet_statistique).objet)).nombre_lignes
! 885: - nombre_lignes); i++)
! 886: {
! 887: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 888: .objet)).tableau)[i] = ((real8 **) tampon)[i];
! 889: }
! 890:
! 891: free(tampon);
! 892:
! 893: for(k = 0; i < (long) ((*((struct_matrice *)
! 894: (*s_objet_statistique).objet)).nombre_lignes); i++, k++)
! 895: {
! 896: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 897: .objet)).tableau)[i] = ((real8 **)
! 898: (*((struct_matrice *) (*s_objet).objet))
! 899: .tableau)[k];
! 900: }
! 901:
! 902: free((real8 **) (*((struct_matrice *) (*s_objet).objet))
! 903: .tableau);
! 904: free((struct_matrice *) (*s_objet).objet);
! 905: free(s_objet);
! 906: s_objet = NULL;
! 907: }
! 908: else if (((*s_objet_statistique).type == MRL) &&
! 909: ((*s_objet).type == MIN))
! 910: {
! 911: tampon = (*((struct_matrice *) (*s_objet_statistique).objet))
! 912: .tableau;
! 913: (*((struct_matrice *) (*s_objet_statistique).objet))
! 914: .nombre_lignes += nombre_lignes;
! 915:
! 916: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 917: .tableau = malloc((*((struct_matrice *)
! 918: (*s_objet_statistique).objet)).nombre_lignes *
! 919: sizeof(real8 *))) == NULL)
! 920: {
! 921: (*s_etat_processus).erreur_systeme =
! 922: d_es_allocation_memoire;
! 923: return;
! 924: }
! 925:
! 926: for(i = 0; i < (long) ((*((struct_matrice *)
! 927: (*s_objet_statistique).objet)).nombre_lignes
! 928: - nombre_lignes); i++)
! 929: {
! 930: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 931: .objet)).tableau)[i] = ((real8 **) tampon)[i];
! 932: }
! 933:
! 934: free(tampon);
! 935:
! 936: for(k = 0; i < (long) ((*((struct_matrice *)
! 937: (*s_objet_statistique).objet)).nombre_lignes); i++, k++)
! 938: {
! 939: if ((((real8 **) (*((struct_matrice *)
! 940: (*s_objet_statistique).objet)).tableau)[i] =
! 941: malloc(nombre_colonnes * sizeof(real8))) == NULL)
! 942: {
! 943: (*s_etat_processus).erreur_systeme =
! 944: d_es_allocation_memoire;
! 945: return;
! 946: }
! 947:
! 948: for(j = 0; j < nombre_colonnes; j++)
! 949: {
! 950: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 951: .objet)).tableau)[i][j] =
! 952: (real8) (((integer8 **) (*((struct_matrice *)
! 953: (*s_objet).objet)).tableau)[k][j]);
! 954: }
! 955: }
! 956: }
! 957: else
! 958: {
! 959: tampon = (*((struct_matrice *) (*s_objet_statistique).objet))
! 960: .tableau;
! 961: (*((struct_matrice *) (*s_objet_statistique).objet))
! 962: .nombre_lignes += nombre_lignes;
! 963:
! 964: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 965: .tableau = malloc((*((struct_matrice *)
! 966: (*s_objet_statistique).objet)).nombre_lignes *
! 967: sizeof(real8 *))) == NULL)
! 968: {
! 969: (*s_etat_processus).erreur_systeme =
! 970: d_es_allocation_memoire;
! 971: return;
! 972: }
! 973:
! 974: for(i = 0; i < (long) ((*((struct_matrice *)
! 975: (*s_objet_statistique).objet)).nombre_lignes
! 976: - nombre_lignes); i++)
! 977: {
! 978: if ((((real8 **) (*((struct_matrice *)
! 979: (*s_objet_statistique).objet)).tableau)[i] =
! 980: malloc(nombre_colonnes * sizeof(real8)))
! 981: == NULL)
! 982: {
! 983: (*s_etat_processus).erreur_systeme =
! 984: d_es_allocation_memoire;
! 985: return;
! 986: }
! 987:
! 988: for(j = 0; j < nombre_colonnes; j++)
! 989: {
! 990: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 991: .objet)).tableau)[i][j] = (real8)
! 992: ((integer8 **) tampon)[i][j];
! 993: }
! 994:
! 995: free(((integer8 **) tampon)[i]);
! 996: }
! 997:
! 998: free(tampon);
! 999:
! 1000: for(k = 0; i < (long) ((*((struct_matrice *)
! 1001: (*s_objet_statistique).objet)).nombre_lignes); i++, k++)
! 1002: {
! 1003: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 1004: .objet)).tableau)[i] = ((real8 **)
! 1005: (*((struct_matrice *) (*s_objet).objet))
! 1006: .tableau)[k];
! 1007: }
! 1008:
! 1009: free((real8 **) (*((struct_matrice *) (*s_objet).objet))
! 1010: .tableau);
! 1011: free((struct_matrice *) (*s_objet).objet);
! 1012: free(s_objet);
! 1013: s_objet = NULL;
! 1014:
! 1015: (*((struct_matrice *) (*s_objet_statistique).objet)).type = 'R';
! 1016: (*s_objet_statistique).type = MRL;
! 1017: }
! 1018: }
! 1019: }
! 1020:
! 1021: /*
! 1022: * Type incompatible en entrée
! 1023: */
! 1024:
! 1025: else
! 1026: {
! 1027: liberation(s_etat_processus, s_objet);
! 1028:
! 1029: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1030: return;
! 1031: }
! 1032:
! 1033: liberation(s_etat_processus, s_objet);
! 1034:
! 1035: return;
! 1036: }
! 1037:
! 1038:
! 1039: /*
! 1040: ================================================================================
! 1041: Fonction 's-'
! 1042: ================================================================================
! 1043: Entrées : structure processus
! 1044: --------------------------------------------------------------------------------
! 1045: Sorties :
! 1046: --------------------------------------------------------------------------------
! 1047: Effets de bord : néant
! 1048: ================================================================================
! 1049: */
! 1050:
! 1051: void
! 1052: instruction_s_moins(struct_processus *s_etat_processus)
! 1053: {
! 1054: logical1 presence_variable;
! 1055:
! 1056: long i;
! 1057:
! 1058: struct_objet *s_copie_statistique;
! 1059: struct_objet *s_objet;
! 1060: struct_objet *s_objet_statistique;
! 1061:
! 1062: unsigned long nombre_colonnes;
! 1063: unsigned long nombre_lignes;
! 1064:
! 1065: void *tampon;
! 1066:
! 1067: (*s_etat_processus).erreur_execution = d_ex;
! 1068:
! 1069: if ((*s_etat_processus).affichage_arguments == 'Y')
! 1070: {
! 1071: printf("\n S- ");
! 1072:
! 1073: if ((*s_etat_processus).langue == 'F')
! 1074: {
! 1075: printf("(retrait une donnée dans la matrice statistique)\n\n");
! 1076: }
! 1077: else
! 1078: {
! 1079: printf("(remove a data value from statistical matrix)\n\n");
! 1080: }
! 1081:
! 1082: printf("-> 1: %s, %s, %s, %s\n", d_INT, d_REL, d_VIN, d_VRL);
! 1083:
! 1084: return;
! 1085: }
! 1086: else if ((*s_etat_processus).test_instruction == 'Y')
! 1087: {
! 1088: (*s_etat_processus).nombre_arguments = -1;
! 1089: return;
! 1090: }
! 1091:
! 1092: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 1093: {
! 1094: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
! 1095: {
! 1096: return;
! 1097: }
! 1098: }
! 1099:
! 1100: /*
! 1101: * Recherche d'une variable globale référencée par SIGMA
! 1102: */
! 1103:
! 1104: if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
! 1105: {
! 1106: /*
! 1107: * Aucune variable SIGMA
! 1108: */
! 1109:
! 1110: (*s_etat_processus).erreur_systeme = d_es;
! 1111: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
! 1112: return;
! 1113: }
! 1114: else
! 1115: {
! 1116: /*
! 1117: * Il existe une variable locale SIGMA. Reste à vérifier l'existence
! 1118: * d'une variable SIGMA globale...
! 1119: */
! 1120:
! 1121: i = (*s_etat_processus).position_variable_courante;
! 1122: presence_variable = d_faux;
! 1123:
! 1124: while(i >= 0)
! 1125: {
! 1126: if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
! 1127: ds_sdat) == 0) && ((*s_etat_processus)
! 1128: .s_liste_variables[i].niveau == 1))
! 1129: {
! 1130: presence_variable = d_vrai;
! 1131: break;
! 1132: }
! 1133:
! 1134: i--;
! 1135: }
! 1136:
! 1137: if (presence_variable == d_faux)
! 1138: {
! 1139: (*s_etat_processus).erreur_execution = d_ex_absence_observations;
! 1140: return;
! 1141: }
! 1142: else
! 1143: {
! 1144: (*s_etat_processus).position_variable_courante = i;
! 1145:
! 1146: if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 1147: .position_variable_courante].variable_verrouillee ==
! 1148: d_vrai)
! 1149: {
! 1150: (*s_etat_processus).erreur_execution =
! 1151: d_ex_variable_verrouillee;
! 1152: return;
! 1153: }
! 1154:
! 1155: if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
! 1156: {
! 1157: (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
! 1158: return;
! 1159: }
! 1160:
! 1161: if (((*((*s_etat_processus).s_liste_variables
! 1162: [(*s_etat_processus).position_variable_courante].objet))
! 1163: .type != MIN) && ((*((*s_etat_processus)
! 1164: .s_liste_variables[(*s_etat_processus)
! 1165: .position_variable_courante].objet)).type != MRL))
! 1166: {
! 1167: (*s_etat_processus).erreur_execution =
! 1168: d_ex_matrice_statistique_invalide;
! 1169: return;
! 1170: }
! 1171:
! 1172: if ((s_copie_statistique = copie_objet(s_etat_processus,
! 1173: (*s_etat_processus)
! 1174: .s_liste_variables[(*s_etat_processus)
! 1175: .position_variable_courante].objet, 'O')) == NULL)
! 1176: {
! 1177: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1178: return;
! 1179: }
! 1180:
! 1181: liberation(s_etat_processus, (*s_etat_processus).s_liste_variables
! 1182: [(*s_etat_processus).position_variable_courante].objet);
! 1183: (*s_etat_processus).s_liste_variables[(*s_etat_processus)
! 1184: .position_variable_courante].objet = s_copie_statistique;
! 1185:
! 1186: nombre_colonnes = (*((struct_matrice *) (*((*s_etat_processus)
! 1187: .s_liste_variables[(*s_etat_processus)
! 1188: .position_variable_courante].objet)).objet))
! 1189: .nombre_colonnes;
! 1190:
! 1191: nombre_lignes = (*((struct_matrice *) (*((*s_etat_processus)
! 1192: .s_liste_variables[(*s_etat_processus)
! 1193: .position_variable_courante].objet)).objet))
! 1194: .nombre_lignes;
! 1195: }
! 1196: }
! 1197:
! 1198: s_objet_statistique = ((*s_etat_processus).s_liste_variables
! 1199: [(*s_etat_processus).position_variable_courante]).objet;
! 1200:
! 1201: if ((*s_objet_statistique).type == MIN)
! 1202: {
! 1203: if (nombre_colonnes == 1)
! 1204: {
! 1205: /*
! 1206: * Formation d'un entier
! 1207: */
! 1208:
! 1209: if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
! 1210: {
! 1211: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1212: return;
! 1213: }
! 1214:
! 1215: (*s_objet).type = INT;
! 1216:
! 1217: if (nombre_lignes == 1)
! 1218: {
! 1219: if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
! 1220: {
! 1221: (*s_etat_processus).erreur_systeme =
! 1222: d_es_allocation_memoire;
! 1223: return;
! 1224: }
! 1225:
! 1226: (*((integer8 *) (*s_objet).objet)) = ((integer8 **)
! 1227: (*((struct_matrice *) (*s_objet_statistique).objet))
! 1228: .tableau)[nombre_lignes - 1][0];
! 1229: }
! 1230: else
! 1231: {
! 1232: (*s_objet).objet = ((integer8 **)
! 1233: (*((struct_matrice *) (*s_objet_statistique).objet))
! 1234: .tableau)[nombre_lignes - 1];
! 1235: }
! 1236: }
! 1237: else
! 1238: {
! 1239: /*
! 1240: * Formation d'un vecteur d'entiers
! 1241: */
! 1242:
! 1243: if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
! 1244: {
! 1245: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1246: return;
! 1247: }
! 1248:
! 1249: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
! 1250: {
! 1251: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1252: return;
! 1253: }
! 1254:
! 1255: (*s_objet).type = VIN;
! 1256: (*((struct_vecteur *) (*s_objet).objet)).type = 'I';
! 1257: (*((struct_vecteur *) (*s_objet).objet)).taille = nombre_colonnes;
! 1258:
! 1259: if (nombre_lignes == 1)
! 1260: {
! 1261: if (((*((struct_vecteur *) (*s_objet).objet))
! 1262: .tableau = malloc(nombre_colonnes *
! 1263: sizeof(integer8))) == NULL)
! 1264: {
! 1265: (*s_etat_processus).erreur_systeme =
! 1266: d_es_allocation_memoire;
! 1267: return;
! 1268: }
! 1269:
! 1270: for(i = 0; i < (long) nombre_colonnes; i++)
! 1271: {
! 1272: ((integer8 *) (*((struct_vecteur *) (*s_objet).objet))
! 1273: .tableau)[i] = ((integer8 **) (*((struct_matrice *)
! 1274: (*s_objet_statistique).objet)).tableau)
! 1275: [nombre_lignes - 1][i];
! 1276: }
! 1277: }
! 1278: else
! 1279: {
! 1280: (*((struct_vecteur *) (*s_objet).objet)).tableau =
! 1281: ((integer8 **) (*((struct_matrice *)
! 1282: (*s_objet_statistique).objet)).tableau)
! 1283: [nombre_lignes - 1];
! 1284: }
! 1285: }
! 1286:
! 1287: if (nombre_lignes == 1)
! 1288: {
! 1289: /*
! 1290: * Destruction de la variable globale SIGMA
! 1291: */
! 1292:
! 1293: if (retrait_variable(s_etat_processus, ds_sdat, 'G') == d_erreur)
! 1294: {
! 1295: return;
! 1296: }
! 1297: }
! 1298: else
! 1299: {
! 1300: /*
! 1301: * Elimination de la dernière ligne de la matrice SIGMA
! 1302: */
! 1303:
! 1304: tampon = (*((struct_matrice *) (*s_objet_statistique)
! 1305: .objet)).tableau;
! 1306: (*((struct_matrice *) (*s_objet_statistique).objet))
! 1307: .nombre_lignes--;
! 1308:
! 1309: if (((*((struct_matrice *) (*s_objet_statistique)
! 1310: .objet)).tableau = malloc(
! 1311: (*((struct_matrice *) (*s_objet_statistique).objet))
! 1312: .nombre_lignes * sizeof(integer8 *))) == NULL)
! 1313: {
! 1314: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1315: return;
! 1316: }
! 1317:
! 1318: for(i = 0; i < (long) (*((struct_matrice *) (*s_objet_statistique)
! 1319: .objet)).nombre_lignes; i++)
! 1320: {
! 1321: ((integer8 **) (*((struct_matrice *) (*s_objet_statistique)
! 1322: .objet)).tableau)[i] = ((integer8 **) tampon)[i];
! 1323: }
! 1324:
! 1325: free(tampon);
! 1326: }
! 1327: }
! 1328: else if ((*s_objet_statistique).type == MRL)
! 1329: {
! 1330: if (nombre_colonnes == 1)
! 1331: {
! 1332: /*
! 1333: * Formation d'un réel
! 1334: */
! 1335:
! 1336: if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
! 1337: {
! 1338: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1339: return;
! 1340: }
! 1341:
! 1342: (*s_objet).type = REL;
! 1343:
! 1344: if (nombre_lignes == 1)
! 1345: {
! 1346: if (((*s_objet).objet = malloc(sizeof(real8)))
! 1347: == NULL)
! 1348: {
! 1349: (*s_etat_processus).erreur_systeme =
! 1350: d_es_allocation_memoire;
! 1351: return;
! 1352: }
! 1353:
! 1354: (*((real8 *) (*s_objet).objet)) = ((real8 **)
! 1355: (*((struct_matrice *) (*s_objet_statistique).objet))
! 1356: .tableau)[nombre_lignes - 1][0];
! 1357: }
! 1358: else
! 1359: {
! 1360: (*s_objet).objet = ((real8 **)
! 1361: (*((struct_matrice *) (*s_objet_statistique).objet))
! 1362: .tableau)[nombre_lignes - 1];
! 1363: }
! 1364: }
! 1365: else
! 1366: {
! 1367: /*
! 1368: * Formation d'un vecteur de réels
! 1369: */
! 1370:
! 1371: if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
! 1372: {
! 1373: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1374: return;
! 1375: }
! 1376:
! 1377: if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
! 1378: {
! 1379: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1380: return;
! 1381: }
! 1382:
! 1383: (*s_objet).type = VRL;
! 1384: (*((struct_vecteur *) (*s_objet).objet)).type = 'R';
! 1385: (*((struct_vecteur *) (*s_objet).objet)).taille = nombre_colonnes;
! 1386:
! 1387: if (nombre_lignes == 1)
! 1388: {
! 1389: if (((*((struct_vecteur *) (*s_objet).objet))
! 1390: .tableau = malloc(nombre_colonnes *
! 1391: sizeof(real8))) == NULL)
! 1392: {
! 1393: (*s_etat_processus).erreur_systeme =
! 1394: d_es_allocation_memoire;
! 1395: return;
! 1396: }
! 1397:
! 1398: for(i = 0; i < (long) nombre_colonnes; i++)
! 1399: {
! 1400: ((real8 *) (*((struct_vecteur *) (*s_objet).objet))
! 1401: .tableau)[i] = ((real8 **) (*((struct_matrice *)
! 1402: (*s_objet_statistique).objet)).tableau)
! 1403: [nombre_lignes - 1][i];
! 1404: }
! 1405: }
! 1406: else
! 1407: {
! 1408: (*((struct_vecteur *) (*s_objet).objet)).tableau =
! 1409: ((real8 **) (*((struct_matrice *)
! 1410: (*s_objet_statistique).objet)).tableau)
! 1411: [nombre_lignes - 1];
! 1412: }
! 1413: }
! 1414:
! 1415: if (nombre_lignes == 1)
! 1416: {
! 1417: /*
! 1418: * Destruction de la variable globale SIGMA
! 1419: */
! 1420:
! 1421: if (retrait_variable(s_etat_processus, ds_sdat, 'G') == d_erreur)
! 1422: {
! 1423: return;
! 1424: }
! 1425: }
! 1426: else
! 1427: {
! 1428: /*
! 1429: * Elimination de la dernière ligne de la matrice SIGMA
! 1430: */
! 1431:
! 1432: tampon = (*((struct_matrice *) (*s_objet_statistique)
! 1433: .objet)).tableau;
! 1434: (*((struct_matrice *) (*s_objet_statistique).objet))
! 1435: .nombre_lignes--;
! 1436:
! 1437: if (((*((struct_matrice *) (*s_objet_statistique).objet))
! 1438: .tableau = malloc((*((struct_matrice *)
! 1439: (*s_objet_statistique).objet)).nombre_lignes *
! 1440: sizeof(real8 *))) == NULL)
! 1441: {
! 1442: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1443: return;
! 1444: }
! 1445:
! 1446: for(i = 0; i < (long) (*((struct_matrice *) (*s_objet_statistique)
! 1447: .objet)).nombre_lignes; i++)
! 1448: {
! 1449: ((real8 **) (*((struct_matrice *) (*s_objet_statistique)
! 1450: .objet)).tableau)[i] = ((real8 **) tampon)[i];
! 1451: }
! 1452:
! 1453: free(tampon);
! 1454: }
! 1455: }
! 1456: else
! 1457: {
! 1458: (*s_etat_processus).erreur_execution =
! 1459: d_ex_matrice_statistique_invalide;
! 1460: return;
! 1461: }
! 1462:
! 1463: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1464: s_objet) == d_erreur)
! 1465: {
! 1466: return;
! 1467: }
! 1468:
! 1469: return;
! 1470: }
! 1471:
! 1472: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_s5.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src