File:  [local] / rpl / src / instructions_g2.c
Revision 1.73: download - view: text, annotated - select for diffs - revision graph
Fri Jan 10 11:15:45 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 'get'
   29: ================================================================================
   30:   Entrées :
   31: --------------------------------------------------------------------------------
   32:   Sorties :
   33: --------------------------------------------------------------------------------
   34:   Effets de bord : néant
   35: ================================================================================
   36: */
   37: 
   38: static int
   39: fonction_comparaison(const void *argument_1, const void *argument_2)
   40: {
   41:     return(strcmp((unsigned char *) argument_1,
   42:             (unsigned char *) (**((struct_objet **) argument_2)).objet));
   43: }
   44: 
   45: 
   46: void
   47: instruction_get(struct_processus *s_etat_processus)
   48: {
   49:     logical1                            variable_partagee;
   50: 
   51:     struct_liste_chainee                *l_element_courant;
   52: 
   53:     struct_objet                        **s_enregistrement;
   54:     struct_objet                        *s_objet_1;
   55:     struct_objet                        *s_objet_2;
   56:     struct_objet                        *s_objet_3;
   57:     struct_objet                        *s_objet_element;
   58:     struct_objet                        *s_objet_noms;
   59:     struct_objet                        *s_objet_resultat;
   60: 
   61:     integer8                            indice_i;
   62:     integer8                            indice_j;
   63:     integer8                            nombre_dimensions;
   64: 
   65:     unsigned char                       *registre_instruction_courante;
   66:     unsigned char                       registre_instruction_valide;
   67:     unsigned char                       registre_test;
   68: 
   69:     (*s_etat_processus).erreur_execution = d_ex;
   70: 
   71:     if ((*s_etat_processus).affichage_arguments == 'Y')
   72:     {
   73:         printf("\n  GET ");
   74: 
   75:         if ((*s_etat_processus).langue == 'F')
   76:         {
   77:             printf("(prend un élément)\n\n");
   78:         }
   79:         else
   80:         {
   81:             printf("(get element)\n\n");
   82:         }
   83: 
   84:         printf("    2: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM);
   85:         printf("    1: %s\n", d_LST);
   86:         printf("->  1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL);
   87: 
   88:         printf("    2: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM);
   89:         printf("    1: %s\n", d_LST);
   90:         printf("->  1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL);
   91: 
   92:         printf("    2: %s, %s\n", d_TAB, d_NOM);
   93:         printf("    1: %s\n", d_LST);
   94:         printf("->  1: %s, %s, %s, %s, %s, %s,\n"
   95:                 "       %s, %s, %s, %s, %s,\n"
   96:                 "       %s, %s, %s, %s, %s,\n"
   97:                 "       %s, %s, %s, %s,\n"
   98:                 "       %s, %s, %s\n\n",
   99:                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
  100:                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
  101:                 d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
  102: 
  103:         printf("    2: %s\n", d_REC);
  104:         printf("    1: %s\n", d_CHN);
  105:         printf("->  1: %s, %s, %s, %s, %s, %s,\n"
  106:                 "       %s, %s, %s, %s, %s,\n"
  107:                 "       %s, %s, %s, %s, %s,\n"
  108:                 "       %s, %s, %s, %s,\n"
  109:                 "       %s, %s, %s\n\n",
  110:                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
  111:                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
  112:                 d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
  113: 
  114:         printf("    2: %s, %s\n", d_LST, d_NOM);
  115:         printf("    1: %s\n", d_INT);
  116:         printf("->  1: %s, %s, %s, %s, %s, %s,\n"
  117:                 "       %s, %s, %s, %s, %s,\n"
  118:                 "       %s, %s, %s, %s, %s,\n"
  119:                 "       %s, %s, %s, %s,\n"
  120:                 "       %s, %s, %s\n",
  121:                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
  122:                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
  123:                 d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
  124: 
  125:         return;
  126:     }
  127:     else if ((*s_etat_processus).test_instruction == 'Y')
  128:     {
  129:         (*s_etat_processus).nombre_arguments = -1;
  130:         return;
  131:     }
  132: 
  133:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  134:     {
  135:         if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
  136:         {
  137:             return;
  138:         }
  139:     }
  140: 
  141:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  142:             &s_objet_1) == d_erreur)
  143:     {
  144:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  145:         return;
  146:     }
  147: 
  148:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  149:             &s_objet_2) == d_erreur)
  150:     {
  151:         liberation(s_etat_processus, s_objet_1);
  152: 
  153:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  154:         return;
  155:     }
  156: 
  157: /*
  158: --------------------------------------------------------------------------------
  159:   Traitement des éléments des vecteurs
  160: --------------------------------------------------------------------------------
  161: */
  162: 
  163:     if (((*s_objet_2).type == VIN) ||
  164:             ((*s_objet_2).type == VRL) ||
  165:             ((*s_objet_2).type == VCX))
  166:     {
  167:         if ((*s_objet_1).type != LST)
  168:         {
  169:             liberation(s_etat_processus, s_objet_1);
  170:             liberation(s_etat_processus, s_objet_2);
  171: 
  172:             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  173:             return;
  174:         }
  175: 
  176:         l_element_courant = (*s_objet_1).objet;
  177:         nombre_dimensions = 0;
  178: 
  179:         while(l_element_courant != NULL)
  180:         {
  181:             nombre_dimensions++;
  182:             l_element_courant = (*l_element_courant).suivant;
  183:         }
  184: 
  185:         if (nombre_dimensions != 1)
  186:         {
  187:             liberation(s_etat_processus, s_objet_1);
  188:             liberation(s_etat_processus, s_objet_2);
  189: 
  190:             (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
  191:             return;
  192:         }
  193: 
  194:         l_element_courant = (*s_objet_1).objet;
  195: 
  196:         if ((*(*l_element_courant).donnee).type != INT)
  197:         {
  198:             liberation(s_etat_processus, s_objet_1);
  199:             liberation(s_etat_processus, s_objet_2);
  200: 
  201:             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  202:             return;
  203:         }
  204: 
  205:         if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
  206:         {
  207:             liberation(s_etat_processus, s_objet_1);
  208:             liberation(s_etat_processus, s_objet_2);
  209: 
  210:             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  211:             return;
  212:         }
  213:         else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
  214:                 (integer8) (*((struct_vecteur *) (*s_objet_2).objet)).taille)
  215:         {
  216:             liberation(s_etat_processus, s_objet_1);
  217:             liberation(s_etat_processus, s_objet_2);
  218: 
  219:             (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
  220:             return;
  221:         }
  222: 
  223:         indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
  224: 
  225:         if ((*s_objet_2).type == VIN)
  226:         {
  227:             /*
  228:              * Vecteur d'entiers
  229:              */
  230: 
  231:             if ((s_objet_resultat = allocation(s_etat_processus, INT))
  232:                     == NULL)
  233:             {
  234:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  235:                 return;
  236:             }
  237: 
  238:             (*((integer8 *) (*s_objet_resultat).objet)) =
  239:                     ((integer8 *) (*((struct_vecteur *) (*s_objet_2).objet))
  240:                     .tableau)[indice_i - 1];
  241:         }
  242:         else if ((*s_objet_2).type == VRL)
  243:         {
  244:             /*
  245:              * Vecteur de réels
  246:              */
  247: 
  248:             if ((s_objet_resultat = allocation(s_etat_processus, REL))
  249:                     == NULL)
  250:             {
  251:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  252:                 return;
  253:             }
  254: 
  255:             (*((real8 *) (*s_objet_resultat).objet)) =
  256:                     ((real8 *) (*((struct_vecteur *) (*s_objet_2).objet))
  257:                     .tableau)[indice_i - 1];
  258:         }
  259:         else
  260:         {
  261:             /*
  262:              * Vecteur de complexes
  263:              */
  264: 
  265:             if ((s_objet_resultat = allocation(s_etat_processus, CPL))
  266:                     == NULL)
  267:             {
  268:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  269:                 return;
  270:             }
  271: 
  272:             (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle =
  273:                     ((struct_complexe16 *) (*((struct_vecteur *)
  274:                     (*s_objet_2).objet)).tableau)[indice_i - 1].partie_reelle;
  275:             (*((struct_complexe16 *) (*s_objet_resultat).objet))
  276:                     .partie_imaginaire = ((struct_complexe16 *)
  277:                     (*((struct_vecteur *) (*s_objet_2).objet)).tableau)
  278:                     [indice_i - 1].partie_imaginaire;
  279:         }
  280:     }
  281: 
  282: /*
  283: --------------------------------------------------------------------------------
  284:   Traitement des éléments des matrices
  285: --------------------------------------------------------------------------------
  286: */
  287: 
  288:     else if (((*s_objet_2).type == MIN) ||
  289:             ((*s_objet_2).type == MRL) ||
  290:             ((*s_objet_2).type == MCX))
  291:     {
  292:         if ((*s_objet_1).type != LST)
  293:         {
  294:             liberation(s_etat_processus, s_objet_1);
  295:             liberation(s_etat_processus, s_objet_2);
  296: 
  297:             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  298:             return;
  299:         }
  300: 
  301:         l_element_courant = (*s_objet_1).objet;
  302:         nombre_dimensions = 0;
  303: 
  304:         while(l_element_courant != NULL)
  305:         {
  306:             nombre_dimensions++;
  307:             l_element_courant = (*l_element_courant).suivant;
  308:         }
  309: 
  310:         if (nombre_dimensions != 2)
  311:         {
  312:             liberation(s_etat_processus, s_objet_1);
  313:             liberation(s_etat_processus, s_objet_2);
  314: 
  315:             (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
  316:             return;
  317:         }
  318: 
  319:         l_element_courant = (*s_objet_1).objet;
  320: 
  321:         indice_i = 0;
  322:         indice_j = 0;
  323: 
  324:         while(l_element_courant != NULL)
  325:         {
  326:             if ((*(*l_element_courant).donnee).type != INT)
  327:             {
  328:                 liberation(s_etat_processus, s_objet_1);
  329:                 liberation(s_etat_processus, s_objet_2);
  330: 
  331:                 (*s_etat_processus).erreur_execution =
  332:                         d_ex_erreur_type_argument;
  333:                 return;
  334:             }
  335: 
  336:             if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
  337:             {
  338:                 liberation(s_etat_processus, s_objet_1);
  339:                 liberation(s_etat_processus, s_objet_2);
  340: 
  341:                 (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  342:                 return;
  343:             }
  344: 
  345:             if (indice_i == 0)
  346:             {
  347:                 indice_i = (*((integer8 *)
  348:                         (*(*l_element_courant).donnee).objet));
  349:             }
  350:             else
  351:             {
  352:                 indice_j = (*((integer8 *)
  353:                         (*(*l_element_courant).donnee).objet));
  354:             }
  355: 
  356:             l_element_courant = (*l_element_courant).suivant;
  357:         }
  358: 
  359:         if ((indice_i > (*((struct_matrice *) (*s_objet_2).objet))
  360:                 .nombre_lignes) || (indice_j > (*((struct_matrice *)
  361:                 (*s_objet_2).objet)).nombre_colonnes))
  362:         {
  363:             liberation(s_etat_processus, s_objet_1);
  364:             liberation(s_etat_processus, s_objet_2);
  365: 
  366:             (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
  367:             return;
  368:         }
  369: 
  370:         if ((*s_objet_2).type == MIN)
  371:         {
  372:             /*
  373:              * Matrice d'entiers
  374:              */
  375: 
  376:             if ((s_objet_resultat = allocation(s_etat_processus, INT))
  377:                     == NULL)
  378:             {
  379:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  380:                 return;
  381:             }
  382: 
  383:             (*((integer8 *) (*s_objet_resultat).objet)) =
  384:                     ((integer8 **) (*((struct_matrice *) (*s_objet_2).objet))
  385:                     .tableau)[indice_i - 1][indice_j - 1];
  386:         }
  387:         else if ((*s_objet_2).type == MRL)
  388:         {
  389:             /*
  390:              * Matrice de réels
  391:              */
  392: 
  393:             if ((s_objet_resultat = allocation(s_etat_processus, REL))
  394:                     == NULL)
  395:             {
  396:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  397:                 return;
  398:             }
  399: 
  400:             (*((real8 *) (*s_objet_resultat).objet)) =
  401:                     ((real8 **) (*((struct_matrice *) (*s_objet_2).objet))
  402:                     .tableau)[indice_i - 1][indice_j - 1];
  403:         }
  404:         else
  405:         {
  406:             /*
  407:              * Matrices de complexes
  408:              */
  409: 
  410:             if ((s_objet_resultat = allocation(s_etat_processus, CPL))
  411:                     == NULL)
  412:             {
  413:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  414:                 return;
  415:             }
  416: 
  417:             (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle =
  418:                     ((struct_complexe16 **) (*((struct_matrice *)
  419:                     (*s_objet_2).objet)).tableau)[indice_i - 1]
  420:                     [indice_j - 1].partie_reelle;
  421:             (*((struct_complexe16 *) (*s_objet_resultat).objet))
  422:                     .partie_imaginaire = ((struct_complexe16 **)
  423:                     (*((struct_matrice *) (*s_objet_2).objet)).tableau)
  424:                     [indice_i - 1][indice_j - 1].partie_imaginaire;
  425:         }
  426:     }
  427: 
  428: /*
  429: --------------------------------------------------------------------------------
  430:   Traitement des listes
  431: --------------------------------------------------------------------------------
  432: */
  433: 
  434:     else if ((*s_objet_2).type == LST)
  435:     {
  436:         if ((*s_objet_1).type != INT)
  437:         {
  438:             liberation(s_etat_processus, s_objet_1);
  439:             liberation(s_etat_processus, s_objet_2);
  440: 
  441:             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  442:             return;
  443:         }
  444: 
  445:         indice_i = (*((integer8 *) (*s_objet_1).objet));
  446:         indice_j = 1;
  447: 
  448:         l_element_courant = (*s_objet_2).objet;
  449: 
  450:         while((l_element_courant != NULL) && (indice_j != indice_i))
  451:         {
  452:             l_element_courant = (*l_element_courant).suivant;
  453:             indice_j++;
  454:         }
  455: 
  456:         if (l_element_courant != NULL)
  457:         {
  458:             if ((s_objet_resultat = copie_objet(s_etat_processus,
  459:                     (*l_element_courant).donnee, 'P')) == NULL)
  460:             {
  461:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  462:                 return;
  463:             }
  464:         }
  465:         else
  466:         {
  467:             liberation(s_etat_processus, s_objet_1);
  468:             liberation(s_etat_processus, s_objet_2);
  469: 
  470:             (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
  471:             return;
  472:         }
  473:     }
  474: 
  475: /*
  476: --------------------------------------------------------------------------------
  477:   Traitement des tables
  478: --------------------------------------------------------------------------------
  479: */
  480: 
  481:     else if ((*s_objet_2).type == TBL)
  482:     {
  483:         if ((*s_objet_1).type != LST)
  484:         {
  485:             liberation(s_etat_processus, s_objet_1);
  486:             liberation(s_etat_processus, s_objet_2);
  487: 
  488:             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  489:             return;
  490:         }
  491: 
  492:         l_element_courant = (*s_objet_1).objet;
  493:         s_objet_element = s_objet_2;
  494: 
  495:         while(l_element_courant != NULL)
  496:         {
  497:             if ((*(*l_element_courant).donnee).type != INT)
  498:             {
  499:                 liberation(s_etat_processus, s_objet_1);
  500:                 liberation(s_etat_processus, s_objet_2);
  501: 
  502:                 (*s_etat_processus).erreur_execution =
  503:                         d_ex_erreur_type_argument;
  504:                 return;
  505:             }
  506: 
  507:             if ((*s_objet_element).type != TBL)
  508:             {
  509:                 liberation(s_etat_processus, s_objet_1);
  510:                 liberation(s_etat_processus, s_objet_2);
  511: 
  512:                 (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
  513:                 return;
  514:             }
  515: 
  516:             indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
  517: 
  518:             if ((indice_i < 1) || (indice_i > (*((struct_tableau *)
  519:                     (*s_objet_element).objet)).nombre_elements))
  520:             {
  521:                 liberation(s_etat_processus, s_objet_1);
  522:                 liberation(s_etat_processus, s_objet_2);
  523: 
  524:                 (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
  525:                 return;
  526:             }
  527: 
  528:             s_objet_element = (*((struct_tableau *) (*s_objet_element)
  529:                     .objet)).elements[indice_i - 1];
  530:             l_element_courant = (*l_element_courant).suivant;
  531:         }
  532: 
  533:         if ((s_objet_resultat = copie_objet(s_etat_processus,
  534:                 s_objet_element, 'P')) == NULL)
  535:         {
  536:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  537:             return;
  538:         }
  539:     }
  540: 
  541: /*
  542: --------------------------------------------------------------------------------
  543:   Traitement des enregistrements
  544: --------------------------------------------------------------------------------
  545: */
  546: 
  547:     else if ((*s_objet_2).type == REC)
  548:     {
  549:         if ((*s_objet_1).type != CHN)
  550:         {
  551:             liberation(s_etat_processus, s_objet_1);
  552:             liberation(s_etat_processus, s_objet_2);
  553: 
  554:             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  555:             return;
  556:         }
  557: 
  558:         s_objet_noms = (*((struct_record *) (*s_objet_2).objet)).noms;
  559: 
  560:         if ((s_enregistrement = bsearch((unsigned char *) (*s_objet_1).objet,
  561:                 (*((struct_tableau *) (*s_objet_noms).objet)).elements,
  562:                 (size_t) (*((struct_tableau *) (*s_objet_noms).objet))
  563:                 .nombre_elements, sizeof(struct_objet *), fonction_comparaison))
  564:                 == NULL)
  565:         {
  566:             liberation(s_etat_processus, s_objet_1);
  567:             liberation(s_etat_processus, s_objet_2);
  568: 
  569:             (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
  570:             return;
  571:         }
  572: 
  573:         indice_i = s_enregistrement - (*((struct_tableau *)
  574:                 (*s_objet_noms).objet)).elements;
  575: 
  576:         // Récupération de l'objet dans le tableau données
  577: 
  578:         if ((s_objet_resultat = copie_objet(s_etat_processus,
  579:                 (*((struct_tableau *) (*(*((struct_record *)
  580:                 (*s_objet_2).objet)).donnees).objet)).elements[indice_i], 'P'))
  581:                 == NULL)
  582:         {
  583:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  584:             return;
  585:         }
  586:     }
  587: /*
  588: --------------------------------------------------------------------------------
  589:   Traitement des variables
  590: --------------------------------------------------------------------------------
  591: */
  592: 
  593:     else if ((*s_objet_2).type == NOM)
  594:     {
  595:         variable_partagee = d_faux;
  596: 
  597:         if (recherche_variable(s_etat_processus, (*((struct_nom *)
  598:                 (*s_objet_2).objet)).nom) == d_faux)
  599:         {
  600:             (*s_etat_processus).erreur_systeme = d_es;
  601:             (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
  602: 
  603:             liberation(s_etat_processus, s_objet_1);
  604:             liberation(s_etat_processus, s_objet_2);
  605: 
  606:             return;
  607:         }
  608: 
  609:         s_objet_3 = (*(*s_etat_processus).pointeur_variable_courante).objet;
  610: 
  611:         if (s_objet_3 == NULL)
  612:         {
  613:             if (recherche_variable_partagee(s_etat_processus,
  614:                     (*(*s_etat_processus).pointeur_variable_courante).nom,
  615:                     (*(*s_etat_processus).pointeur_variable_courante)
  616:                     .variable_partagee, (*(*s_etat_processus)
  617:                     .pointeur_variable_courante).origine) == NULL)
  618:             {
  619:                 (*s_etat_processus).erreur_systeme = d_es;
  620:                 (*s_etat_processus).erreur_execution =
  621:                         d_ex_variable_non_definie;
  622: 
  623:                 liberation(s_etat_processus, s_objet_1);
  624:                 liberation(s_etat_processus, s_objet_2);
  625: 
  626:                 return;
  627:             }
  628: 
  629:             s_objet_3 = (*(*s_etat_processus)
  630:                     .pointeur_variable_partagee_courante).objet;
  631:             variable_partagee = d_vrai;
  632:         }
  633: 
  634:         if (((*s_objet_3).type == VIN) ||
  635:                 ((*s_objet_3).type == VRL) ||
  636:                 ((*s_objet_3).type == VCX))
  637:         {
  638:             if ((*s_objet_1).type != LST)
  639:             {
  640:                 if (variable_partagee == d_vrai)
  641:                 {
  642:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
  643:                             .pointeur_variable_partagee_courante).mutex)) != 0)
  644:                     {
  645:                         (*s_etat_processus).erreur_systeme = d_es_processus;
  646:                         return;
  647:                     }
  648:                 }
  649: 
  650:                 liberation(s_etat_processus, s_objet_1);
  651:                 liberation(s_etat_processus, s_objet_2);
  652: 
  653:                 (*s_etat_processus).erreur_execution =
  654:                         d_ex_erreur_type_argument;
  655:                 return;
  656:             }
  657: 
  658:             l_element_courant = (*s_objet_1).objet;
  659:             nombre_dimensions = 0;
  660: 
  661:             while(l_element_courant != NULL)
  662:             {
  663:                 nombre_dimensions++;
  664:                 l_element_courant = (*l_element_courant).suivant;
  665:             }
  666: 
  667:             if (nombre_dimensions != 1)
  668:             {
  669:                 if (variable_partagee == d_vrai)
  670:                 {
  671:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
  672:                             .pointeur_variable_partagee_courante).mutex)) != 0)
  673:                     {
  674:                         (*s_etat_processus).erreur_systeme = d_es_processus;
  675:                         return;
  676:                     }
  677:                 }
  678: 
  679:                 liberation(s_etat_processus, s_objet_1);
  680:                 liberation(s_etat_processus, s_objet_2);
  681: 
  682:                 (*s_etat_processus).erreur_execution =
  683:                         d_ex_dimensions_invalides;
  684:                 return;
  685:             }
  686: 
  687:             l_element_courant = (*s_objet_1).objet;
  688: 
  689:             if ((*(*l_element_courant).donnee).type != INT)
  690:             {
  691:                 if (variable_partagee == d_vrai)
  692:                 {
  693:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
  694:                             .pointeur_variable_partagee_courante).mutex)) != 0)
  695:                     {
  696:                         (*s_etat_processus).erreur_systeme = d_es_processus;
  697:                         return;
  698:                     }
  699:                 }
  700: 
  701:                 liberation(s_etat_processus, s_objet_1);
  702:                 liberation(s_etat_processus, s_objet_2);
  703: 
  704:                 (*s_etat_processus).erreur_execution =
  705:                         d_ex_erreur_type_argument;
  706:                 return;
  707:             }
  708: 
  709:             if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
  710:             {
  711:                 if (variable_partagee == d_vrai)
  712:                 {
  713:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
  714:                             .pointeur_variable_partagee_courante).mutex)) != 0)
  715:                     {
  716:                         (*s_etat_processus).erreur_systeme = d_es_processus;
  717:                         return;
  718:                     }
  719:                 }
  720: 
  721:                 liberation(s_etat_processus, s_objet_1);
  722:                 liberation(s_etat_processus, s_objet_2);
  723: 
  724:                 (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
  725:                 return;
  726:             }
  727:             else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
  728:                     (integer8) (*((struct_vecteur *) (*s_objet_3).objet))
  729:                     .taille)
  730:             {
  731:                 if (variable_partagee == d_vrai)
  732:                 {
  733:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
  734:                             .pointeur_variable_partagee_courante).mutex)) != 0)
  735:                     {
  736:                         (*s_etat_processus).erreur_systeme = d_es_processus;
  737:                         return;
  738:                     }
  739:                 }
  740: 
  741:                 liberation(s_etat_processus, s_objet_1);
  742:                 liberation(s_etat_processus, s_objet_2);
  743: 
  744:                 (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
  745:                 return;
  746:             }
  747: 
  748:             indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
  749: 
  750:             if ((*s_objet_3).type == VIN)
  751:             {
  752:                 /*
  753:                  * Vecteur d'entiers
  754:                  */
  755: 
  756:                 if ((s_objet_resultat = allocation(s_etat_processus, INT))
  757:                         == NULL)
  758:                 {
  759:                     if (variable_partagee == d_vrai)
  760:                     {
  761:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
  762:                                 .pointeur_variable_partagee_courante).mutex))
  763:                                 != 0)
  764:                         {
  765:                             (*s_etat_processus).erreur_systeme = d_es_processus;
  766:                             return;
  767:                         }
  768:                     }
  769: 
  770:                     (*s_etat_processus).erreur_systeme
  771:                             = d_es_allocation_memoire;
  772:                     return;
  773:                 }
  774: 
  775:                 (*((integer8 *) (*s_objet_resultat).objet)) =
  776:                         ((integer8 *) (*((struct_vecteur *)
  777:                         (*s_objet_3).objet)).tableau)[indice_i - 1];
  778:             }
  779:             else if ((*s_objet_3).type == VRL)
  780:             {
  781:                 /*
  782:                  * Vecteur de réels
  783:                  */
  784: 
  785:                 if ((s_objet_resultat = allocation(s_etat_processus, REL))
  786:                         == NULL)
  787:                 {
  788:                     if (variable_partagee == d_vrai)
  789:                     {
  790:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
  791:                                 .pointeur_variable_partagee_courante).mutex))
  792:                                 != 0)
  793:                         {
  794:                             (*s_etat_processus).erreur_systeme = d_es_processus;
  795:                             return;
  796:                         }
  797:                     }
  798: 
  799:                     (*s_etat_processus).erreur_systeme
  800:                             = d_es_allocation_memoire;
  801:                     return;
  802:                 }
  803: 
  804:                 (*((real8 *) (*s_objet_resultat).objet)) =
  805:                         ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
  806:                         .tableau)[indice_i - 1];
  807:             }
  808:             else
  809:             {
  810:                 /*
  811:                  * Vecteur de complexes
  812:                  */
  813: 
  814:                 if ((s_objet_resultat = allocation(s_etat_processus, CPL))
  815:                         == NULL)
  816:                 {
  817:                     if (variable_partagee == d_vrai)
  818:                     {
  819:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
  820:                                 .pointeur_variable_partagee_courante).mutex))
  821:                                 != 0)
  822:                         {
  823:                             (*s_etat_processus).erreur_systeme = d_es_processus;
  824:                             return;
  825:                         }
  826:                     }
  827: 
  828:                     (*s_etat_processus).erreur_systeme
  829:                             = d_es_allocation_memoire;
  830:                     return;
  831:                 }
  832: 
  833:                 (*((struct_complexe16 *) (*s_objet_resultat).objet))
  834:                         .partie_reelle = ((struct_complexe16 *)
  835:                         (*((struct_vecteur *) (*s_objet_3).objet))
  836:                         .tableau)[indice_i - 1].partie_reelle;
  837:                 (*((struct_complexe16 *) (*s_objet_resultat).objet))
  838:                         .partie_imaginaire = ((struct_complexe16 *)
  839:                         (*((struct_vecteur *) (*s_objet_3).objet)).tableau)
  840:                         [indice_i - 1].partie_imaginaire;
  841:             }
  842:         }
  843:         else if (((*s_objet_3).type == MIN) ||
  844:                 ((*s_objet_3).type == MRL) ||
  845:                 ((*s_objet_3).type == MCX))
  846:         {
  847:             if ((*s_objet_1).type != LST)
  848:             {
  849:                 if (variable_partagee == d_vrai)
  850:                 {
  851:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
  852:                             .pointeur_variable_partagee_courante).mutex)) != 0)
  853:                     {
  854:                         (*s_etat_processus).erreur_systeme = d_es_processus;
  855:                         return;
  856:                     }
  857:                 }
  858: 
  859:                 liberation(s_etat_processus, s_objet_1);
  860:                 liberation(s_etat_processus, s_objet_2);
  861: 
  862:                 (*s_etat_processus).erreur_execution =
  863:                         d_ex_erreur_type_argument;
  864:                 return;
  865:             }
  866: 
  867:             l_element_courant = (*s_objet_1).objet;
  868:             nombre_dimensions = 0;
  869: 
  870:             while(l_element_courant != NULL)
  871:             {
  872:                 nombre_dimensions++;
  873:                 l_element_courant = (*l_element_courant).suivant;
  874:             }
  875: 
  876:             if (nombre_dimensions != 2)
  877:             {
  878:                 if (variable_partagee == d_vrai)
  879:                 {
  880:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
  881:                             .pointeur_variable_partagee_courante).mutex)) != 0)
  882:                     {
  883:                         (*s_etat_processus).erreur_systeme = d_es_processus;
  884:                         return;
  885:                     }
  886:                 }
  887: 
  888:                 liberation(s_etat_processus, s_objet_1);
  889:                 liberation(s_etat_processus, s_objet_2);
  890: 
  891:                 (*s_etat_processus).erreur_execution =
  892:                         d_ex_dimensions_invalides;
  893:                 return;
  894:             }
  895: 
  896:             l_element_courant = (*s_objet_1).objet;
  897: 
  898:             indice_i = 0;
  899:             indice_j = 0;
  900: 
  901:             while(l_element_courant != NULL)
  902:             {
  903:                 if ((*(*l_element_courant).donnee).type != INT)
  904:                 {
  905:                     if (variable_partagee == d_vrai)
  906:                     {
  907:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
  908:                                 .pointeur_variable_partagee_courante).mutex))
  909:                                 != 0)
  910:                         {
  911:                             (*s_etat_processus).erreur_systeme = d_es_processus;
  912:                             return;
  913:                         }
  914:                     }
  915: 
  916:                     liberation(s_etat_processus, s_objet_1);
  917:                     liberation(s_etat_processus, s_objet_2);
  918: 
  919:                     (*s_etat_processus).erreur_execution =
  920:                             d_ex_erreur_type_argument;
  921:                     return;
  922:                 }
  923: 
  924:                 if ((*((integer8 *) (*(*l_element_courant)
  925:                         .donnee).objet)) <= 0)
  926:                 {
  927:                     if (variable_partagee == d_vrai)
  928:                     {
  929:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
  930:                                 .pointeur_variable_partagee_courante).mutex))
  931:                                 != 0)
  932:                         {
  933:                             (*s_etat_processus).erreur_systeme = d_es_processus;
  934:                             return;
  935:                         }
  936:                     }
  937: 
  938:                     liberation(s_etat_processus, s_objet_1);
  939:                     liberation(s_etat_processus, s_objet_2);
  940: 
  941:                     (*s_etat_processus).erreur_execution =
  942:                             d_ex_argument_invalide;
  943:                     return;
  944:                 }
  945: 
  946:                 if (indice_i == 0)
  947:                 {
  948:                     indice_i = (*((integer8 *)
  949:                             (*(*l_element_courant).donnee).objet));
  950:                 }
  951:                 else
  952:                 {
  953:                     indice_j = (*((integer8 *)
  954:                             (*(*l_element_courant).donnee).objet));
  955:                 }
  956: 
  957:                 l_element_courant = (*l_element_courant).suivant;
  958:             }
  959: 
  960:             if ((indice_i > (*((struct_matrice *) (*s_objet_3).objet))
  961:                     .nombre_lignes) || (indice_j > (*((struct_matrice *)
  962:                     (*s_objet_3).objet)).nombre_colonnes))
  963:             {
  964:                 if (variable_partagee == d_vrai)
  965:                 {
  966:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
  967:                             .pointeur_variable_partagee_courante).mutex)) != 0)
  968:                     {
  969:                         (*s_etat_processus).erreur_systeme = d_es_processus;
  970:                         return;
  971:                     }
  972:                 }
  973: 
  974:                 liberation(s_etat_processus, s_objet_1);
  975:                 liberation(s_etat_processus, s_objet_2);
  976: 
  977:                 (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
  978:                 return;
  979:             }
  980: 
  981:             if ((*s_objet_3).type == MIN)
  982:             {
  983:                 /*
  984:                  * Matrice d'entiers
  985:                  */
  986: 
  987:                 if ((s_objet_resultat = allocation(s_etat_processus, INT))
  988:                         == NULL)
  989:                 {
  990:                     if (variable_partagee == d_vrai)
  991:                     {
  992:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
  993:                                 .pointeur_variable_partagee_courante).mutex))
  994:                                 != 0)
  995:                         {
  996:                             (*s_etat_processus).erreur_systeme = d_es_processus;
  997:                             return;
  998:                         }
  999:                     }
 1000: 
 1001:                     (*s_etat_processus).erreur_systeme =
 1002:                             d_es_allocation_memoire;
 1003:                     return;
 1004:                 }
 1005: 
 1006:                 (*((integer8 *) (*s_objet_resultat).objet)) =
 1007:                         ((integer8 **) (*((struct_matrice *)
 1008:                         (*s_objet_3).objet))
 1009:                         .tableau)[indice_i - 1][indice_j - 1];
 1010:             }
 1011:             else if ((*s_objet_3).type == MRL)
 1012:             {
 1013:                 /*
 1014:                  * Matrice de réels
 1015:                  */
 1016: 
 1017:                 if ((s_objet_resultat = allocation(s_etat_processus, REL))
 1018:                         == NULL)
 1019:                 {
 1020:                     if (variable_partagee == d_vrai)
 1021:                     {
 1022:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1023:                                 .pointeur_variable_partagee_courante).mutex))
 1024:                                 != 0)
 1025:                         {
 1026:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 1027:                             return;
 1028:                         }
 1029:                     }
 1030: 
 1031:                     (*s_etat_processus).erreur_systeme =
 1032:                             d_es_allocation_memoire;
 1033:                     return;
 1034:                 }
 1035: 
 1036:                 (*((real8 *) (*s_objet_resultat).objet)) =
 1037:                         ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
 1038:                         .tableau)[indice_i - 1][indice_j - 1];
 1039:             }
 1040:             else
 1041:             {
 1042:                 /*
 1043:                  * Matrices de complexes
 1044:                  */
 1045: 
 1046:                 if ((s_objet_resultat = allocation(s_etat_processus, CPL))
 1047:                         == NULL)
 1048:                 {
 1049:                     if (variable_partagee == d_vrai)
 1050:                     {
 1051:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1052:                                 .pointeur_variable_partagee_courante).mutex))
 1053:                                 != 0)
 1054:                         {
 1055:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 1056:                             return;
 1057:                         }
 1058:                     }
 1059: 
 1060:                     (*s_etat_processus).erreur_systeme =
 1061:                             d_es_allocation_memoire;
 1062:                     return;
 1063:                 }
 1064: 
 1065:                 (*((struct_complexe16 *) (*s_objet_resultat).objet))
 1066:                         .partie_reelle = ((struct_complexe16 **)
 1067:                         (*((struct_matrice *)
 1068:                         (*s_objet_3).objet)).tableau)[indice_i - 1]
 1069:                         [indice_j - 1].partie_reelle;
 1070:                 (*((struct_complexe16 *) (*s_objet_resultat).objet))
 1071:                         .partie_imaginaire = ((struct_complexe16 **)
 1072:                         (*((struct_matrice *) (*s_objet_3).objet)).tableau)
 1073:                         [indice_i - 1][indice_j - 1].partie_imaginaire;
 1074:             }
 1075:         }
 1076:         else if ((*s_objet_3).type == LST)
 1077:         {
 1078:             if ((*s_objet_1).type != INT)
 1079:             {
 1080:                 if (variable_partagee == d_vrai)
 1081:                 {
 1082:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1083:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 1084:                     {
 1085:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 1086:                         return;
 1087:                     }
 1088:                 }
 1089: 
 1090:                 liberation(s_etat_processus, s_objet_1);
 1091:                 liberation(s_etat_processus, s_objet_2);
 1092: 
 1093:                 (*s_etat_processus).erreur_execution =
 1094:                         d_ex_erreur_type_argument;
 1095:                 return;
 1096:             }
 1097: 
 1098:             indice_i = (*((integer8 *) (*s_objet_1).objet));
 1099:             indice_j = 1;
 1100: 
 1101:             l_element_courant = (*s_objet_3).objet;
 1102: 
 1103:             while((l_element_courant != NULL) && (indice_j != indice_i))
 1104:             {
 1105:                 l_element_courant = (*l_element_courant).suivant;
 1106:                 indice_j++;
 1107:             }
 1108: 
 1109:             if (l_element_courant != NULL)
 1110:             {
 1111:                 if ((s_objet_resultat = copie_objet(s_etat_processus,
 1112:                         (*l_element_courant).donnee, 'P')) == NULL)
 1113:                 {
 1114:                     if (variable_partagee == d_vrai)
 1115:                     {
 1116:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1117:                                 .pointeur_variable_partagee_courante).mutex))
 1118:                                 != 0)
 1119:                         {
 1120:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 1121:                             return;
 1122:                         }
 1123:                     }
 1124: 
 1125:                     (*s_etat_processus).erreur_systeme =
 1126:                             d_es_allocation_memoire;
 1127:                     return;
 1128:                 }
 1129:             }
 1130:             else
 1131:             {
 1132:                 if (variable_partagee == d_vrai)
 1133:                 {
 1134:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1135:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 1136:                     {
 1137:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 1138:                         return;
 1139:                     }
 1140:                 }
 1141: 
 1142:                 liberation(s_etat_processus, s_objet_1);
 1143:                 liberation(s_etat_processus, s_objet_2);
 1144: 
 1145:                 (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
 1146:                 return;
 1147:             }
 1148:         }
 1149:         else if ((*s_objet_3).type == TBL)
 1150:         {
 1151:             if ((*s_objet_1).type != LST)
 1152:             {
 1153:                 if (variable_partagee == d_vrai)
 1154:                 {
 1155:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1156:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 1157:                     {
 1158:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 1159:                         return;
 1160:                     }
 1161:                 }
 1162: 
 1163:                 liberation(s_etat_processus, s_objet_1);
 1164:                 liberation(s_etat_processus, s_objet_2);
 1165: 
 1166:                 (*s_etat_processus).erreur_execution =
 1167:                         d_ex_erreur_type_argument;
 1168:                 return;
 1169:             }
 1170: 
 1171:             l_element_courant = (*s_objet_1).objet;
 1172:             s_objet_element = s_objet_3;
 1173: 
 1174:             while(l_element_courant != NULL)
 1175:             {
 1176:                 if ((*(*l_element_courant).donnee).type != INT)
 1177:                 {
 1178:                     if (variable_partagee == d_vrai)
 1179:                     {
 1180:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1181:                                 .pointeur_variable_partagee_courante).mutex))
 1182:                                 != 0)
 1183:                         {
 1184:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 1185:                             return;
 1186:                         }
 1187:                     }
 1188: 
 1189:                     liberation(s_etat_processus, s_objet_1);
 1190:                     liberation(s_etat_processus, s_objet_2);
 1191: 
 1192:                     (*s_etat_processus).erreur_execution =
 1193:                             d_ex_erreur_type_argument;
 1194:                     return;
 1195:                 }
 1196: 
 1197:                 if ((*s_objet_element).type != TBL)
 1198:                 {
 1199:                     if (variable_partagee == d_vrai)
 1200:                     {
 1201:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1202:                                 .pointeur_variable_partagee_courante).mutex))
 1203:                                 != 0)
 1204:                         {
 1205:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 1206:                             return;
 1207:                         }
 1208:                     }
 1209: 
 1210:                     liberation(s_etat_processus, s_objet_1);
 1211:                     liberation(s_etat_processus, s_objet_2);
 1212: 
 1213:                     (*s_etat_processus).erreur_execution =
 1214:                             d_ex_element_inexistant;
 1215:                     return;
 1216:                 }
 1217: 
 1218:                 indice_i = (*((integer8 *) (*(*l_element_courant)
 1219:                         .donnee).objet));
 1220: 
 1221:                 if ((indice_i < 1) || (indice_i > (*((struct_tableau *)
 1222:                         (*s_objet_element).objet)).nombre_elements))
 1223:                 {
 1224:                     if (variable_partagee == d_vrai)
 1225:                     {
 1226:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1227:                                 .pointeur_variable_partagee_courante).mutex))
 1228:                                 != 0)
 1229:                         {
 1230:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 1231:                             return;
 1232:                         }
 1233:                     }
 1234: 
 1235:                     liberation(s_etat_processus, s_objet_1);
 1236:                     liberation(s_etat_processus, s_objet_2);
 1237: 
 1238:                     (*s_etat_processus).erreur_execution =
 1239:                             d_ex_element_inexistant;
 1240:                     return;
 1241:                 }
 1242: 
 1243:                 s_objet_element = (*((struct_tableau *) (*s_objet_element)
 1244:                         .objet)).elements[indice_i - 1];
 1245:                 l_element_courant = (*l_element_courant).suivant;
 1246:             }
 1247: 
 1248:             if ((s_objet_resultat = copie_objet(s_etat_processus,
 1249:                     s_objet_element, 'P')) == NULL)
 1250:             {
 1251:                 if (variable_partagee == d_vrai)
 1252:                 {
 1253:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1254:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 1255:                     {
 1256:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 1257:                         return;
 1258:                     }
 1259:                 }
 1260: 
 1261:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1262:                 return;
 1263:             }
 1264:         }
 1265:         else if ((*s_objet_3).type == REC)
 1266:         {
 1267:             if ((*s_objet_1).type != CHN)
 1268:             {
 1269:                 if (variable_partagee == d_vrai)
 1270:                 {
 1271:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1272:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 1273:                     {
 1274:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 1275:                         return;
 1276:                     }
 1277:                 }
 1278: 
 1279:                 liberation(s_etat_processus, s_objet_1);
 1280:                 liberation(s_etat_processus, s_objet_2);
 1281: 
 1282:                 (*s_etat_processus).erreur_execution =
 1283:                         d_ex_erreur_type_argument;
 1284:                 return;
 1285:             }
 1286: 
 1287:             s_objet_noms = (*((struct_record *) (*s_objet_3).objet)).noms;
 1288: 
 1289:             if ((s_enregistrement = bsearch((unsigned char *)
 1290:                     (*s_objet_1).objet, (*((struct_tableau *)
 1291:                     (*s_objet_noms).objet)).elements,
 1292:                     (size_t) (*((struct_tableau *) (*s_objet_noms).objet))
 1293:                     .nombre_elements, sizeof(struct_objet *),
 1294:                     fonction_comparaison)) == NULL)
 1295:             {
 1296:                 if (variable_partagee == d_vrai)
 1297:                 {
 1298:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1299:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 1300:                     {
 1301:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 1302:                         return;
 1303:                     }
 1304:                 }
 1305: 
 1306:                 liberation(s_etat_processus, s_objet_1);
 1307:                 liberation(s_etat_processus, s_objet_2);
 1308: 
 1309:                 (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
 1310:                 return;
 1311:             }
 1312: 
 1313:             indice_i = s_enregistrement - (*((struct_tableau *)
 1314:                     (*s_objet_noms).objet)).elements;
 1315: 
 1316:             // Récupération de l'objet dans le tableau données
 1317: 
 1318:             if ((s_objet_resultat = copie_objet(s_etat_processus,
 1319:                     (*((struct_tableau *) (*(*((struct_record *)
 1320:                     (*s_objet_3).objet)).donnees).objet)).elements[indice_i],
 1321:                     'P')) == NULL)
 1322:             {
 1323:                 if (variable_partagee == d_vrai)
 1324:                 {
 1325:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1326:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 1327:                     {
 1328:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 1329:                         return;
 1330:                     }
 1331:                 }
 1332: 
 1333:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1334:                 return;
 1335:             }
 1336:         }
 1337:         else
 1338:         {
 1339:             if (variable_partagee == d_vrai)
 1340:             {
 1341:                 if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1342:                         .pointeur_variable_partagee_courante).mutex)) != 0)
 1343:                 {
 1344:                     (*s_etat_processus).erreur_systeme = d_es_processus;
 1345:                     return;
 1346:                 }
 1347:             }
 1348: 
 1349:             liberation(s_etat_processus, s_objet_1);
 1350:             liberation(s_etat_processus, s_objet_2);
 1351: 
 1352:             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
 1353:             return;
 1354:         }
 1355: 
 1356:         if (variable_partagee == d_vrai)
 1357:         {
 1358:             if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1359:                     .pointeur_variable_partagee_courante).mutex)) != 0)
 1360:             {
 1361:                 (*s_etat_processus).erreur_systeme = d_es_processus;
 1362:                 return;
 1363:             }
 1364:         }
 1365:     }
 1366: 
 1367: /*
 1368: --------------------------------------------------------------------------------
 1369:   Type incompatible avec la fonction GET
 1370: --------------------------------------------------------------------------------
 1371: */
 1372: 
 1373:     else
 1374:     {
 1375:         liberation(s_etat_processus, s_objet_1);
 1376:         liberation(s_etat_processus, s_objet_2);
 1377: 
 1378:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
 1379:         return;
 1380:     }
 1381: 
 1382:     liberation(s_etat_processus, s_objet_1);
 1383:     liberation(s_etat_processus, s_objet_2);
 1384: 
 1385:     if ((*s_objet_resultat).type == NOM)
 1386:     {
 1387:         if ((*((struct_nom *) (*s_objet_resultat).objet)).symbole == d_faux)
 1388:         {
 1389:             if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
 1390:             {
 1391:                 return;
 1392:             }
 1393:         }
 1394:         else
 1395:         {
 1396:             if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 1397:                     s_objet_resultat) == d_erreur)
 1398:             {
 1399:                 return;
 1400:             }
 1401:         }
 1402:     }
 1403:     else if ((*s_objet_resultat).type == FCT)
 1404:     {
 1405:         registre_test = (*s_etat_processus).test_instruction;
 1406:         registre_instruction_courante = (*s_etat_processus)
 1407:                 .instruction_courante;
 1408:         registre_instruction_valide = (*s_etat_processus)
 1409:                 .instruction_valide;
 1410: 
 1411:         (*s_etat_processus).test_instruction = 'Y';
 1412:         (*s_etat_processus).instruction_courante =
 1413:                 (*((struct_fonction *) (*s_objet_resultat).objet)).nom_fonction;
 1414: 
 1415:         analyse(s_etat_processus, NULL);
 1416: 
 1417:         (*s_etat_processus).test_instruction = registre_test;
 1418:         (*s_etat_processus).instruction_courante =
 1419:                 registre_instruction_courante;
 1420: 
 1421:         if (((*s_etat_processus).instruction_valide == 'Y') &&
 1422:                 (*s_etat_processus).constante_symbolique == 'Y')
 1423:         {
 1424:             if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
 1425:             {
 1426:                 (*s_etat_processus).instruction_valide =
 1427:                         registre_instruction_valide;
 1428:                 return;
 1429:             }
 1430:         }
 1431:         else
 1432:         {
 1433:             if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 1434:                     s_objet_resultat) == d_erreur)
 1435:             {
 1436:                 (*s_etat_processus).instruction_valide =
 1437:                         registre_instruction_valide;
 1438:                 return;
 1439:             }
 1440:         }
 1441: 
 1442:         (*s_etat_processus).instruction_valide = registre_instruction_valide;
 1443:     }
 1444:     else
 1445:     {
 1446:         if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 1447:                 s_objet_resultat) == d_erreur)
 1448:         {
 1449:             return;
 1450:         }
 1451:     }
 1452: 
 1453:     return;
 1454: }
 1455: 
 1456: 
 1457: /*
 1458: ================================================================================
 1459:   Fonction 'geti'
 1460: ================================================================================
 1461:   Entrées :
 1462: --------------------------------------------------------------------------------
 1463:   Sorties :
 1464: --------------------------------------------------------------------------------
 1465:   Effets de bord : néant
 1466: ================================================================================
 1467: */
 1468: 
 1469: void
 1470: instruction_geti(struct_processus *s_etat_processus)
 1471: {
 1472:     logical1                            variable_partagee;
 1473: 
 1474:     struct_liste_chainee                *l_element_courant;
 1475: 
 1476:     struct_objet                        *s_copie_1;
 1477:     struct_objet                        *s_objet_1;
 1478:     struct_objet                        *s_objet_2;
 1479:     struct_objet                        *s_objet_3;
 1480:     struct_objet                        *s_objet_resultat;
 1481: 
 1482:     integer8                            indice_i;
 1483:     integer8                            indice_j;
 1484:     integer8                            nombre_dimensions;
 1485:     integer8                            nombre_elements;
 1486: 
 1487:     unsigned char                       *registre_instruction_courante;
 1488:     unsigned char                       registre_instruction_valide;
 1489:     unsigned char                       registre_test;
 1490: 
 1491:     (*s_etat_processus).erreur_execution = d_ex;
 1492: 
 1493:     if ((*s_etat_processus).affichage_arguments == 'Y')
 1494:     {
 1495:         printf("\n  GETI ");
 1496: 
 1497:         if ((*s_etat_processus).langue == 'F')
 1498:         {
 1499:             printf("(prend un élément)\n\n");
 1500:         }
 1501:         else
 1502:         {
 1503:             printf("(get element)\n\n");
 1504:         }
 1505: 
 1506:         printf("    2: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM);
 1507:         printf("    1: %s\n", d_LST);
 1508:         printf("->  3: %s, %s, %s, %s\n", d_VIN, d_VRL, d_VCX, d_NOM);
 1509:         printf("    2: %s\n", d_LST);
 1510:         printf("    1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL);
 1511: 
 1512:         printf("    2: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM);
 1513:         printf("    1: %s\n", d_LST);
 1514:         printf("->  3: %s, %s, %s, %s\n", d_MIN, d_MRL, d_MCX, d_NOM);
 1515:         printf("    2: %s\n", d_LST);
 1516:         printf("    1: %s, %s, %s\n\n", d_INT, d_REL, d_CPL);
 1517: 
 1518:         printf("    2: %s, %s\n", d_LST, d_NOM);
 1519:         printf("    1: %s\n", d_INT);
 1520:         printf("->  3: %s, %s\n", d_LST, d_NOM);
 1521:         printf("    2: %s\n", d_INT);
 1522:         printf("    1: %s, %s, %s, %s, %s, %s,\n"
 1523:                 "       %s, %s, %s, %s, %s,\n"
 1524:                 "       %s, %s, %s, %s, %s,\n"
 1525:                 "       %s, %s, %s, %s,\n"
 1526:                 "       %s, %s, %s\n",
 1527:                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
 1528:                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
 1529:                 d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
 1530: 
 1531:         return;
 1532:     }
 1533:     else if ((*s_etat_processus).test_instruction == 'Y')
 1534:     {
 1535:         (*s_etat_processus).nombre_arguments = -1;
 1536:         return;
 1537:     }
 1538: 
 1539:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
 1540:     {
 1541:         if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
 1542:         {
 1543:             return;
 1544:         }
 1545:     }
 1546: 
 1547:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 1548:             &s_objet_1) == d_erreur)
 1549:     {
 1550:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
 1551:         return;
 1552:     }
 1553: 
 1554:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 1555:             &s_objet_2) == d_erreur)
 1556:     {
 1557:         liberation(s_etat_processus, s_objet_1);
 1558: 
 1559:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
 1560:         return;
 1561:     }
 1562: 
 1563:     if ((s_copie_1 = copie_objet(s_etat_processus, s_objet_1, 'O')) == NULL)
 1564:     {
 1565:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1566:         return;
 1567:     }
 1568: 
 1569:     liberation(s_etat_processus, s_objet_1);
 1570:     s_objet_1 = s_copie_1;
 1571: 
 1572: /*
 1573: --------------------------------------------------------------------------------
 1574:   Traitement des éléments des vecteurs
 1575: --------------------------------------------------------------------------------
 1576: */
 1577: 
 1578:     if (((*s_objet_2).type == VIN) ||
 1579:             ((*s_objet_2).type == VRL) ||
 1580:             ((*s_objet_2).type == VCX))
 1581:     {
 1582:         if ((*s_objet_1).type != LST)
 1583:         {
 1584:             liberation(s_etat_processus, s_objet_1);
 1585:             liberation(s_etat_processus, s_objet_2);
 1586: 
 1587:             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
 1588:             return;
 1589:         }
 1590: 
 1591:         l_element_courant = (*s_objet_1).objet;
 1592:         nombre_dimensions = 0;
 1593: 
 1594:         while(l_element_courant != NULL)
 1595:         {
 1596:             nombre_dimensions++;
 1597:             l_element_courant = (*l_element_courant).suivant;
 1598:         }
 1599: 
 1600:         if (nombre_dimensions != 1)
 1601:         {
 1602:             liberation(s_etat_processus, s_objet_1);
 1603:             liberation(s_etat_processus, s_objet_2);
 1604: 
 1605:             (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
 1606:             return;
 1607:         }
 1608: 
 1609:         l_element_courant = (*s_objet_1).objet;
 1610: 
 1611:         if ((*(*l_element_courant).donnee).type != INT)
 1612:         {
 1613:             liberation(s_etat_processus, s_objet_1);
 1614:             liberation(s_etat_processus, s_objet_2);
 1615: 
 1616:             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
 1617:             return;
 1618:         }
 1619: 
 1620:         if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
 1621:         {
 1622:             liberation(s_etat_processus, s_objet_1);
 1623:             liberation(s_etat_processus, s_objet_2);
 1624: 
 1625:             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
 1626:             return;
 1627:         }
 1628:         else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
 1629:                 (integer8) (*((struct_vecteur *) (*s_objet_2).objet)).taille)
 1630:         {
 1631:             liberation(s_etat_processus, s_objet_1);
 1632:             liberation(s_etat_processus, s_objet_2);
 1633: 
 1634:             (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
 1635:             return;
 1636:         }
 1637: 
 1638:         indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
 1639: 
 1640:         if ((*s_objet_2).type == VIN)
 1641:         {
 1642:             /*
 1643:              * Vecteur d'entiers
 1644:              */
 1645: 
 1646:             if ((s_objet_resultat = allocation(s_etat_processus, INT))
 1647:                     == NULL)
 1648:             {
 1649:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1650:                 return;
 1651:             }
 1652: 
 1653:             (*((integer8 *) (*s_objet_resultat).objet)) =
 1654:                     ((integer8 *) (*((struct_vecteur *) (*s_objet_2).objet))
 1655:                     .tableau)[indice_i - 1];
 1656:         }
 1657:         else if ((*s_objet_2).type == VRL)
 1658:         {
 1659:             /*
 1660:              * Vecteur de réels
 1661:              */
 1662: 
 1663:             if ((s_objet_resultat = allocation(s_etat_processus, REL))
 1664:                     == NULL)
 1665:             {
 1666:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1667:                 return;
 1668:             }
 1669: 
 1670:             (*((real8 *) (*s_objet_resultat).objet)) =
 1671:                     ((real8 *) (*((struct_vecteur *) (*s_objet_2).objet))
 1672:                     .tableau)[indice_i - 1];
 1673:         }
 1674:         else
 1675:         {
 1676:             /*
 1677:              * Vecteur de complexes
 1678:              */
 1679: 
 1680:             if ((s_objet_resultat = allocation(s_etat_processus, CPL))
 1681:                     == NULL)
 1682:             {
 1683:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1684:                 return;
 1685:             }
 1686: 
 1687:             (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle =
 1688:                     ((struct_complexe16 *) (*((struct_vecteur *)
 1689:                     (*s_objet_2).objet)).tableau)[indice_i - 1].partie_reelle;
 1690:             (*((struct_complexe16 *) (*s_objet_resultat).objet))
 1691:                     .partie_imaginaire = ((struct_complexe16 *)
 1692:                     (*((struct_vecteur *) (*s_objet_2).objet)).tableau)
 1693:                     [indice_i - 1].partie_imaginaire;
 1694:         }
 1695: 
 1696:         (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
 1697:                 (indice_i % (*((struct_vecteur *) (*s_objet_2).objet)).taille)
 1698:                 + 1;
 1699:     }
 1700: 
 1701: /*
 1702: --------------------------------------------------------------------------------
 1703:   Traitement des éléments des matrices
 1704: --------------------------------------------------------------------------------
 1705: */
 1706: 
 1707:     else if (((*s_objet_2).type == MIN) ||
 1708:             ((*s_objet_2).type == MRL) ||
 1709:             ((*s_objet_2).type == MCX))
 1710:     {
 1711:         if ((*s_objet_1).type != LST)
 1712:         {
 1713:             liberation(s_etat_processus, s_objet_1);
 1714:             liberation(s_etat_processus, s_objet_2);
 1715: 
 1716:             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
 1717:             return;
 1718:         }
 1719: 
 1720:         l_element_courant = (*s_objet_1).objet;
 1721:         nombre_dimensions = 0;
 1722: 
 1723:         while(l_element_courant != NULL)
 1724:         {
 1725:             nombre_dimensions++;
 1726:             l_element_courant = (*l_element_courant).suivant;
 1727:         }
 1728: 
 1729:         if (nombre_dimensions != 2)
 1730:         {
 1731:             liberation(s_etat_processus, s_objet_1);
 1732:             liberation(s_etat_processus, s_objet_2);
 1733: 
 1734:             (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
 1735:             return;
 1736:         }
 1737: 
 1738:         l_element_courant = (*s_objet_1).objet;
 1739: 
 1740:         indice_i = 0;
 1741:         indice_j = 0;
 1742: 
 1743:         while(l_element_courant != NULL)
 1744:         {
 1745:             if ((*(*l_element_courant).donnee).type != INT)
 1746:             {
 1747:                 liberation(s_etat_processus, s_objet_1);
 1748:                 liberation(s_etat_processus, s_objet_2);
 1749: 
 1750:                 (*s_etat_processus).erreur_execution =
 1751:                         d_ex_erreur_type_argument;
 1752:                 return;
 1753:             }
 1754: 
 1755:             if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
 1756:             {
 1757:                 liberation(s_etat_processus, s_objet_1);
 1758:                 liberation(s_etat_processus, s_objet_2);
 1759: 
 1760:                 (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
 1761:                 return;
 1762:             }
 1763: 
 1764:             if (indice_i == 0)
 1765:             {
 1766:                 indice_i = (*((integer8 *)
 1767:                         (*(*l_element_courant).donnee).objet));
 1768:             }
 1769:             else
 1770:             {
 1771:                 indice_j = (*((integer8 *)
 1772:                         (*(*l_element_courant).donnee).objet));
 1773:             }
 1774: 
 1775:             l_element_courant = (*l_element_courant).suivant;
 1776:         }
 1777: 
 1778:         if ((indice_i > (*((struct_matrice *) (*s_objet_2).objet))
 1779:                 .nombre_lignes) || (indice_j > (*((struct_matrice *)
 1780:                 (*s_objet_2).objet)).nombre_colonnes))
 1781:         {
 1782:             liberation(s_etat_processus, s_objet_1);
 1783:             liberation(s_etat_processus, s_objet_2);
 1784: 
 1785:             (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
 1786:             return;
 1787:         }
 1788: 
 1789:         if ((*s_objet_2).type == MIN)
 1790:         {
 1791:             /*
 1792:              * Matrice d'entiers
 1793:              */
 1794: 
 1795:             if ((s_objet_resultat = allocation(s_etat_processus, INT))
 1796:                     == NULL)
 1797:             {
 1798:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1799:                 return;
 1800:             }
 1801: 
 1802:             (*((integer8 *) (*s_objet_resultat).objet)) =
 1803:                     ((integer8 **) (*((struct_matrice *) (*s_objet_2).objet))
 1804:                     .tableau)[indice_i - 1][indice_j - 1];
 1805:         }
 1806:         else if ((*s_objet_2).type == MRL)
 1807:         {
 1808:             /*
 1809:              * Matrice de réels
 1810:              */
 1811: 
 1812:             if ((s_objet_resultat = allocation(s_etat_processus, REL))
 1813:                     == NULL)
 1814:             {
 1815:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1816:                 return;
 1817:             }
 1818: 
 1819:             (*((real8 *) (*s_objet_resultat).objet)) =
 1820:                     ((real8 **) (*((struct_matrice *) (*s_objet_2).objet))
 1821:                     .tableau)[indice_i - 1][indice_j - 1];
 1822:         }
 1823:         else
 1824:         {
 1825:             /*
 1826:              * Matrices de complexes
 1827:              */
 1828: 
 1829:             if ((s_objet_resultat = allocation(s_etat_processus, CPL))
 1830:                     == NULL)
 1831:             {
 1832:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1833:                 return;
 1834:             }
 1835: 
 1836:             (*((struct_complexe16 *) (*s_objet_resultat).objet)).partie_reelle =
 1837:                     ((struct_complexe16 **) (*((struct_matrice *)
 1838:                     (*s_objet_2).objet)).tableau)[indice_i - 1]
 1839:                     [indice_j - 1].partie_reelle;
 1840:             (*((struct_complexe16 *) (*s_objet_resultat).objet))
 1841:                     .partie_imaginaire = ((struct_complexe16 **)
 1842:                     (*((struct_matrice *) (*s_objet_2).objet)).tableau)
 1843:                     [indice_i - 1][indice_j - 1].partie_imaginaire;
 1844:         }
 1845: 
 1846: 
 1847:         if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *)
 1848:                 (*s_objet_1).objet)).suivant).donnee).objet))) >
 1849:                 (integer8) (*((struct_matrice *) (*s_objet_2).objet))
 1850:                 .nombre_colonnes)
 1851:         {
 1852:             (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_1)
 1853:                     .objet)).suivant).donnee).objet)) = 1;
 1854: 
 1855:             if ((++(*((integer8 *) (*(*((struct_liste_chainee *)
 1856:                     (*s_objet_1).objet)).donnee).objet))) >
 1857:                     (integer8) (*((struct_matrice *) (*s_objet_2).objet))
 1858:                     .nombre_lignes)
 1859:             {
 1860:                 (*((integer8 *) (*(*((struct_liste_chainee *)
 1861:                         (*s_objet_1).objet)).donnee).objet)) = 1;
 1862:             }
 1863:         }
 1864:     }
 1865: 
 1866: /*
 1867: --------------------------------------------------------------------------------
 1868:   Traitement des listes
 1869: --------------------------------------------------------------------------------
 1870: */
 1871: 
 1872:     else if ((*s_objet_2).type == LST)
 1873:     {
 1874:         if ((*s_objet_1).type != INT)
 1875:         {
 1876:             liberation(s_etat_processus, s_objet_1);
 1877:             liberation(s_etat_processus, s_objet_2);
 1878: 
 1879:             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
 1880:             return;
 1881:         }
 1882: 
 1883:         nombre_elements = 0;
 1884:         l_element_courant = (*s_objet_2).objet;
 1885: 
 1886:         while(l_element_courant != NULL)
 1887:         {
 1888:             l_element_courant = (*l_element_courant).suivant;
 1889:             nombre_elements++;
 1890:         }
 1891: 
 1892:         indice_i = (*((integer8 *) (*s_objet_1).objet));
 1893:         indice_j = 1;
 1894:         l_element_courant = (*s_objet_2).objet;
 1895: 
 1896:         while((l_element_courant != NULL) && (indice_j != indice_i))
 1897:         {
 1898:             l_element_courant = (*l_element_courant).suivant;
 1899:             indice_j++;
 1900:         }
 1901: 
 1902:         if (l_element_courant != NULL)
 1903:         {
 1904:             if ((s_objet_resultat = copie_objet(s_etat_processus,
 1905:                     (*l_element_courant).donnee, 'O')) == NULL)
 1906:             {
 1907:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 1908:                 return;
 1909:             }
 1910:         }
 1911:         else
 1912:         {
 1913:             liberation(s_etat_processus, s_objet_1);
 1914:             liberation(s_etat_processus, s_objet_2);
 1915: 
 1916:             (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
 1917:             return;
 1918:         }
 1919: 
 1920:         (*((integer8 *) (*s_objet_1).objet)) =
 1921:                 (indice_i % nombre_elements) + 1;
 1922:     }
 1923: 
 1924: /*
 1925: --------------------------------------------------------------------------------
 1926:   Traitement des variables
 1927: --------------------------------------------------------------------------------
 1928: */
 1929: 
 1930:     else if ((*s_objet_2).type == NOM)
 1931:     {
 1932:         variable_partagee = d_faux;
 1933: 
 1934:         if (recherche_variable(s_etat_processus, (*((struct_nom *)
 1935:                 (*s_objet_2).objet)).nom) == d_faux)
 1936:         {
 1937:             (*s_etat_processus).erreur_systeme = d_es;
 1938:             (*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
 1939: 
 1940:             liberation(s_etat_processus, s_objet_1);
 1941:             liberation(s_etat_processus, s_objet_2);
 1942: 
 1943:             return;
 1944:         }
 1945: 
 1946:         s_objet_3 = (*(*s_etat_processus).pointeur_variable_courante).objet;
 1947: 
 1948:         if (s_objet_3 == NULL)
 1949:         {
 1950:             if (recherche_variable_partagee(s_etat_processus,
 1951:                     (*(*s_etat_processus).pointeur_variable_courante).nom,
 1952:                     (*(*s_etat_processus).pointeur_variable_courante)
 1953:                     .variable_partagee, (*(*s_etat_processus)
 1954:                     .pointeur_variable_courante).origine) == NULL)
 1955:             {
 1956:                 (*s_etat_processus).erreur_systeme = d_es;
 1957:                 (*s_etat_processus).erreur_execution =
 1958:                         d_ex_variable_non_definie;
 1959: 
 1960:                 liberation(s_etat_processus, s_objet_1);
 1961:                 liberation(s_etat_processus, s_objet_2);
 1962: 
 1963:                 return;
 1964:             }
 1965: 
 1966:             s_objet_3 = (*(*s_etat_processus)
 1967:                     .pointeur_variable_partagee_courante).objet;
 1968:             variable_partagee = d_vrai;
 1969:         }
 1970: 
 1971:         if (((*s_objet_3).type == VIN) ||
 1972:                 ((*s_objet_3).type == VRL) ||
 1973:                 ((*s_objet_3).type == VCX))
 1974:         {
 1975:             if ((*s_objet_1).type != LST)
 1976:             {
 1977:                 if (variable_partagee == d_vrai)
 1978:                 {
 1979:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 1980:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 1981:                     {
 1982:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 1983:                         return;
 1984:                     }
 1985:                 }
 1986: 
 1987:                 liberation(s_etat_processus, s_objet_1);
 1988:                 liberation(s_etat_processus, s_objet_2);
 1989: 
 1990:                 (*s_etat_processus).erreur_execution =
 1991:                         d_ex_erreur_type_argument;
 1992:                 return;
 1993:             }
 1994: 
 1995:             l_element_courant = (*s_objet_1).objet;
 1996:             nombre_dimensions = 0;
 1997: 
 1998:             while(l_element_courant != NULL)
 1999:             {
 2000:                 nombre_dimensions++;
 2001:                 l_element_courant = (*l_element_courant).suivant;
 2002:             }
 2003: 
 2004:             if (nombre_dimensions != 1)
 2005:             {
 2006:                 if (variable_partagee == d_vrai)
 2007:                 {
 2008:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2009:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 2010:                     {
 2011:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 2012:                         return;
 2013:                     }
 2014:                 }
 2015: 
 2016:                 liberation(s_etat_processus, s_objet_1);
 2017:                 liberation(s_etat_processus, s_objet_2);
 2018: 
 2019:                 (*s_etat_processus).erreur_execution =
 2020:                         d_ex_dimensions_invalides;
 2021:                 return;
 2022:             }
 2023: 
 2024:             l_element_courant = (*s_objet_1).objet;
 2025: 
 2026:             if ((*(*l_element_courant).donnee).type != INT)
 2027:             {
 2028:                 if (variable_partagee == d_vrai)
 2029:                 {
 2030:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2031:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 2032:                     {
 2033:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 2034:                         return;
 2035:                     }
 2036:                 }
 2037: 
 2038:                 liberation(s_etat_processus, s_objet_1);
 2039:                 liberation(s_etat_processus, s_objet_2);
 2040: 
 2041:                 (*s_etat_processus).erreur_execution =
 2042:                         d_ex_erreur_type_argument;
 2043:                 return;
 2044:             }
 2045: 
 2046:             if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) <= 0)
 2047:             {
 2048:                 if (variable_partagee == d_vrai)
 2049:                 {
 2050:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2051:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 2052:                     {
 2053:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 2054:                         return;
 2055:                     }
 2056:                 }
 2057: 
 2058:                 liberation(s_etat_processus, s_objet_1);
 2059:                 liberation(s_etat_processus, s_objet_2);
 2060: 
 2061:                 (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
 2062:                 return;
 2063:             }
 2064:             else if ((*((integer8 *) (*(*l_element_courant).donnee).objet)) >
 2065:                     (integer8) (*((struct_vecteur *) (*s_objet_3).objet))
 2066:                     .taille)
 2067:             {
 2068:                 if (variable_partagee == d_vrai)
 2069:                 {
 2070:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2071:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 2072:                     {
 2073:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 2074:                         return;
 2075:                     }
 2076:                 }
 2077: 
 2078:                 liberation(s_etat_processus, s_objet_1);
 2079:                 liberation(s_etat_processus, s_objet_2);
 2080: 
 2081:                 (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
 2082:                 return;
 2083:             }
 2084: 
 2085:             indice_i = (*((integer8 *) (*(*l_element_courant).donnee).objet));
 2086: 
 2087:             if ((*s_objet_3).type == VIN)
 2088:             {
 2089:                 /*
 2090:                  * Vecteur d'entiers
 2091:                  */
 2092: 
 2093:                 if ((s_objet_resultat = allocation(s_etat_processus, INT))
 2094:                         == NULL)
 2095:                 {
 2096:                     if (variable_partagee == d_vrai)
 2097:                     {
 2098:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2099:                                 .pointeur_variable_partagee_courante).mutex))
 2100:                                 != 0)
 2101:                         {
 2102:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 2103:                             return;
 2104:                         }
 2105:                     }
 2106: 
 2107:                     (*s_etat_processus).erreur_systeme
 2108:                             = d_es_allocation_memoire;
 2109:                     return;
 2110:                 }
 2111: 
 2112:                 (*((integer8 *) (*s_objet_resultat).objet)) =
 2113:                         ((integer8 *) (*((struct_vecteur *)
 2114:                         (*s_objet_3).objet)).tableau)[indice_i - 1];
 2115:             }
 2116:             else if ((*s_objet_3).type == VRL)
 2117:             {
 2118:                 /*
 2119:                  * Vecteur de réels
 2120:                  */
 2121: 
 2122:                 if ((s_objet_resultat = allocation(s_etat_processus, REL))
 2123:                         == NULL)
 2124:                 {
 2125:                     if (variable_partagee == d_vrai)
 2126:                     {
 2127:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2128:                                 .pointeur_variable_partagee_courante).mutex))
 2129:                                 != 0)
 2130:                         {
 2131:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 2132:                             return;
 2133:                         }
 2134:                     }
 2135: 
 2136:                     (*s_etat_processus).erreur_systeme
 2137:                             = d_es_allocation_memoire;
 2138:                     return;
 2139:                 }
 2140: 
 2141:                 (*((real8 *) (*s_objet_resultat).objet)) =
 2142:                         ((real8 *) (*((struct_vecteur *) (*s_objet_3).objet))
 2143:                         .tableau)[indice_i - 1];
 2144:             }
 2145:             else
 2146:             {
 2147:                 /*
 2148:                  * Vecteur de complexes
 2149:                  */
 2150: 
 2151:                 if ((s_objet_resultat = allocation(s_etat_processus, CPL))
 2152:                         == NULL)
 2153:                 {
 2154:                     if (variable_partagee == d_vrai)
 2155:                     {
 2156:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2157:                                 .pointeur_variable_partagee_courante).mutex))
 2158:                                 != 0)
 2159:                         {
 2160:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 2161:                             return;
 2162:                         }
 2163:                     }
 2164: 
 2165:                     (*s_etat_processus).erreur_systeme
 2166:                             = d_es_allocation_memoire;
 2167:                     return;
 2168:                 }
 2169: 
 2170:                 (*((struct_complexe16 *) (*s_objet_resultat).objet))
 2171:                         .partie_reelle = ((struct_complexe16 *)
 2172:                         (*((struct_vecteur *) (*s_objet_3).objet))
 2173:                         .tableau)[indice_i - 1].partie_reelle;
 2174:                 (*((struct_complexe16 *) (*s_objet_resultat).objet))
 2175:                         .partie_imaginaire = ((struct_complexe16 *)
 2176:                         (*((struct_vecteur *) (*s_objet_3).objet)).tableau)
 2177:                         [indice_i - 1].partie_imaginaire;
 2178:             }
 2179: 
 2180:             (*((integer8 *) (*(*l_element_courant).donnee).objet)) =
 2181:                     (indice_i % (*((struct_vecteur *) (*s_objet_3).objet))
 2182:                     .taille) + 1;
 2183:         }
 2184:         else if (((*s_objet_3).type == MIN) ||
 2185:                 ((*s_objet_3).type == MRL) ||
 2186:                 ((*s_objet_3).type == MCX))
 2187:         {
 2188:             if ((*s_objet_1).type != LST)
 2189:             {
 2190:                 if (variable_partagee == d_vrai)
 2191:                 {
 2192:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2193:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 2194:                     {
 2195:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 2196:                         return;
 2197:                     }
 2198:                 }
 2199: 
 2200:                 liberation(s_etat_processus, s_objet_1);
 2201:                 liberation(s_etat_processus, s_objet_2);
 2202: 
 2203:                 (*s_etat_processus).erreur_execution =
 2204:                         d_ex_erreur_type_argument;
 2205:                 return;
 2206:             }
 2207: 
 2208:             l_element_courant = (*s_objet_1).objet;
 2209:             nombre_dimensions = 0;
 2210: 
 2211:             while(l_element_courant != NULL)
 2212:             {
 2213:                 nombre_dimensions++;
 2214:                 l_element_courant = (*l_element_courant).suivant;
 2215:             }
 2216: 
 2217:             if (nombre_dimensions != 2)
 2218:             {
 2219:                 if (variable_partagee == d_vrai)
 2220:                 {
 2221:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2222:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 2223:                     {
 2224:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 2225:                         return;
 2226:                     }
 2227:                 }
 2228: 
 2229:                 liberation(s_etat_processus, s_objet_1);
 2230:                 liberation(s_etat_processus, s_objet_2);
 2231: 
 2232:                 (*s_etat_processus).erreur_execution =
 2233:                         d_ex_dimensions_invalides;
 2234:                 return;
 2235:             }
 2236: 
 2237:             l_element_courant = (*s_objet_1).objet;
 2238: 
 2239:             indice_i = 0;
 2240:             indice_j = 0;
 2241: 
 2242:             while(l_element_courant != NULL)
 2243:             {
 2244:                 if ((*(*l_element_courant).donnee).type != INT)
 2245:                 {
 2246:                     if (variable_partagee == d_vrai)
 2247:                     {
 2248:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2249:                                 .pointeur_variable_partagee_courante).mutex))
 2250:                                 != 0)
 2251:                         {
 2252:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 2253:                             return;
 2254:                         }
 2255:                     }
 2256: 
 2257:                     liberation(s_etat_processus, s_objet_1);
 2258:                     liberation(s_etat_processus, s_objet_2);
 2259: 
 2260:                     (*s_etat_processus).erreur_execution =
 2261:                             d_ex_erreur_type_argument;
 2262:                     return;
 2263:                 }
 2264: 
 2265:                 if ((*((integer8 *) (*(*l_element_courant)
 2266:                         .donnee).objet)) <= 0)
 2267:                 {
 2268:                     if (variable_partagee == d_vrai)
 2269:                     {
 2270:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2271:                                 .pointeur_variable_partagee_courante).mutex))
 2272:                                 != 0)
 2273:                         {
 2274:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 2275:                             return;
 2276:                         }
 2277:                     }
 2278: 
 2279:                     liberation(s_etat_processus, s_objet_1);
 2280:                     liberation(s_etat_processus, s_objet_2);
 2281: 
 2282:                     (*s_etat_processus).erreur_execution =
 2283:                             d_ex_argument_invalide;
 2284:                     return;
 2285:                 }
 2286: 
 2287:                 if (indice_i == 0)
 2288:                 {
 2289:                     indice_i = (*((integer8 *)
 2290:                             (*(*l_element_courant).donnee).objet));
 2291:                 }
 2292:                 else
 2293:                 {
 2294:                     indice_j = (*((integer8 *)
 2295:                             (*(*l_element_courant).donnee).objet));
 2296:                 }
 2297: 
 2298:                 l_element_courant = (*l_element_courant).suivant;
 2299:             }
 2300: 
 2301:             if ((indice_i > (*((struct_matrice *) (*s_objet_3).objet))
 2302:                     .nombre_lignes) || (indice_j > (*((struct_matrice *)
 2303:                     (*s_objet_3).objet)).nombre_colonnes))
 2304:             {
 2305:                 if (variable_partagee == d_vrai)
 2306:                 {
 2307:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2308:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 2309:                     {
 2310:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 2311:                         return;
 2312:                     }
 2313:                 }
 2314: 
 2315:                 liberation(s_etat_processus, s_objet_1);
 2316:                 liberation(s_etat_processus, s_objet_2);
 2317: 
 2318:                 (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
 2319:                 return;
 2320:             }
 2321: 
 2322:             if ((*s_objet_3).type == MIN)
 2323:             {
 2324:                 /*
 2325:                  * Matrice d'entiers
 2326:                  */
 2327: 
 2328:                 if ((s_objet_resultat = allocation(s_etat_processus, INT))
 2329:                         == NULL)
 2330:                 {
 2331:                     if (variable_partagee == d_vrai)
 2332:                     {
 2333:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2334:                                 .pointeur_variable_partagee_courante).mutex))
 2335:                                 != 0)
 2336:                         {
 2337:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 2338:                             return;
 2339:                         }
 2340:                     }
 2341: 
 2342:                     (*s_etat_processus).erreur_systeme =
 2343:                             d_es_allocation_memoire;
 2344:                     return;
 2345:                 }
 2346: 
 2347:                 (*((integer8 *) (*s_objet_resultat).objet)) =
 2348:                         ((integer8 **) (*((struct_matrice *)
 2349:                         (*s_objet_3).objet))
 2350:                         .tableau)[indice_i - 1][indice_j - 1];
 2351:             }
 2352:             else if ((*s_objet_3).type == MRL)
 2353:             {
 2354:                 /*
 2355:                  * Matrice de réels
 2356:                  */
 2357: 
 2358:                 if ((s_objet_resultat = allocation(s_etat_processus, REL))
 2359:                         == NULL)
 2360:                 {
 2361:                     if (variable_partagee == d_vrai)
 2362:                     {
 2363:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2364:                                 .pointeur_variable_partagee_courante).mutex))
 2365:                                 != 0)
 2366:                         {
 2367:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 2368:                             return;
 2369:                         }
 2370:                     }
 2371: 
 2372:                     (*s_etat_processus).erreur_systeme =
 2373:                             d_es_allocation_memoire;
 2374:                     return;
 2375:                 }
 2376: 
 2377:                 (*((real8 *) (*s_objet_resultat).objet)) =
 2378:                         ((real8 **) (*((struct_matrice *) (*s_objet_3).objet))
 2379:                         .tableau)[indice_i - 1][indice_j - 1];
 2380:             }
 2381:             else
 2382:             {
 2383:                 /*
 2384:                  * Matrices de complexes
 2385:                  */
 2386: 
 2387:                 if ((s_objet_resultat = allocation(s_etat_processus, CPL))
 2388:                         == NULL)
 2389:                 {
 2390:                     if (variable_partagee == d_vrai)
 2391:                     {
 2392:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2393:                                 .pointeur_variable_partagee_courante).mutex))
 2394:                                 != 0)
 2395:                         {
 2396:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 2397:                             return;
 2398:                         }
 2399:                     }
 2400: 
 2401:                     (*s_etat_processus).erreur_systeme =
 2402:                             d_es_allocation_memoire;
 2403:                     return;
 2404:                 }
 2405: 
 2406:                 (*((struct_complexe16 *) (*s_objet_resultat).objet))
 2407:                         .partie_reelle = ((struct_complexe16 **)
 2408:                         (*((struct_matrice *)
 2409:                         (*s_objet_3).objet)).tableau)[indice_i - 1]
 2410:                         [indice_j - 1].partie_reelle;
 2411:                 (*((struct_complexe16 *) (*s_objet_resultat).objet))
 2412:                         .partie_imaginaire = ((struct_complexe16 **)
 2413:                         (*((struct_matrice *) (*s_objet_3).objet)).tableau)
 2414:                         [indice_i - 1][indice_j - 1].partie_imaginaire;
 2415:             }
 2416: 
 2417:             if ((++(*((integer8 *) (*(*(*((struct_liste_chainee *)
 2418:                     (*s_objet_1).objet)).suivant).donnee).objet))) >
 2419:                     (integer8) (*((struct_matrice *) (*s_objet_3).objet))
 2420:                     .nombre_colonnes)
 2421:             {
 2422:                 (*((integer8 *) (*(*(*((struct_liste_chainee *) (*s_objet_1)
 2423:                         .objet)).suivant).donnee).objet)) = 1;
 2424: 
 2425:                 if ((++(*((integer8 *) (*(*((struct_liste_chainee *)
 2426:                         (*s_objet_1).objet)).donnee).objet))) >
 2427:                         (integer8) (*((struct_matrice *) (*s_objet_3).objet))
 2428:                         .nombre_lignes)
 2429:                 {
 2430:                     (*((integer8 *) (*(*((struct_liste_chainee *)
 2431:                             (*s_objet_1).objet)).donnee).objet)) = 1;
 2432:                 }
 2433:             }
 2434:         }
 2435:         else if ((*s_objet_3).type == LST)
 2436:         {
 2437:             if ((*s_objet_1).type != INT)
 2438:             {
 2439:                 if (variable_partagee == d_vrai)
 2440:                 {
 2441:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2442:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 2443:                     {
 2444:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 2445:                         return;
 2446:                     }
 2447:                 }
 2448: 
 2449:                 liberation(s_etat_processus, s_objet_1);
 2450:                 liberation(s_etat_processus, s_objet_2);
 2451: 
 2452:                 (*s_etat_processus).erreur_execution =
 2453:                         d_ex_erreur_type_argument;
 2454:                 return;
 2455:             }
 2456: 
 2457:             nombre_elements = 0;
 2458:             l_element_courant = (*s_objet_3).objet;
 2459: 
 2460:             while(l_element_courant != NULL)
 2461:             {
 2462:                 l_element_courant = (*l_element_courant).suivant;
 2463:                 nombre_elements++;
 2464:             }
 2465: 
 2466:             indice_i = (*((integer8 *) (*s_objet_1).objet));
 2467:             indice_j = 1;
 2468:             l_element_courant = (*s_objet_3).objet;
 2469: 
 2470:             while((l_element_courant != NULL) && (indice_j != indice_i))
 2471:             {
 2472:                 l_element_courant = (*l_element_courant).suivant;
 2473:                 indice_j++;
 2474:             }
 2475: 
 2476:             if (l_element_courant != NULL)
 2477:             {
 2478:                 if ((s_objet_resultat = copie_objet(s_etat_processus,
 2479:                         (*l_element_courant).donnee, 'O')) == NULL)
 2480:                 {
 2481:                     if (variable_partagee == d_vrai)
 2482:                     {
 2483:                         if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2484:                                 .pointeur_variable_partagee_courante).mutex))
 2485:                                 != 0)
 2486:                         {
 2487:                             (*s_etat_processus).erreur_systeme = d_es_processus;
 2488:                             return;
 2489:                         }
 2490:                     }
 2491: 
 2492:                     (*s_etat_processus).erreur_systeme =
 2493:                             d_es_allocation_memoire;
 2494:                     return;
 2495:                 }
 2496:             }
 2497:             else
 2498:             {
 2499:                 if (variable_partagee == d_vrai)
 2500:                 {
 2501:                     if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2502:                             .pointeur_variable_partagee_courante).mutex)) != 0)
 2503:                     {
 2504:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 2505:                         return;
 2506:                     }
 2507:                 }
 2508: 
 2509:                 liberation(s_etat_processus, s_objet_1);
 2510:                 liberation(s_etat_processus, s_objet_2);
 2511: 
 2512:                 (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
 2513:                 return;
 2514:             }
 2515: 
 2516:             (*((integer8 *) (*s_objet_1).objet)) =
 2517:                     (indice_i % nombre_elements) + 1;
 2518:         }
 2519:         else
 2520:         {
 2521:             if (variable_partagee == d_vrai)
 2522:             {
 2523:                 if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2524:                         .pointeur_variable_partagee_courante).mutex)) != 0)
 2525:                 {
 2526:                     (*s_etat_processus).erreur_systeme = d_es_processus;
 2527:                     return;
 2528:                 }
 2529:             }
 2530: 
 2531:             liberation(s_etat_processus, s_objet_1);
 2532:             liberation(s_etat_processus, s_objet_2);
 2533: 
 2534:             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
 2535:             return;
 2536:         }
 2537: 
 2538:         if (variable_partagee == d_vrai)
 2539:         {
 2540:             if (pthread_mutex_unlock(&((*(*s_etat_processus)
 2541:                     .pointeur_variable_partagee_courante).mutex)) != 0)
 2542:             {
 2543:                 (*s_etat_processus).erreur_systeme = d_es_processus;
 2544:                 return;
 2545:             }
 2546:         }
 2547:     }
 2548: 
 2549: /*
 2550: --------------------------------------------------------------------------------
 2551:   Type incompatible avec la fonction GETI
 2552: --------------------------------------------------------------------------------
 2553: */
 2554: 
 2555:     else
 2556:     {
 2557:         liberation(s_etat_processus, s_objet_1);
 2558:         liberation(s_etat_processus, s_objet_2);
 2559: 
 2560:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
 2561:         return;
 2562:     }
 2563: 
 2564:     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 2565:             s_objet_2) == d_erreur)
 2566:     {
 2567:         return;
 2568:     }
 2569: 
 2570:     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 2571:             s_objet_1) == d_erreur)
 2572:     {
 2573:         return;
 2574:     }
 2575: 
 2576:     if ((*s_objet_resultat).type == NOM)
 2577:     {
 2578:         if ((*((struct_nom *) (*s_objet_resultat).objet)).symbole == d_faux)
 2579:         {
 2580:             if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
 2581:             {
 2582:                 return;
 2583:             }
 2584:         }
 2585:         else
 2586:         {
 2587:             if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 2588:                     s_objet_resultat) == d_erreur)
 2589:             {
 2590:                 return;
 2591:             }
 2592:         }
 2593:     }
 2594:     else if ((*s_objet_resultat).type == FCT)
 2595:     {
 2596:         registre_test = (*s_etat_processus).test_instruction;
 2597:         registre_instruction_courante = (*s_etat_processus)
 2598:                 .instruction_courante;
 2599:         registre_instruction_valide = (*s_etat_processus)
 2600:                 .instruction_valide;
 2601: 
 2602:         (*s_etat_processus).test_instruction = 'Y';
 2603:         (*s_etat_processus).instruction_courante =
 2604:                 (*((struct_fonction *) (*s_objet_resultat).objet)).nom_fonction;
 2605: 
 2606:         analyse(s_etat_processus, NULL);
 2607: 
 2608:         (*s_etat_processus).test_instruction = registre_test;
 2609:         (*s_etat_processus).instruction_courante =
 2610:                 registre_instruction_courante;
 2611: 
 2612:         if (((*s_etat_processus).instruction_valide == 'Y') &&
 2613:                 (*s_etat_processus).constante_symbolique == 'Y')
 2614:         {
 2615:             if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
 2616:             {
 2617:                 (*s_etat_processus).instruction_valide =
 2618:                         registre_instruction_valide;
 2619:                 return;
 2620:             }
 2621:         }
 2622:         else
 2623:         {
 2624:             if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 2625:                     s_objet_resultat) == d_erreur)
 2626:             {
 2627:                 (*s_etat_processus).instruction_valide =
 2628:                         registre_instruction_valide;
 2629:                 return;
 2630:             }
 2631:         }
 2632: 
 2633:         (*s_etat_processus).instruction_valide = registre_instruction_valide;
 2634:     }
 2635:     else
 2636:     {
 2637:         if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 2638:                 s_objet_resultat) == d_erreur)
 2639:         {
 2640:             return;
 2641:         }
 2642:     }
 2643: 
 2644:     return;
 2645: }
 2646: 
 2647: // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>