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

CVSweb interface <joel.bertrand@systella.fr>