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