File:  [local] / rpl / src / instructions_c5.c
Revision 1.69: download - view: text, annotated - select for diffs - revision graph
Fri Jan 10 11:15:44 2020 UTC (4 years, 2 months ago) by bertrand
Branches: MAIN
CVS tags: rpl-4_1_32, HEAD
Modification du copyright.

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

CVSweb interface <joel.bertrand@systella.fr>