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