File:  [local] / rpl / src / instructions_r4.c
Revision 1.112: download - view: text, annotated - select for diffs - revision graph
Fri Jan 10 11:15:47 2020 UTC (4 years, 2 months ago) by bertrand
Branches: MAIN
CVS tags: 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 'r->b'
   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_r_vers_b(struct_processus *s_etat_processus)
   40: {
   41:     struct_objet                *s_objet_argument;
   42:     struct_objet                *s_objet_resultat;
   43: 
   44:     (*s_etat_processus).erreur_execution = d_ex;
   45: 
   46:     if ((*s_etat_processus).affichage_arguments == 'Y')
   47:     {
   48:         printf("\n  R->B ");
   49: 
   50:         if ((*s_etat_processus).langue == 'F')
   51:         {
   52:             printf("(réel vers binaire)\n\n");
   53:         }
   54:         else
   55:         {
   56:             printf("(real to binary)\n\n");
   57:         }
   58: 
   59:         printf("    1: %s\n", d_INT);
   60:         printf("->  1: %s\n", d_BIN);
   61: 
   62:         return;
   63:     }
   64:     else if ((*s_etat_processus).test_instruction == 'Y')
   65:     {
   66:         (*s_etat_processus).nombre_arguments = -1;
   67:         return;
   68:     }
   69: 
   70:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
   71:     {
   72:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
   73:         {
   74:             return;
   75:         }
   76:     }
   77: 
   78:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
   79:             &s_objet_argument) == d_erreur)
   80:     {
   81:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
   82:         return;
   83:     }
   84: 
   85:     if ((*s_objet_argument).type == INT)
   86:     {
   87:         if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
   88:         {
   89:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
   90:             return;
   91:         }
   92: 
   93:         if ((*((integer8 *) (*s_objet_argument).objet)) < 0)
   94:         {
   95:             (*((logical8 *) (*s_objet_resultat).objet)) = 0;
   96:         }
   97:         else
   98:         {
   99:             (*((logical8 *) (*s_objet_resultat).objet)) = (logical8)
  100:                     (*((integer8 *) (*s_objet_argument).objet));
  101:         }
  102:     }
  103:     else
  104:     {
  105:         liberation(s_etat_processus, s_objet_argument);
  106: 
  107:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  108:         return;
  109:     }
  110: 
  111:     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  112:             s_objet_resultat) == d_erreur)
  113:     {
  114:         return;
  115:     }
  116: 
  117:     liberation(s_etat_processus, s_objet_argument);
  118:     return;
  119: }
  120: 
  121: 
  122: /*
  123: ================================================================================
  124:   Fonction 'rl'
  125: ================================================================================
  126:   Entrées : pointeur sur une structure struct_processus
  127: --------------------------------------------------------------------------------
  128:   Sorties :
  129: --------------------------------------------------------------------------------
  130:   Effets de bord : néant
  131: ================================================================================
  132: */
  133: 
  134: void
  135: instruction_rl(struct_processus *s_etat_processus)
  136: {
  137:     logical8                            masque;
  138:     logical8                            tampon;
  139: 
  140:     struct_objet                        *s_copie;
  141:     struct_objet                        *s_objet;
  142: 
  143:     unsigned long                       i;
  144:     unsigned long                       j;
  145:     unsigned long                       longueur;
  146: 
  147:     (*s_etat_processus).erreur_execution = d_ex;
  148: 
  149:     if ((*s_etat_processus).affichage_arguments == 'Y')
  150:     {
  151:         printf("\n  RL ");
  152: 
  153:         if ((*s_etat_processus).langue == 'F')
  154:         {
  155:             printf("(rotation à gauche)\n\n");
  156:         }
  157:         else
  158:         {
  159:             printf("(rotate left)\n\n");
  160:         }
  161: 
  162:         printf("    1: %s\n", d_BIN);
  163:         printf("->  1: %s\n", d_BIN);
  164: 
  165:         return;
  166:     }
  167:     else if ((*s_etat_processus).test_instruction == 'Y')
  168:     {
  169:         (*s_etat_processus).nombre_arguments = -1;
  170:         return;
  171:     }
  172: 
  173:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  174:     {
  175:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
  176:         {
  177:             return;
  178:         }
  179:     }
  180: 
  181:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  182:             &s_objet) == d_erreur)
  183:     {
  184:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  185:         return;
  186:     }
  187: 
  188:     if ((*s_objet).type == BIN)
  189:     {
  190:         if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
  191:         {
  192:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  193:             return;
  194:         }
  195: 
  196:         longueur = 1;
  197:         j = 1;
  198: 
  199:         for(i = 37; i <= 42; i++)
  200:         {
  201:             longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
  202:                     == d_vrai) ? j : 0;
  203:             j *= 2;
  204:         }
  205: 
  206:         tampon = (*((logical8 *) (*s_copie).objet));
  207:         masque = ((logical8) 1) << (longueur - 1);
  208: 
  209:         if ((tampon & masque) == 0)
  210:         {
  211:             tampon <<= 1;
  212:         }
  213:         else
  214:         {
  215:             tampon <<= 1;
  216:             tampon |= (logical8) 1;
  217:         }
  218: 
  219:         for(masque = 0, i = 0; i < longueur; i++)
  220:         {
  221:             masque <<= 1;
  222:             masque |= (logical8) 1;
  223:         }
  224: 
  225:         tampon &= masque;
  226:         (*((logical8 *) (*s_copie).objet)) = tampon;
  227: 
  228:         if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  229:                 s_copie) == d_erreur)
  230:         {
  231:             return;
  232:         }
  233:     }
  234:     else
  235:     {
  236:         liberation(s_etat_processus, s_objet);
  237: 
  238:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  239:         return;
  240:     }
  241: 
  242:     liberation(s_etat_processus, s_objet);
  243: 
  244:     return;
  245: }
  246: 
  247: 
  248: /*
  249: ================================================================================
  250:   Fonction 'rlb'
  251: ================================================================================
  252:   Entrées : pointeur sur une structure struct_processus
  253: --------------------------------------------------------------------------------
  254:   Sorties :
  255: --------------------------------------------------------------------------------
  256:   Effets de bord : néant
  257: ================================================================================
  258: */
  259: 
  260: void
  261: instruction_rlb(struct_processus *s_etat_processus)
  262: {
  263:     struct_liste_chainee    *l_base_pile;
  264: 
  265:     unsigned long           i;
  266: 
  267:     (*s_etat_processus).erreur_execution = d_ex;
  268: 
  269:     if ((*s_etat_processus).affichage_arguments == 'Y')
  270:     {
  271:         printf("\n  RLB ");
  272: 
  273:         if ((*s_etat_processus).langue == 'F')
  274:         {
  275:             printf("(rotation d'un octet vers la gauche)\n\n");
  276:         }
  277:         else
  278:         {
  279:             printf("(rotate left byte)\n\n");
  280:         }
  281: 
  282:         printf("    1: %s\n", d_BIN);
  283:         printf("->  1: %s\n", d_BIN);
  284: 
  285:         return;
  286:     }
  287:     else if ((*s_etat_processus).test_instruction == 'Y')
  288:     {
  289:         (*s_etat_processus).nombre_arguments = -1;
  290:         return;
  291:     }
  292: 
  293:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  294:     {
  295:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
  296:         {
  297:             return;
  298:         }
  299:     }
  300: 
  301:     l_base_pile = (*s_etat_processus).l_base_pile_last;
  302:     (*s_etat_processus).l_base_pile_last = NULL;
  303: 
  304:     for(i = 0; i < 8; i++)
  305:     {
  306:         instruction_rl(s_etat_processus);
  307: 
  308:         if (((*s_etat_processus).erreur_systeme != d_es) ||
  309:                 ((*s_etat_processus).erreur_execution != d_ex))
  310:         {
  311:             break;
  312:         }
  313:     }
  314: 
  315:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  316:     {
  317:         if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
  318:         {
  319:             return;
  320:         }
  321:     }
  322: 
  323:     (*s_etat_processus).l_base_pile_last = l_base_pile;
  324:     return;
  325: }
  326: 
  327: 
  328: /*
  329: ================================================================================
  330:   Fonction 'rr'
  331: ================================================================================
  332:   Entrées : pointeur sur une structure struct_processus
  333: --------------------------------------------------------------------------------
  334:   Sorties :
  335: --------------------------------------------------------------------------------
  336:   Effets de bord : néant
  337: ================================================================================
  338: */
  339: 
  340: void
  341: instruction_rr(struct_processus *s_etat_processus)
  342: {
  343:     logical8                            masque;
  344:     logical8                            tampon;
  345: 
  346:     struct_objet                        *s_copie;
  347:     struct_objet                        *s_objet;
  348: 
  349:     unsigned long                       i;
  350:     unsigned long                       j;
  351:     unsigned long                       longueur;
  352: 
  353:     (*s_etat_processus).erreur_execution = d_ex;
  354: 
  355:     if ((*s_etat_processus).affichage_arguments == 'Y')
  356:     {
  357:         printf("\n  RR ");
  358: 
  359:         if ((*s_etat_processus).langue == 'F')
  360:         {
  361:             printf("(rotation à droite)\n\n");
  362:         }
  363:         else
  364:         {
  365:             printf("(rotate right)\n\n");
  366:         }
  367: 
  368:         printf("    1: %s\n", d_BIN);
  369:         printf("->  1: %s\n", d_BIN);
  370: 
  371:         return;
  372:     }
  373:     else if ((*s_etat_processus).test_instruction == 'Y')
  374:     {
  375:         (*s_etat_processus).nombre_arguments = -1;
  376:         return;
  377:     }
  378: 
  379:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  380:     {
  381:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
  382:         {
  383:             return;
  384:         }
  385:     }
  386: 
  387:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  388:             &s_objet) == d_erreur)
  389:     {
  390:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  391:         return;
  392:     }
  393: 
  394:     if ((*s_objet).type == BIN)
  395:     {
  396:         if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
  397:         {
  398:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  399:             return;
  400:         }
  401: 
  402:         longueur = 1;
  403:         j = 1;
  404: 
  405:         for(i = 37; i <= 42; i++)
  406:         {
  407:             longueur += (test_cfsf(s_etat_processus, (unsigned char) i)
  408:                     == d_vrai) ? j : 0;
  409:             j *= 2;
  410:         }
  411: 
  412:         tampon = (*((logical8 *) (*s_copie).objet));
  413:         masque = (logical8) 1;
  414: 
  415:         if ((tampon & masque) == 0)
  416:         {
  417:             tampon >>= 1;
  418:         }
  419:         else
  420:         {
  421:             tampon >>=  1;
  422:             tampon |= (((logical8) 1) << (longueur - 1));
  423:         }
  424: 
  425:         for(masque = 0, i = 0; i < longueur; i++)
  426:         {
  427:             masque <<= 1;
  428:             masque |= 1;
  429:         }
  430: 
  431:         tampon &= masque;
  432:         (*((logical8 *) (*s_copie).objet)) = tampon;
  433: 
  434:         if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  435:                 s_copie) == d_erreur)
  436:         {
  437:             return;
  438:         }
  439:     }
  440:     else
  441:     {
  442:         liberation(s_etat_processus, s_objet);
  443: 
  444:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  445:         return;
  446:     }
  447: 
  448:     liberation(s_etat_processus, s_objet);
  449: 
  450:     return;
  451: }
  452: 
  453: 
  454: /*
  455: ================================================================================
  456:   Fonction 'rrb'
  457: ================================================================================
  458:   Entrées : pointeur sur une structure struct_processus
  459: --------------------------------------------------------------------------------
  460:   Sorties :
  461: --------------------------------------------------------------------------------
  462:   Effets de bord : néant
  463: ================================================================================
  464: */
  465: 
  466: void
  467: instruction_rrb(struct_processus *s_etat_processus)
  468: {
  469:     struct_liste_chainee    *l_base_pile;
  470: 
  471:     unsigned long           i;
  472: 
  473:     (*s_etat_processus).erreur_execution = d_ex;
  474: 
  475:     if ((*s_etat_processus).affichage_arguments == 'Y')
  476:     {
  477:         printf("\n  RRB ");
  478: 
  479:         if ((*s_etat_processus).langue == 'F')
  480:         {
  481:             printf("(rotation d'un octet vers la droite)\n\n");
  482:         }
  483:         else
  484:         {
  485:             printf("(rotate right byte)\n\n");
  486:         }
  487: 
  488:         printf("    1: %s\n", d_BIN);
  489:         printf("->  1: %s\n", d_BIN);
  490: 
  491:         return;
  492:     }
  493:     else if ((*s_etat_processus).test_instruction == 'Y')
  494:     {
  495:         (*s_etat_processus).nombre_arguments = -1;
  496:         return;
  497:     }
  498: 
  499:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  500:     {
  501:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
  502:         {
  503:             return;
  504:         }
  505:     }
  506: 
  507:     l_base_pile = (*s_etat_processus).l_base_pile_last;
  508:     (*s_etat_processus).l_base_pile_last = NULL;
  509: 
  510:     for(i = 0; i < 8; i++)
  511:     {
  512:         instruction_rr(s_etat_processus);
  513: 
  514:         if (((*s_etat_processus).erreur_systeme != d_es) ||
  515:                 ((*s_etat_processus).erreur_execution != d_ex))
  516:         {
  517:             break;
  518:         }
  519:     }
  520: 
  521:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  522:     {
  523:         if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
  524:         {
  525:             return;
  526:         }
  527:     }
  528: 
  529:     (*s_etat_processus).l_base_pile_last = l_base_pile;
  530:     return;
  531: }
  532: 
  533: 
  534: /*
  535: ================================================================================
  536:   Fonction 'redraw'
  537: ================================================================================
  538:   Entrées : pointeur sur une structure struct_processus
  539: --------------------------------------------------------------------------------
  540:   Sorties :
  541: --------------------------------------------------------------------------------
  542:   Effets de bord : néant
  543: ================================================================================
  544: */
  545: 
  546: void
  547: instruction_redraw(struct_processus *s_etat_processus)
  548: {
  549:     (*s_etat_processus).erreur_execution = d_ex;
  550: 
  551:     if ((*s_etat_processus).affichage_arguments == 'Y')
  552:     {
  553:         printf("\n  REDRAW ");
  554: 
  555:         if ((*s_etat_processus).langue == 'F')
  556:         {
  557:             printf("(redessine une courbe)\n\n");
  558:             printf("  Aucun argument\n");
  559:         }
  560:         else
  561:         {
  562:             printf("(redraw a graphic)\n\n");
  563:             printf("  No argument\n");
  564:         }
  565: 
  566:         return;
  567:     }
  568:     else if ((*s_etat_processus).test_instruction == 'Y')
  569:     {
  570:         (*s_etat_processus).nombre_arguments = -1;
  571:         return;
  572:     }
  573: 
  574:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  575:     {
  576:         if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
  577:         {
  578:             return;
  579:         }
  580:     }
  581: 
  582:     if ((*s_etat_processus).mise_a_jour_trace_requise == d_vrai)
  583:     {
  584:         (*s_etat_processus).erreur_execution = d_ex_graphique_memorise;
  585:         return;
  586:     }
  587: 
  588:     if ((*s_etat_processus).fichiers_graphiques != NULL)
  589:     {
  590:         appel_gnuplot(s_etat_processus, 'N');
  591:     }
  592: 
  593:     return;
  594: }
  595: 
  596: 
  597: /*
  598: ================================================================================
  599:   Fonction 'remove'
  600: ================================================================================
  601:   Entrées : pointeur sur une structure struct_processus
  602: --------------------------------------------------------------------------------
  603:   Sorties :
  604: --------------------------------------------------------------------------------
  605:   Effets de bord : néant
  606: ================================================================================
  607: */
  608: 
  609: void
  610: instruction_remove(struct_processus *s_etat_processus)
  611: {
  612:     struct_objet                    *s_objet_argument;
  613: 
  614:     (*s_etat_processus).erreur_execution = d_ex;
  615: 
  616:     if ((*s_etat_processus).affichage_arguments == 'Y')
  617:     {
  618:         printf("\n  REMOVE ");
  619: 
  620:         if ((*s_etat_processus).langue == 'F')
  621:         {
  622:             printf("(retrait d'une bibliothèque dynamique)\n\n");
  623:         }
  624:         else
  625:         {
  626:             printf("(remove a shared library)\n\n");
  627:         }
  628: 
  629:         printf("    1: %s\n", d_SLB);
  630: 
  631:         return;
  632:     }
  633:     else if ((*s_etat_processus).test_instruction == 'Y')
  634:     {
  635:         (*s_etat_processus).nombre_arguments = -1;
  636:         return;
  637:     }
  638: 
  639:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  640:     {
  641:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
  642:         {
  643:             return;
  644:         }
  645:     }
  646: 
  647:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  648:             &s_objet_argument) == d_erreur)
  649:     {
  650:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  651:         return;
  652:     }
  653: 
  654:     if ((*s_objet_argument).type == SLB)
  655:     {
  656:         /*
  657:          * On ne décharge que les bibliothèques qui ont été chargées dans
  658:          * le couple pid/tid courant.
  659:          */
  660: 
  661:         if (((*((struct_bibliotheque *) (*s_objet_argument).objet)).pid ==
  662:                 getpid()) && (pthread_equal((*((struct_bibliotheque *)
  663:                 (*s_objet_argument).objet)).tid, pthread_self()) != 0))
  664:         {
  665:             if (retrait_bibliotheque(s_etat_processus,
  666:                     (*s_objet_argument).objet) == d_erreur)
  667:             {
  668:                 liberation(s_etat_processus, s_objet_argument);
  669: 
  670:                 return;
  671:             }
  672:         }
  673:     }
  674:     else
  675:     {
  676:         liberation(s_etat_processus, s_objet_argument);
  677: 
  678:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  679:         return;
  680:     }
  681: 
  682:     liberation(s_etat_processus, s_objet_argument);
  683: 
  684:     return;
  685: }
  686: 
  687: 
  688: /*
  689: ================================================================================
  690:   Fonction 'relax'
  691: ================================================================================
  692:   Entrées : pointeur sur une structure struct_processus
  693: --------------------------------------------------------------------------------
  694:   Sorties :
  695: --------------------------------------------------------------------------------
  696:   Effets de bord : néant
  697: ================================================================================
  698: */
  699: 
  700: void
  701: instruction_relax(struct_processus *s_etat_processus)
  702: {
  703:     (*s_etat_processus).erreur_execution = d_ex;
  704: 
  705:     if ((*s_etat_processus).affichage_arguments == 'Y')
  706:     {
  707:         printf("\n  RELAX ");
  708: 
  709:         if ((*s_etat_processus).langue == 'F')
  710:         {
  711:             printf("(ne fait rien)\n\n");
  712:             printf("  Aucun argument\n");
  713:         }
  714:         else
  715:         {
  716:             printf("(do nothing)\n\n");
  717:             printf("  No argument\n");
  718:         }
  719: 
  720:         return;
  721:     }
  722:     else if ((*s_etat_processus).test_instruction == 'Y')
  723:     {
  724:         (*s_etat_processus).nombre_arguments = 1;
  725:         return;
  726:     }
  727: 
  728:     /*
  729:      * Cette instruction ne fait rien. Elle existe pour être symétrique
  730:      * à l'instruction CHS et permet de traiter les équations de façon
  731:      * simple (Ex : '+pi'). En principe, elle n'a pas a être appelée
  732:      * directement par l'utilisateur.
  733:      */
  734: 
  735:     return;
  736: }
  737: 
  738: 
  739: /*
  740: ================================================================================
  741:   Fonction 'rewind'
  742: ================================================================================
  743:   Entrées : pointeur sur une structure struct_processus
  744: --------------------------------------------------------------------------------
  745:   Sorties :
  746: --------------------------------------------------------------------------------
  747:   Effets de bord : néant
  748: ================================================================================
  749: */
  750: 
  751: void
  752: instruction_rewind(struct_processus *s_etat_processus)
  753: {
  754:     struct_descripteur_fichier      *descripteur;
  755: 
  756:     struct_objet                    *s_objet_argument;
  757: 
  758:     (*s_etat_processus).erreur_execution = d_ex;
  759: 
  760:     if ((*s_etat_processus).affichage_arguments == 'Y')
  761:     {
  762:         printf("\n  REWIND ");
  763: 
  764:         if ((*s_etat_processus).langue == 'F')
  765:         {
  766:             printf("(retour au début d'un fichier)\n\n");
  767:         }
  768:         else
  769:         {
  770:             printf("(rewind a file)\n\n");
  771:         }
  772: 
  773:         printf("    1: %s\n", d_FCH);
  774: 
  775:         return;
  776:     }
  777:     else if ((*s_etat_processus).test_instruction == 'Y')
  778:     {
  779:         (*s_etat_processus).nombre_arguments = -1;
  780:         return;
  781:     }
  782: 
  783:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  784:     {
  785:         if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
  786:         {
  787:             return;
  788:         }
  789:     }
  790: 
  791:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
  792:             &s_objet_argument) == d_erreur)
  793:     {
  794:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  795:         return;
  796:     }
  797: 
  798:     if ((*s_objet_argument).type == FCH)
  799:     {
  800:         if ((descripteur = descripteur_fichier(s_etat_processus,
  801:                 (struct_fichier *) (*s_objet_argument).objet)) == NULL)
  802:         {
  803:             return;
  804:         }
  805: 
  806:         if ((*descripteur).type == 'C')
  807:         {
  808:             if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_SET) != 0)
  809:             {
  810:                 (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  811:                 return;
  812:             }
  813:         }
  814:         else
  815:         {
  816:             liberation(s_etat_processus, s_objet_argument);
  817: 
  818:             (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;
  819:             return;
  820:         }
  821:     }
  822:     else
  823:     {
  824:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
  825:         return;
  826:     }
  827: 
  828:     liberation(s_etat_processus, s_objet_argument);
  829: 
  830:     return;
  831: }
  832: 
  833: 
  834: /*
  835: ================================================================================
  836:   Fonction 'read'
  837: ================================================================================
  838:   Entrées : pointeur sur une structure struct_processus
  839: --------------------------------------------------------------------------------
  840:   Sorties :
  841: --------------------------------------------------------------------------------
  842:   Effets de bord : néant
  843: ================================================================================
  844: */
  845: 
  846: void
  847: instruction_read(struct_processus *s_etat_processus)
  848: {
  849:     const char                      *queue;
  850: 
  851:     int                             c;
  852:     int                             ios;
  853:     int                             timeout;
  854: 
  855:     integer8                        element;
  856:     integer8                        i;
  857:     integer8                        id;
  858:     integer8                        index;
  859:     integer8                        longueur;
  860:     integer8                        position_clef;
  861: 
  862:     integer8                        longueur_effective;
  863:     integer8                        longueur_enregistrement;
  864:     integer8                        longueur_questure;
  865:     integer8                        niveau;
  866:     integer8                        pointeur;
  867:     integer8                        position_finale;
  868:     integer8                        position_initiale;
  869: 
  870:     logical1                        device;
  871:     logical1                        format_degenere;
  872:     logical1                        format_oriente_ligne;
  873:     logical1                        indicateur_48;
  874:     logical1                        presence_chaine;
  875:     logical1                        presence_indicateur;
  876:     logical1                        trame_complete;
  877: 
  878:     socklen_t                       longueur_adresse;
  879: 
  880:     sqlite3_stmt                    *ppStmt;
  881: 
  882:     struct flock                    lock;
  883: 
  884:     struct pollfd                   fds[1];
  885: 
  886:     struct sockaddr_un              adresse_unix;
  887:     struct sockaddr_in              adresse_ipv4;
  888: #   ifdef IPV6
  889:     struct sockaddr_in6             adresse_ipv6;
  890: #   endif
  891: 
  892:     struct termios                  tc;
  893: 
  894:     struct timespec                 attente;
  895: 
  896:     struct_descripteur_fichier      *descripteur;
  897: 
  898:     struct_liste_chainee            *l_element_courant;
  899:     struct_liste_chainee            *l_element_courant_format;
  900:     struct_liste_chainee            *l_element_inclus;
  901: 
  902:     struct_objet                    *s_objet_adresse;
  903:     struct_objet                    *s_objet_argument_1;
  904:     struct_objet                    *s_objet_argument_2;
  905:     struct_objet                    *s_objet_resultat;
  906:     struct_objet                    *s_objet_type;
  907: 
  908:     unsigned char                   caractere;
  909:     unsigned char                   *clef_utf8;
  910:     unsigned char                   *commande;
  911:     unsigned char                   *format_chaine;
  912:     unsigned char                   *ptr;
  913:     unsigned char                   *tampon_lecture;
  914:     unsigned char                   *tampon;
  915:     unsigned char                   *tampon2;
  916:     unsigned char                   *tampon3;
  917: 
  918:     int                             vitesses[] =
  919:                         {
  920:                             50, 75, 110, 134, 150, 200, 300, 600,
  921:                             1200, 1800, 2400, 4800, 9600, 19200, 38400,
  922: #ifdef B57600
  923:                             57600,
  924: #endif
  925: #ifdef B115200
  926:                             115200,
  927: #endif
  928: #ifdef B230400
  929:                             230400,
  930: #endif
  931:                             0
  932:                         };
  933: 
  934:     tcflag_t                        vitesses_constantes[] =
  935:                         {
  936:                             B50, B75, B110, B134, B150, B200, B300, B600,
  937:                             B1200, B1800, B2400, B4800, B9600, B19200, B38400,
  938: #ifdef B57600
  939:                             B57600,
  940: #endif
  941: #ifdef B115200
  942:                             B115200,
  943: #endif
  944: #ifdef B230400
  945:                             B230400,
  946: #endif
  947:                             0
  948:                         };
  949: 
  950:     (*s_etat_processus).erreur_execution = d_ex;
  951: 
  952:     if ((*s_etat_processus).affichage_arguments == 'Y')
  953:     {
  954:         printf("\n  READ ");
  955: 
  956:         if ((*s_etat_processus).langue == 'F')
  957:         {
  958:             printf("(lecture d'un enregistrement d'un fichier)\n\n");
  959:         }
  960:         else
  961:         {
  962:             printf("(read a record of a file)\n\n");
  963:         }
  964: 
  965:         printf("    1: %s, %s\n\n", d_FCH, d_SCK);
  966: 
  967:         printf("    2: %s, %s\n", d_INT, d_CHN);
  968:         printf("    1: %s\n", d_FCH);
  969:         return;
  970:     }
  971:     else if ((*s_etat_processus).test_instruction == 'Y')
  972:     {
  973:         (*s_etat_processus).nombre_arguments = -1;
  974:         return;
  975:     }
  976: 
  977:     if (test_cfsf(s_etat_processus, 31) == d_vrai)
  978:     {
  979:         if ((*s_etat_processus).l_base_pile == NULL)
  980:         {
  981:             (*s_etat_processus).erreur_execution = d_ex_manque_argument;
  982:             return;
  983:         }
  984: 
  985:         if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)
  986:         {
  987:             if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile)
  988:                     .donnee).objet)).acces == 'S')
  989:             {
  990:                 if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
  991:                 {
  992:                     return;
  993:                 }
  994:             }
  995:             else
  996:             {
  997:                 if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
  998:                 {
  999:                     return;
 1000:                 }
 1001:             }
 1002:         }
 1003:         else
 1004:         {
 1005:             if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
 1006:             {
 1007:                 return;
 1008:             }
 1009:         }
 1010:     }
 1011: 
 1012:     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 1013:             &s_objet_argument_1) == d_erreur)
 1014:     {
 1015:         (*s_etat_processus).erreur_execution = d_ex_manque_argument;
 1016:         return;
 1017:     }
 1018: 
 1019:     if ((*s_objet_argument_1).type == FCH)
 1020:     {
 1021:         if ((descripteur = descripteur_fichier(s_etat_processus,
 1022:                 (struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
 1023:         {
 1024:             return;
 1025:         }
 1026: 
 1027:         /*
 1028:          * Vérification des verrous
 1029:          */
 1030: 
 1031:         lock.l_type = F_RDLCK;
 1032:         lock.l_whence = SEEK_SET;
 1033:         lock.l_start = 0;
 1034:         lock.l_len = 0;
 1035:         lock.l_pid = getpid();
 1036: 
 1037:         if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
 1038:                 == -1)
 1039:         {
 1040:             liberation(s_etat_processus, s_objet_argument_1);
 1041: 
 1042:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1043:             return;
 1044:         }
 1045: 
 1046:         if (lock.l_type != F_UNLCK)
 1047:         {
 1048:             liberation(s_etat_processus, s_objet_argument_1);
 1049: 
 1050:             (*s_etat_processus).erreur_execution =
 1051:                     d_ex_fichier_verrouille;
 1052:             return;
 1053:         }
 1054: 
 1055:         /*
 1056:          * Vérification de l'autorisation de lecture
 1057:          */
 1058: 
 1059:         if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
 1060:                 == 'W')
 1061:         {
 1062:             liberation(s_etat_processus, s_objet_argument_1);
 1063: 
 1064:             (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
 1065:             return;
 1066:         }
 1067:         else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).protection
 1068:                 == 'N')
 1069:         {
 1070:             if ((*descripteur).type == 'C')
 1071:             {
 1072:                 if (fflush((*descripteur).descripteur_c) != 0)
 1073:                 {
 1074:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1075:                     return;
 1076:                 }
 1077:             }
 1078:         }
 1079: 
 1080:         if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire == 'N')
 1081:         {
 1082:             /*
 1083:              * Fichiers formatés
 1084:              */
 1085: 
 1086:             if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
 1087:                     == 'S')
 1088:             {
 1089:                 /*
 1090:                  * Fichiers séquentiels
 1091:                  */
 1092: 
 1093:                 longueur_questure = 4096;
 1094: 
 1095:                 if ((tampon_lecture = malloc(((size_t) longueur_questure) *
 1096:                         sizeof(unsigned char))) == NULL)
 1097:                 {
 1098:                     (*s_etat_processus).erreur_systeme =
 1099:                             d_es_allocation_memoire;
 1100:                     return;
 1101:                 }
 1102: 
 1103:                 BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
 1104: 
 1105:                 if ((position_initiale = ftell((*descripteur).descripteur_c))
 1106:                         == -1)
 1107:                 {
 1108:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1109:                     return;
 1110:                 }
 1111: 
 1112:                 do
 1113:                 {
 1114:                     longueur_effective = (integer8) fread(tampon_lecture,
 1115:                             sizeof(unsigned char), (size_t) longueur_questure,
 1116:                             (*descripteur).descripteur_c);
 1117: 
 1118:                     pointeur = 0;
 1119:                     presence_indicateur = d_faux;
 1120: 
 1121:                     while(pointeur < longueur_effective)
 1122:                     {
 1123:                         if (tampon_lecture[pointeur] == '{')
 1124:                         {
 1125:                             presence_indicateur = d_vrai;
 1126:                             break;
 1127:                         }
 1128: 
 1129:                         position_initiale++;
 1130:                         pointeur++;
 1131:                     }
 1132: 
 1133:                     if (presence_indicateur == d_vrai)
 1134:                     {
 1135:                         break;
 1136:                     }
 1137:                 } while(longueur_effective == longueur_questure);
 1138: 
 1139:                 if (presence_indicateur == d_faux)
 1140:                 {
 1141:                     liberation(s_etat_processus, s_objet_argument_1);
 1142:                     free(tampon_lecture);
 1143: 
 1144:                     (*s_etat_processus).erreur_execution =
 1145:                             d_ex_fin_de_fichier_atteinte;
 1146:                     return;
 1147:                 }
 1148: 
 1149:                 position_finale = position_initiale + 1;
 1150:                 presence_chaine = d_faux;
 1151:                 niveau = 1;
 1152: 
 1153:                 if (fseek((*descripteur).descripteur_c, (long) position_finale,
 1154:                         SEEK_SET) != 0)
 1155:                 {
 1156:                     liberation(s_etat_processus, s_objet_argument_1);
 1157:                     free(tampon_lecture);
 1158: 
 1159:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1160:                     return;
 1161:                 }
 1162: 
 1163:                 do
 1164:                 {
 1165:                     longueur_effective = (integer8) fread(tampon_lecture,
 1166:                             sizeof(unsigned char), (size_t) longueur_questure,
 1167:                             (*descripteur).descripteur_c);
 1168: 
 1169:                     pointeur = 0;
 1170:                     presence_indicateur = d_faux;
 1171: 
 1172:                     while(pointeur < longueur_effective)
 1173:                     {
 1174:                         if (tampon_lecture[pointeur] == '"')
 1175:                         {
 1176:                             if (pointeur > 0)
 1177:                             {
 1178:                                 if (tampon_lecture[pointeur - 1] != '\\')
 1179:                                 {
 1180:                                     presence_chaine = (presence_chaine ==
 1181:                                             d_vrai) ? d_faux : d_vrai;
 1182:                                 }
 1183:                             }
 1184:                             else
 1185:                             {
 1186:                                 presence_chaine = (presence_chaine == d_vrai)
 1187:                                         ? d_faux : d_vrai;
 1188:                             }
 1189:                         }
 1190:                         else
 1191:                         {
 1192:                             if (presence_chaine == d_faux)
 1193:                             {
 1194:                                 if (tampon_lecture[pointeur] == '{')
 1195:                                 {
 1196:                                     niveau++;
 1197:                                 }
 1198:                                 else if (tampon_lecture[pointeur] == '}')
 1199:                                 {
 1200:                                     niveau--;
 1201:                                 }
 1202:                             }
 1203:                         }
 1204: 
 1205:                         position_finale++;
 1206:                         pointeur++;
 1207: 
 1208:                         if (niveau == 0)
 1209:                         {
 1210:                             presence_indicateur = d_vrai;
 1211:                             break;
 1212:                         }
 1213:                     }
 1214: 
 1215:                     if (presence_indicateur == d_vrai)
 1216:                     {
 1217:                         break;
 1218:                     }
 1219:                 } while(longueur_effective == longueur_questure);
 1220: 
 1221:                 if (presence_indicateur == d_faux)
 1222:                 {
 1223:                     liberation(s_etat_processus, s_objet_argument_1);
 1224:                     free(tampon_lecture);
 1225: 
 1226:                     (*s_etat_processus).erreur_execution =
 1227:                             d_ex_fin_de_fichier_atteinte;
 1228:                     return;
 1229:                 }
 1230: 
 1231:                 free(tampon_lecture);
 1232:                 longueur_enregistrement = position_finale - position_initiale;
 1233: 
 1234:                 if ((tampon_lecture = malloc(((size_t)
 1235:                         (longueur_enregistrement + 1)) *
 1236:                         sizeof(unsigned char))) == NULL)
 1237:                 {
 1238:                     (*s_etat_processus).erreur_systeme =
 1239:                             d_es_allocation_memoire;
 1240:                     return;
 1241:                 }
 1242: 
 1243:                 if (fseek((*descripteur).descripteur_c,
 1244:                         (long) position_initiale, SEEK_SET) != 0)
 1245:                 {
 1246:                     liberation(s_etat_processus, s_objet_argument_1);
 1247:                     free(tampon_lecture);
 1248: 
 1249:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1250:                     return;
 1251:                 }
 1252: 
 1253:                 longueur_effective = (integer8) fread(tampon_lecture,
 1254:                         sizeof(unsigned char), (size_t) longueur_enregistrement,
 1255:                         (*descripteur).descripteur_c);
 1256: 
 1257:                 if (longueur_effective != longueur_enregistrement)
 1258:                 {
 1259:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1260:                     return;
 1261:                 }
 1262: 
 1263:                 tampon_lecture[longueur_enregistrement] = d_code_fin_chaine;
 1264:                 tampon = (*s_etat_processus).instruction_courante;
 1265: 
 1266:                 if (((*s_etat_processus).instruction_courante =
 1267:                         transliteration(s_etat_processus, tampon_lecture,
 1268:                         "UTF-8", d_locale)) == NULL)
 1269:                 {
 1270:                     (*s_etat_processus).instruction_courante = tampon;
 1271:                     liberation(s_etat_processus, s_objet_argument_1);
 1272:                     free(tampon_lecture);
 1273:                     return;
 1274:                 }
 1275: 
 1276:                 indicateur_48 = test_cfsf(s_etat_processus, 48);
 1277:                 cf(s_etat_processus, 48);
 1278: 
 1279:                 (*s_etat_processus).type_en_cours = NON;
 1280:                 recherche_type(s_etat_processus);
 1281:                 free((*s_etat_processus).instruction_courante);
 1282: 
 1283:                 if ((*s_etat_processus).erreur_execution != d_ex)
 1284:                 {
 1285:                     if (indicateur_48 == d_vrai)
 1286:                     {
 1287:                         sf(s_etat_processus, 48);
 1288:                     }
 1289:                     else
 1290:                     {
 1291:                         cf(s_etat_processus, 48);
 1292:                     }
 1293: 
 1294:                     (*s_etat_processus).instruction_courante = tampon;
 1295:                     free(tampon_lecture);
 1296:                     
 1297:                     liberation(s_etat_processus, s_objet_argument_1);
 1298:                     return;
 1299:                 }
 1300: 
 1301:                 if (indicateur_48 == d_vrai)
 1302:                 {
 1303:                     sf(s_etat_processus, 48);
 1304:                 }
 1305:                 else
 1306:                 {
 1307:                     cf(s_etat_processus, 48);
 1308:                 }
 1309: 
 1310:                 (*s_etat_processus).instruction_courante = tampon;
 1311:                 free(tampon_lecture);
 1312:             }
 1313:             else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
 1314:                     == 'D')
 1315:             {
 1316:                 BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
 1317: 
 1318:                 if (depilement(s_etat_processus, &((*s_etat_processus)
 1319:                         .l_base_pile), &s_objet_argument_2) == d_erreur)
 1320:                 {
 1321:                     (*s_etat_processus).erreur_execution = d_ex_manque_argument;
 1322:                     return;
 1323:                 }
 1324: 
 1325:                 if ((*s_objet_argument_2).type != INT)
 1326:                 {
 1327:                     liberation(s_etat_processus, s_objet_argument_1);
 1328:                     liberation(s_etat_processus, s_objet_argument_2);
 1329: 
 1330:                     (*s_etat_processus).erreur_execution =
 1331:                             d_ex_erreur_type_argument;
 1332:                     return;
 1333:                 }
 1334: 
 1335:                 if (alsprintf(s_etat_processus, &commande,
 1336:                         "select data from data where id = %lld",
 1337:                         (*((integer8 *) (*s_objet_argument_2).objet))) < 0)
 1338:                 {
 1339:                     (*s_etat_processus).erreur_systeme =
 1340:                             d_es_allocation_memoire;
 1341:                     return;
 1342:                 }
 1343: 
 1344:                 if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
 1345:                         commande, (int) strlen(commande), &ppStmt, &queue)
 1346:                         != SQLITE_OK)
 1347:                 {
 1348:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1349:                     return;
 1350:                 }
 1351: 
 1352:                 attente.tv_sec = 0;
 1353:                 attente.tv_nsec = GRANULARITE_us * 1000;
 1354: 
 1355:                 do
 1356:                 {
 1357:                     ios = sqlite3_step(ppStmt);
 1358: 
 1359:                     switch(ios)
 1360:                     {
 1361:                         case SQLITE_ROW:
 1362:                         {
 1363:                             // Résultat attendu
 1364:                             break;
 1365:                         }
 1366: 
 1367:                         case SQLITE_DONE:
 1368:                         {
 1369:                             // Aucun enregistrement
 1370:                             if (sqlite3_finalize(ppStmt) != SQLITE_OK)
 1371:                             {
 1372:                                 (*s_etat_processus).erreur_systeme =
 1373:                                         d_es_erreur_fichier;
 1374:                                 return;
 1375:                             }
 1376: 
 1377:                             free(commande);
 1378: 
 1379:                             liberation(s_etat_processus, s_objet_argument_1);
 1380:                             liberation(s_etat_processus, s_objet_argument_2);
 1381: 
 1382:                             (*s_etat_processus).erreur_execution =
 1383:                                     d_ex_enregistrement_inexistant;
 1384:                             return;
 1385:                         }
 1386: 
 1387:                         case SQLITE_BUSY:
 1388:                         case SQLITE_LOCKED:
 1389:                         {
 1390:                             nanosleep(&attente, NULL);
 1391:                             INCR_GRANULARITE(attente.tv_nsec);
 1392:                             break;
 1393:                         }
 1394: 
 1395:                         default:
 1396:                         {
 1397:                             (*s_etat_processus).erreur_systeme =
 1398:                                     d_es_erreur_fichier;
 1399:                             return;
 1400:                         }
 1401:                     }
 1402:                 } while(ios != SQLITE_ROW);
 1403: 
 1404:                 if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
 1405:                 {
 1406:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1407:                     return;
 1408:                 }
 1409: 
 1410:                 tampon = (*s_etat_processus).instruction_courante;
 1411: 
 1412:                 if ((tampon_lecture = (unsigned char *)
 1413:                         sqlite3_column_text(ppStmt, 0)) == NULL)
 1414:                 {
 1415:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1416:                     return;
 1417:                 }
 1418: 
 1419:                 if (((*s_etat_processus).instruction_courante =
 1420:                         transliteration(s_etat_processus, tampon_lecture,
 1421:                         "UTF-8", d_locale)) == NULL)
 1422:                 {
 1423:                     (*s_etat_processus).instruction_courante = tampon;
 1424: 
 1425:                     liberation(s_etat_processus, s_objet_argument_1);
 1426:                     liberation(s_etat_processus, s_objet_argument_2);
 1427:                     free(commande);
 1428:                     return;
 1429:                 }
 1430: 
 1431:                 indicateur_48 = test_cfsf(s_etat_processus, 48);
 1432:                 cf(s_etat_processus, 48);
 1433: 
 1434:                 (*s_etat_processus).type_en_cours = NON;
 1435:                 recherche_type(s_etat_processus);
 1436: 
 1437:                 if ((*s_etat_processus).erreur_execution != d_ex)
 1438:                 {
 1439:                     if (indicateur_48 == d_vrai)
 1440:                     {
 1441:                         sf(s_etat_processus, 48);
 1442:                     }
 1443:                     else
 1444:                     {
 1445:                         cf(s_etat_processus, 48);
 1446:                     }
 1447: 
 1448:                     liberation(s_etat_processus, s_objet_argument_1);
 1449:                     liberation(s_etat_processus, s_objet_argument_2);
 1450: 
 1451:                     free((*s_etat_processus).instruction_courante);
 1452:                     free(commande);
 1453: 
 1454:                     (*s_etat_processus).instruction_courante = tampon;
 1455:                     return;
 1456:                 }
 1457: 
 1458:                 if (indicateur_48 == d_vrai)
 1459:                 {
 1460:                     sf(s_etat_processus, 48);
 1461:                 }
 1462:                 else
 1463:                 {
 1464:                     cf(s_etat_processus, 48);
 1465:                 }
 1466: 
 1467:                 free((*s_etat_processus).instruction_courante);
 1468:                 liberation(s_etat_processus, s_objet_argument_2);
 1469:                 (*s_etat_processus).instruction_courante = tampon;
 1470: 
 1471:                 if (sqlite3_step(ppStmt) != SQLITE_DONE)
 1472:                 {
 1473:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1474:                     return;
 1475:                 }
 1476: 
 1477:                 if (sqlite3_finalize(ppStmt) != SQLITE_OK)
 1478:                 {
 1479:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1480:                     return;
 1481:                 }
 1482: 
 1483:                 free(commande);
 1484:             }
 1485:             else
 1486:             {
 1487:                 BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
 1488: 
 1489:                 if (depilement(s_etat_processus, &((*s_etat_processus)
 1490:                         .l_base_pile), &s_objet_argument_2) == d_erreur)
 1491:                 {
 1492:                     (*s_etat_processus).erreur_execution = d_ex_manque_argument;
 1493:                     return;
 1494:                 }
 1495: 
 1496:                 if ((*s_objet_argument_2).type != CHN)
 1497:                 {
 1498:                     liberation(s_etat_processus, s_objet_argument_1);
 1499:                     liberation(s_etat_processus, s_objet_argument_2);
 1500: 
 1501:                     (*s_etat_processus).erreur_execution =
 1502:                             d_ex_erreur_type_argument;
 1503:                     return;
 1504:                 }
 1505: 
 1506:                 // Récupération de la position de la clef
 1507: 
 1508:                 if (alsprintf(s_etat_processus, &commande,
 1509:                         "select key from control where id = 1") < 0)
 1510:                 {
 1511:                     (*s_etat_processus).erreur_systeme =
 1512:                             d_es_allocation_memoire;
 1513:                     return;
 1514:                 }
 1515: 
 1516:                 if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
 1517:                         commande, (int) strlen(commande), &ppStmt, &queue)
 1518:                         != SQLITE_OK)
 1519:                 {
 1520:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1521:                     return;
 1522:                 }
 1523: 
 1524:                 attente.tv_sec = 0;
 1525:                 attente.tv_nsec = GRANULARITE_us * 1000;
 1526: 
 1527:                 do
 1528:                 {
 1529:                     ios = sqlite3_step(ppStmt);
 1530: 
 1531:                     if (ios == SQLITE_ROW)
 1532:                     {
 1533:                         break;
 1534:                     }
 1535:                     else if ((ios == SQLITE_BUSY) || (ios == SQLITE_LOCKED))
 1536:                     {
 1537:                         nanosleep(&attente, NULL);
 1538:                         INCR_GRANULARITE(attente.tv_nsec);
 1539:                     }
 1540:                     else
 1541:                     {
 1542:                         (*s_etat_processus).erreur_systeme =
 1543:                                 d_es_erreur_fichier;
 1544:                         return;
 1545:                     }
 1546:                 } while(ios != SQLITE_ROW);
 1547: 
 1548:                 if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
 1549:                 {
 1550:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1551:                     return;
 1552:                 }
 1553: 
 1554:                 position_clef = sqlite3_column_int64(ppStmt, 0);
 1555: 
 1556:                 if (sqlite3_step(ppStmt) != SQLITE_DONE)
 1557:                 {
 1558:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1559:                     return;
 1560:                 }
 1561: 
 1562:                 if (sqlite3_finalize(ppStmt) != SQLITE_OK)
 1563:                 {
 1564:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1565:                     return;
 1566:                 }
 1567: 
 1568:                 free(commande);
 1569: 
 1570:                 if ((clef_utf8 = transliteration(s_etat_processus,
 1571:                         (unsigned char *) (*s_objet_argument_2).objet,
 1572:                         d_locale, "UTF-8")) == NULL)
 1573:                 {
 1574:                     liberation(s_etat_processus, s_objet_argument_1);
 1575:                     liberation(s_etat_processus, s_objet_argument_2);
 1576: 
 1577:                     return;
 1578:                 }
 1579: 
 1580:                 // Récupération de l'identifiant de la clef
 1581: 
 1582:                 if (alsprintf(s_etat_processus, &commande,
 1583:                         "select id from key where key = '{ \"%s\" }'",
 1584:                         clef_utf8) < 0)
 1585:                 {
 1586:                     (*s_etat_processus).erreur_systeme =
 1587:                             d_es_allocation_memoire;
 1588:                     return;
 1589:                 }
 1590: 
 1591:                 if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
 1592:                         commande, (int) strlen(commande), &ppStmt, &queue)
 1593:                         != SQLITE_OK)
 1594:                 {
 1595:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1596:                     return;
 1597:                 }
 1598: 
 1599:                 attente.tv_sec = 0;
 1600:                 attente.tv_nsec = GRANULARITE_us * 1000;
 1601: 
 1602:                 do
 1603:                 {
 1604:                     ios = sqlite3_step(ppStmt);
 1605: 
 1606:                     switch(ios)
 1607:                     {
 1608:                         case SQLITE_ROW:
 1609:                         {
 1610:                             // Résultat attendu : une clef correspond.
 1611:                             break;
 1612:                         }
 1613: 
 1614:                         case SQLITE_DONE:
 1615:                         {
 1616:                             // Aucun enregistrement
 1617:                             if (sqlite3_finalize(ppStmt) != SQLITE_OK)
 1618:                             {
 1619:                                 (*s_etat_processus).erreur_systeme =
 1620:                                         d_es_erreur_fichier;
 1621:                                 return;
 1622:                             }
 1623: 
 1624:                             free(clef_utf8);
 1625:                             free(commande);
 1626: 
 1627:                             liberation(s_etat_processus, s_objet_argument_1);
 1628:                             liberation(s_etat_processus, s_objet_argument_2);
 1629: 
 1630:                             (*s_etat_processus).erreur_execution =
 1631:                                     d_ex_enregistrement_inexistant;
 1632:                             return;
 1633:                         }
 1634: 
 1635:                         case SQLITE_BUSY:
 1636:                         case SQLITE_LOCKED:
 1637:                         {
 1638:                             nanosleep(&attente, NULL);
 1639:                             INCR_GRANULARITE(attente.tv_nsec);
 1640:                             break;
 1641:                         }
 1642: 
 1643:                         default:
 1644:                         {
 1645:                             (*s_etat_processus).erreur_systeme =
 1646:                                     d_es_erreur_fichier;
 1647:                             return;
 1648:                         }
 1649:                     }
 1650:                 } while(ios != SQLITE_ROW);
 1651: 
 1652:                 if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
 1653:                 {
 1654:                     free(clef_utf8);
 1655:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1656:                     return;
 1657:                 }
 1658: 
 1659:                 id = sqlite3_column_int64(ppStmt, 0);
 1660: 
 1661:                 if (sqlite3_step(ppStmt) != SQLITE_DONE)
 1662:                 {
 1663:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1664:                     return;
 1665:                 }
 1666: 
 1667:                 if (sqlite3_finalize(ppStmt) != SQLITE_OK)
 1668:                 {
 1669:                     (*s_etat_processus).erreur_systeme =
 1670:                             d_es_erreur_fichier;
 1671:                     return;
 1672:                 }
 1673: 
 1674:                 free(commande);
 1675: 
 1676:                 if (alsprintf(s_etat_processus, &commande,
 1677:                         "select data from data where "
 1678:                         "key_id = %lld order by sequence asc", id) < 0)
 1679:                 {
 1680:                     (*s_etat_processus).erreur_systeme =
 1681:                             d_es_allocation_memoire;
 1682:                     return;
 1683:                 }
 1684: 
 1685:                 if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
 1686:                         commande, (int) strlen(commande), &ppStmt, &queue)
 1687:                         != SQLITE_OK)
 1688:                 {
 1689:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1690:                     return;
 1691:                 }
 1692: 
 1693:                 element = 1;
 1694: 
 1695:                 attente.tv_sec = 0;
 1696:                 attente.tv_nsec = GRANULARITE_us * 1000;
 1697: 
 1698:                 do
 1699:                 {
 1700:                     switch(ios = sqlite3_step(ppStmt))
 1701:                     {
 1702:                         case SQLITE_ROW:
 1703:                         {
 1704:                             // Donnée supplémentaire
 1705: 
 1706:                             if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
 1707:                             {
 1708:                                 (*s_etat_processus).erreur_systeme =
 1709:                                         d_es_erreur_fichier;
 1710:                                 return;
 1711:                             }
 1712: 
 1713:                             tampon = (*s_etat_processus).instruction_courante;
 1714: 
 1715:                             if ((tampon_lecture = (unsigned char *)
 1716:                                     sqlite3_column_text(ppStmt, 0)) == NULL)
 1717:                             {
 1718:                                 (*s_etat_processus).erreur_systeme =
 1719:                                         d_es_erreur_fichier;
 1720:                                 return;
 1721:                             }
 1722: 
 1723:                             if (((*s_etat_processus).instruction_courante =
 1724:                                     transliteration(s_etat_processus,
 1725:                                     tampon_lecture,
 1726:                                     "UTF-8", d_locale)) == NULL)
 1727:                             {
 1728:                                 (*s_etat_processus).instruction_courante =
 1729:                                         tampon;
 1730: 
 1731:                                 liberation(s_etat_processus,
 1732:                                         s_objet_argument_1);
 1733:                                 liberation(s_etat_processus,
 1734:                                         s_objet_argument_2);
 1735: 
 1736:                                 free(commande);
 1737:                                 free(clef_utf8);
 1738:                                 return;
 1739:                             }
 1740: 
 1741:                             indicateur_48 = test_cfsf(s_etat_processus, 48);
 1742:                             cf(s_etat_processus, 48);
 1743: 
 1744:                             (*s_etat_processus).type_en_cours = NON;
 1745:                             recherche_type(s_etat_processus);
 1746: 
 1747:                             if ((*s_etat_processus).erreur_execution != d_ex)
 1748:                             {
 1749:                                 if (indicateur_48 == d_vrai)
 1750:                                 {
 1751:                                     sf(s_etat_processus, 48);
 1752:                                 }
 1753:                                 else
 1754:                                 {
 1755:                                     cf(s_etat_processus, 48);
 1756:                                 }
 1757: 
 1758:                                 liberation(s_etat_processus,
 1759:                                         s_objet_argument_1);
 1760:                                 liberation(s_etat_processus,
 1761:                                         s_objet_argument_2);
 1762: 
 1763:                                 free((*s_etat_processus).instruction_courante);
 1764:                                 free(commande);
 1765:                                 free(clef_utf8);
 1766: 
 1767:                                 (*s_etat_processus).instruction_courante =
 1768:                                         tampon;
 1769:                                 return;
 1770:                             }
 1771: 
 1772:                             if (indicateur_48 == d_vrai)
 1773:                             {
 1774:                                 sf(s_etat_processus, 48);
 1775:                             }
 1776:                             else
 1777:                             {
 1778:                                 cf(s_etat_processus, 48);
 1779:                             }
 1780: 
 1781:                             free((*s_etat_processus).instruction_courante);
 1782:                             (*s_etat_processus).instruction_courante = tampon;
 1783: 
 1784:                             element++;
 1785: 
 1786:                             // Inscription de la clef
 1787: 
 1788:                             if (element == position_clef)
 1789:                             {
 1790:                                 if (((*s_etat_processus).instruction_courante =
 1791:                                         transliteration(s_etat_processus,
 1792:                                         clef_utf8, "UTF-8", d_locale)) == NULL)
 1793:                                 {
 1794:                                     (*s_etat_processus).instruction_courante =
 1795:                                             tampon;
 1796: 
 1797:                                     liberation(s_etat_processus,
 1798:                                             s_objet_argument_1);
 1799:                                     liberation(s_etat_processus,
 1800:                                             s_objet_argument_2);
 1801: 
 1802:                                     free(commande);
 1803:                                     free(clef_utf8);
 1804:                                     return;
 1805:                                 }
 1806: 
 1807:                                 if (alsprintf(s_etat_processus, &tampon2,
 1808:                                         "{ \"%s\" }", (*s_etat_processus)
 1809:                                         .instruction_courante) < 0)
 1810:                                 {
 1811:                                     (*s_etat_processus).erreur_systeme =
 1812:                                             d_es_allocation_memoire;
 1813:                                     return;
 1814:                                 }
 1815: 
 1816:                                 free((*s_etat_processus).instruction_courante);
 1817:                                 (*s_etat_processus).instruction_courante
 1818:                                         = tampon2;
 1819: 
 1820:                                 indicateur_48 = test_cfsf(s_etat_processus, 48);
 1821:                                 cf(s_etat_processus, 48);
 1822: 
 1823:                                 (*s_etat_processus).type_en_cours = NON;
 1824:                                 recherche_type(s_etat_processus);
 1825: 
 1826:                                 if ((*s_etat_processus).erreur_execution
 1827:                                         != d_ex)
 1828:                                 {
 1829:                                     if (indicateur_48 == d_vrai)
 1830:                                     {
 1831:                                         sf(s_etat_processus, 48);
 1832:                                     }
 1833:                                     else
 1834:                                     {
 1835:                                         cf(s_etat_processus, 48);
 1836:                                     }
 1837: 
 1838:                                     liberation(s_etat_processus,
 1839:                                             s_objet_argument_1);
 1840:                                     liberation(s_etat_processus,
 1841:                                             s_objet_argument_2);
 1842: 
 1843:                                     free((*s_etat_processus)
 1844:                                             .instruction_courante);
 1845:                                     free(commande);
 1846:                                     free(clef_utf8);
 1847: 
 1848:                                     (*s_etat_processus).instruction_courante =
 1849:                                             tampon;
 1850:                                     return;
 1851:                                 }
 1852: 
 1853:                                 if (indicateur_48 == d_vrai)
 1854:                                 {
 1855:                                     sf(s_etat_processus, 48);
 1856:                                 }
 1857:                                 else
 1858:                                 {
 1859:                                     cf(s_etat_processus, 48);
 1860:                                 }
 1861: 
 1862:                                 free((*s_etat_processus).instruction_courante);
 1863:                                 (*s_etat_processus).instruction_courante =
 1864:                                         tampon;
 1865: 
 1866:                                 element++;
 1867:                             }
 1868: 
 1869:                             break;
 1870:                         }
 1871: 
 1872:                         case SQLITE_DONE:
 1873:                         {
 1874:                             // Fin de la liste
 1875:                             break;
 1876:                         }
 1877: 
 1878:                         case SQLITE_BUSY:
 1879:                         case SQLITE_LOCKED:
 1880:                         {
 1881:                             nanosleep(&attente, NULL);
 1882:                             INCR_GRANULARITE(attente.tv_nsec);
 1883:                             break;
 1884:                         }
 1885: 
 1886:                         default:
 1887:                         {
 1888:                             (*s_etat_processus).erreur_systeme =
 1889:                                     d_es_erreur_fichier;
 1890:                             return;
 1891:                         }
 1892:                     }
 1893:                 } while(ios != SQLITE_DONE);
 1894: 
 1895:                 if (sqlite3_finalize(ppStmt) != SQLITE_OK)
 1896:                 {
 1897:                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 1898:                     return;
 1899:                 }
 1900: 
 1901:                 free(commande);
 1902:                 free(clef_utf8);
 1903: 
 1904:                 liberation(s_etat_processus, s_objet_argument_2);
 1905: 
 1906:                 if ((s_objet_resultat = allocation(s_etat_processus, LST))
 1907:                         == NULL)
 1908:                 {
 1909:                     (*s_etat_processus).erreur_systeme =
 1910:                             d_es_allocation_memoire;
 1911:                     return;
 1912:                 }
 1913: 
 1914:                 l_element_courant = NULL;
 1915:                 l_element_inclus = NULL;
 1916: 
 1917:                 for(element--; element > 0; element--)
 1918:                 {
 1919:                     if (depilement(s_etat_processus, &((*s_etat_processus)
 1920:                             .l_base_pile), &s_objet_argument_2) == d_erreur)
 1921:                     {
 1922:                         (*s_etat_processus).erreur_systeme =
 1923:                                 d_es_erreur_fichier;
 1924:                         return;
 1925:                     }
 1926: 
 1927:                     if ((*s_objet_argument_2).type != LST)
 1928:                     {
 1929:                         (*s_etat_processus).erreur_systeme =
 1930:                                 d_es_erreur_fichier;
 1931:                         return;
 1932:                     }
 1933: 
 1934:                     l_element_inclus = (*s_objet_argument_2).objet;
 1935: 
 1936:                     if (l_element_inclus != NULL)
 1937:                     {
 1938:                         while(l_element_inclus != NULL)
 1939:                         {
 1940:                             if ((*l_element_inclus).suivant == NULL)
 1941:                             {
 1942:                                 (*l_element_inclus).suivant = l_element_courant;
 1943:                                 break;
 1944:                             }
 1945: 
 1946:                             l_element_inclus = (*l_element_inclus).suivant;
 1947:                         }
 1948: 
 1949:                         l_element_courant = (*s_objet_argument_2).objet;
 1950:                         (*s_objet_argument_2).objet = NULL;
 1951:                     }
 1952: 
 1953:                     liberation(s_etat_processus, s_objet_argument_2);
 1954:                 }
 1955: 
 1956:                 (*s_objet_resultat).objet = l_element_inclus;
 1957: 
 1958:                 if (empilement(s_etat_processus,
 1959:                         &((*s_etat_processus).l_base_pile),
 1960:                         s_objet_resultat) == d_erreur)
 1961:                 {
 1962:                     return;
 1963:                 }
 1964:             }
 1965:         }
 1966:         else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
 1967:                 == 'Y')
 1968:         {
 1969:             /*
 1970:              * Fichiers non formatés
 1971:              */
 1972: 
 1973:             if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
 1974:                     == 'S')
 1975:             {
 1976:                 /*
 1977:                  * Fichiers séquentiels
 1978:                  *
 1979:                  * Les fichiers séquentiels non formatés contiennent comme
 1980:                  * les fichiers séquentiels formatés leurs enregistrements
 1981:                  * sous la forme de listes les unes derrières les autres.
 1982:                  *
 1983:                  * Le quartet de poids fort du premier octet à lire
 1984:                  * doit donc être égal à 0100. Si ce n'est pas le cas,
 1985:                  * il sera impossible de lire le fichier et on renvoie
 1986:                  * immédiatement une erreur. Si on lit dans le fichier
 1987:                  * la valeur attendue, on récupère la longueur en octet
 1988:                  * de l'enregistrement puis on le lit.
 1989:                  */
 1990: 
 1991:                 BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
 1992: 
 1993:                 if ((s_objet_resultat = lecture_fichier_non_formate(
 1994:                         s_etat_processus, (*descripteur).descripteur_c, -1,
 1995:                         d_faux)) == NULL)
 1996:                 {
 1997:                     return;
 1998:                 }
 1999: 
 2000:                 if (empilement(s_etat_processus,
 2001:                         &((*s_etat_processus).l_base_pile),
 2002:                         s_objet_resultat) == d_erreur)
 2003:                 {
 2004:                     return;
 2005:                 }
 2006:             }
 2007:         }
 2008:         else
 2009:         {
 2010:             /*
 2011:              * Fichiers de type FLOW
 2012:              */
 2013: 
 2014:             if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
 2015:                     == 'S')
 2016:             {
 2017:                 /*
 2018:                  * Fichiers séquentiels
 2019:                  */
 2020: 
 2021:                 BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
 2022:                 longueur_enregistrement = 0;
 2023: 
 2024:                 device = d_faux;
 2025: 
 2026:                 if ((position_initiale = ftell((*descripteur).descripteur_c))
 2027:                         == -1)
 2028:                 {
 2029:                     if (errno == ESPIPE)
 2030:                     {
 2031:                         device = d_vrai;
 2032:                     }
 2033:                     else
 2034:                     {
 2035:                         (*s_etat_processus).erreur_systeme =
 2036:                                 d_es_erreur_fichier;
 2037:                         return;
 2038:                     }
 2039:                 }
 2040: 
 2041:                 l_element_courant_format = (struct_liste_chainee *)
 2042:                         (*(*((struct_fichier *) (*s_objet_argument_1).objet))
 2043:                         .format).objet;
 2044:                 l_element_courant = NULL;
 2045: 
 2046:                 if ((s_objet_resultat = allocation(s_etat_processus, LST))
 2047:                         == NULL)
 2048:                 {
 2049:                     (*s_etat_processus).erreur_systeme =
 2050:                             d_es_allocation_memoire;
 2051:                     return;
 2052:                 }
 2053: 
 2054:                 while(l_element_courant_format != NULL)
 2055:                 {
 2056:                     if ((*(*l_element_courant_format).donnee).type != CHN)
 2057:                     {
 2058:                         liberation(s_etat_processus, s_objet_argument_1);
 2059:                         liberation(s_etat_processus, s_objet_resultat);
 2060: 
 2061:                         (*s_etat_processus).erreur_execution =
 2062:                                 d_ex_erreur_type_argument;
 2063:                         return;
 2064:                     }
 2065: 
 2066:                     if ((format_chaine = conversion_majuscule(
 2067:                             s_etat_processus, (unsigned char *)
 2068:                             (*(*l_element_courant_format).donnee).objet))
 2069:                             == NULL)
 2070:                     {
 2071:                         (*s_etat_processus).erreur_systeme =
 2072:                                 d_es_allocation_memoire;
 2073:                         return;
 2074:                     }
 2075: 
 2076:                     if (strcmp("LINE*(*)", format_chaine) == 0)
 2077:                     {
 2078:                         format_degenere = d_vrai;
 2079:                         format_oriente_ligne = d_vrai;
 2080:                     }
 2081:                     else
 2082:                     {
 2083:                         format_oriente_ligne = d_faux;
 2084: 
 2085:                         if (strncmp("LENGTH*(", format_chaine, 8) != 0)
 2086:                         {
 2087:                             liberation(s_etat_processus, s_objet_argument_1);
 2088:                             liberation(s_etat_processus, s_objet_resultat);
 2089:                             free(format_chaine);
 2090: 
 2091:                             (*s_etat_processus).erreur_execution =
 2092:                                     d_ex_erreur_format_fichier;
 2093:                             return;
 2094:                         }
 2095: 
 2096:                         longueur = (integer8) strlen(format_chaine);
 2097: 
 2098:                         if (format_chaine[longueur - 1] != ')')
 2099:                         {
 2100:                             liberation(s_etat_processus, s_objet_argument_1);
 2101:                             liberation(s_etat_processus, s_objet_resultat);
 2102:                             free(format_chaine);
 2103: 
 2104:                             (*s_etat_processus).erreur_execution =
 2105:                                     d_ex_erreur_format_fichier;
 2106:                             return;
 2107:                         }
 2108: 
 2109:                         format_chaine[longueur] = d_code_fin_chaine;
 2110: 
 2111:                         if (format_chaine[8] == '*')
 2112:                         {
 2113:                             format_degenere = d_vrai;
 2114:                         }
 2115:                         else
 2116:                         {
 2117:                             // Détermination de la longueur
 2118:                             format_degenere = d_faux;
 2119: 
 2120:                             if (sscanf(&(format_chaine[8]), "%lld", &longueur)
 2121:                                     != 1)
 2122:                             {
 2123:                                 liberation(s_etat_processus, s_objet_argument_1);
 2124:                                 liberation(s_etat_processus, s_objet_resultat);
 2125:                                 free(format_chaine);
 2126: 
 2127:                                 (*s_etat_processus).erreur_execution =
 2128:                                         d_ex_erreur_format_fichier;
 2129:                                 return;
 2130:                             }
 2131:                         }
 2132:                     }
 2133: 
 2134:                     free(format_chaine);
 2135:                     tampon3 = NULL;
 2136: 
 2137:                     if (format_degenere == d_vrai)
 2138:                     {
 2139:                         if (device == d_vrai)
 2140:                         {
 2141:                             longueur_questure = 4096;
 2142:                             index = 0;
 2143: 
 2144:                             if ((tampon3 = malloc(((size_t) longueur_questure) *
 2145:                                     sizeof(unsigned char))) == NULL)
 2146:                             {
 2147:                                 (*s_etat_processus).erreur_systeme =
 2148:                                         d_es_allocation_memoire;
 2149:                                 return;
 2150:                             }
 2151: 
 2152:                             tampon3[index] = d_code_fin_chaine;
 2153: 
 2154:                             fds[0].fd = fileno((*descripteur).descripteur_c);
 2155:                             fds[0].events = POLLIN;
 2156:                             fds[0].revents = 0;
 2157: 
 2158:                             tcgetattr(fileno((*descripteur).descripteur_c),
 2159:                                     &tc);
 2160:                             timeout = 0;
 2161: 
 2162:                             for(i = 0; vitesses[i] != 0; i++)
 2163:                             {
 2164:                                 if (cfgetispeed(&tc) == vitesses_constantes[i])
 2165:                                 {
 2166:                                     // La durée entre deux caractères sur le
 2167:                                     // périphérique série ne doit pas dépasser
 2168:                                     // la moitié de la durée de transmission
 2169:                                     // d'un caractère complet.
 2170: 
 2171:                                     timeout = (int) (((double) 1000) /
 2172:                                             (((double) vitesses_constantes[i]) /
 2173:                                             4));
 2174:                                     break;
 2175:                                 }
 2176:                             }
 2177:                         }
 2178:                         else
 2179:                         {
 2180:                             // Évite un warning de gcc.
 2181:                             longueur_questure = 0;
 2182:                             index = 0;
 2183:                             timeout = 0;
 2184:                         }
 2185: 
 2186:                         do
 2187:                         {
 2188:                             if (device == d_vrai)
 2189:                             {
 2190:                                 if (poll(fds, 1, timeout) == 0)
 2191:                                 {
 2192:                                     break;
 2193:                                 }
 2194:                             }
 2195: 
 2196:                             c = getc((*descripteur).descripteur_c);
 2197:                             longueur_enregistrement++;
 2198: 
 2199:                             if (device == d_vrai)
 2200:                             {
 2201:                                 if (longueur_enregistrement >=
 2202:                                         longueur_questure)
 2203:                                 {
 2204:                                     if ((tampon3 = realloc(tampon3,
 2205:                                             (size_t) (longueur_questure *= 2)))
 2206:                                             == NULL)
 2207:                                     {
 2208:                                         (*s_etat_processus).erreur_systeme =
 2209:                                                 d_es_allocation_memoire;
 2210:                                         return;
 2211:                                     }
 2212:                                 }
 2213: 
 2214:                                 tampon3[index++] = (unsigned char) c;
 2215:                             }
 2216: 
 2217:                             if (format_oriente_ligne == d_vrai)
 2218:                             {
 2219:                                 if (c == '\n')
 2220:                                 {
 2221:                                     break;
 2222:                                 }
 2223:                             }
 2224:                         } while(c != EOF);
 2225: 
 2226:                         if (device == d_faux)
 2227:                         {
 2228:                             if (fseek((*descripteur).descripteur_c,
 2229:                                     (long) position_initiale, SEEK_SET) != 0)
 2230:                             {
 2231:                                 liberation(s_etat_processus,
 2232:                                         s_objet_argument_1);
 2233:                                 liberation(s_etat_processus, s_objet_resultat);
 2234: 
 2235:                                 (*s_etat_processus).erreur_systeme =
 2236:                                         d_es_erreur_fichier;
 2237:                                 return;
 2238:                             }
 2239:                         }
 2240:                     }
 2241:                     else
 2242:                     {
 2243:                         longueur_enregistrement = longueur;
 2244:                     }
 2245: 
 2246:                     if ((device == d_vrai) && (format_degenere == d_vrai))
 2247:                     {
 2248:                         longueur_effective = longueur_enregistrement;
 2249:                         tampon_lecture = tampon3;
 2250:                     }
 2251:                     else
 2252:                     {
 2253:                         if ((tampon_lecture = malloc(((size_t)
 2254:                                 longueur_enregistrement) *
 2255:                                 sizeof(unsigned char))) == NULL)
 2256:                         {
 2257:                             (*s_etat_processus).erreur_systeme =
 2258:                                     d_es_allocation_memoire;
 2259:                             return;
 2260:                         }
 2261: 
 2262:                         longueur_effective = (integer8) fread(tampon_lecture,
 2263:                                 sizeof(unsigned char),
 2264:                                 (size_t) longueur_enregistrement,
 2265:                                 (*descripteur).descripteur_c);
 2266:                     }
 2267: 
 2268:                     if (l_element_courant == NULL)
 2269:                     {
 2270:                         // Premier maillon de la liste
 2271:                         if (((*s_objet_resultat).objet =
 2272:                                 allocation_maillon(s_etat_processus)) == NULL)
 2273:                         {
 2274:                             (*s_etat_processus).erreur_systeme =
 2275:                                     d_es_allocation_memoire;
 2276:                             return;
 2277:                         }
 2278: 
 2279:                         l_element_courant = (*s_objet_resultat).objet;
 2280:                     }
 2281:                     else
 2282:                     {
 2283:                         if (((*l_element_courant).suivant =
 2284:                                 allocation_maillon(s_etat_processus)) == NULL)
 2285:                         {
 2286:                             (*s_etat_processus).erreur_systeme =
 2287:                                     d_es_allocation_memoire;
 2288:                             return;
 2289:                         }
 2290: 
 2291:                         l_element_courant = (*l_element_courant).suivant;
 2292:                     }
 2293: 
 2294:                     (*l_element_courant).suivant = NULL;
 2295: 
 2296:                     if (((*l_element_courant).donnee =
 2297:                             allocation(s_etat_processus, CHN)) == NULL)
 2298:                     {
 2299:                         (*s_etat_processus).erreur_systeme =
 2300:                                 d_es_allocation_memoire;
 2301:                         return;
 2302:                     }
 2303: 
 2304:                     if (format_degenere == d_vrai)
 2305:                     {
 2306:                         if (device == d_faux)
 2307:                         {
 2308:                             if (((*(*l_element_courant).donnee).objet =
 2309:                                 analyse_flux(s_etat_processus, tampon_lecture,
 2310:                                 longueur_enregistrement - 1)) == NULL)
 2311:                             {
 2312:                                 return;
 2313:                             }
 2314:                         }
 2315:                         else
 2316:                         {
 2317:                             if (((*(*l_element_courant).donnee).objet =
 2318:                                 analyse_flux(s_etat_processus, tampon_lecture,
 2319:                                 longueur_enregistrement)) == NULL)
 2320:                             {
 2321:                                 return;
 2322:                             }
 2323:                         }
 2324:                     }
 2325:                     else
 2326:                     {
 2327:                         if (((*(*l_element_courant).donnee).objet =
 2328:                             analyse_flux(s_etat_processus, tampon_lecture,
 2329:                             longueur_enregistrement)) == NULL)
 2330:                         {
 2331:                             return;
 2332:                         }
 2333:                     }
 2334: 
 2335:                     free(tampon_lecture);
 2336: 
 2337:                     l_element_courant_format =
 2338:                             (*l_element_courant_format).suivant;
 2339:                 }
 2340: 
 2341:                 if (empilement(s_etat_processus,
 2342:                         &((*s_etat_processus).l_base_pile),
 2343:                         s_objet_resultat) == d_erreur)
 2344:                 {
 2345:                     return;
 2346:                 }
 2347:             }
 2348:             else
 2349:             {
 2350:                 liberation(s_etat_processus, s_objet_argument_1);
 2351: 
 2352:                 (*s_etat_processus).erreur_execution =
 2353:                         d_ex_erreur_type_fichier;
 2354:                 return;
 2355:             }
 2356:         }
 2357:     }
 2358:     else if ((*s_objet_argument_1).type == SCK) 
 2359:     {
 2360:         /*
 2361:          * Vérification de l'autorisation de lecture
 2362:          */
 2363: 
 2364:         if ((*((struct_socket *) (*s_objet_argument_1).objet)).protection
 2365:                 == 'W')
 2366:         {
 2367:             liberation(s_etat_processus, s_objet_argument_1);
 2368: 
 2369:             (*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
 2370:             return;
 2371:         }
 2372: 
 2373:         /*
 2374:          * Vérification de l'écoute de la socket si celle-ci est connectée
 2375:          */
 2376: 
 2377:         if ((strcmp((*((struct_socket *) (*s_objet_argument_1).objet)).type,
 2378:                 "STREAM") == 0) || (strcmp((*((struct_socket *)
 2379:                 (*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
 2380:                 == 0))
 2381:         {
 2382:             if ((*((struct_socket *) (*s_objet_argument_1).objet))
 2383:                     .socket_en_ecoute == 'Y') 
 2384:             {
 2385:                 liberation(s_etat_processus, s_objet_argument_1);
 2386: 
 2387:                 (*s_etat_processus).erreur_execution = d_ex_socket_en_ecoute;
 2388:                 return;
 2389:             }
 2390:         }
 2391: 
 2392:         if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
 2393:         { // Socket formatée
 2394:             longueur_questure = 4096;
 2395:             longueur_effective = 0;
 2396:             tampon_lecture = NULL;
 2397: 
 2398:             attente.tv_sec = 0;
 2399:             attente.tv_nsec = GRANULARITE_us * 1000;
 2400: 
 2401:             trame_complete = d_faux;
 2402:             position_initiale = 0;
 2403:             position_finale = 0;
 2404: 
 2405:             do
 2406:             {
 2407:                 presence_indicateur = d_faux;
 2408: 
 2409:                 if ((tampon_lecture = realloc(tampon_lecture,
 2410:                         ((size_t) (longueur_effective + longueur_questure + 1))
 2411:                         * sizeof(unsigned char))) == NULL)
 2412:                 {
 2413:                     (*s_etat_processus).erreur_systeme =
 2414:                             d_es_allocation_memoire;
 2415:                     return;
 2416:                 }
 2417: 
 2418: #               ifndef SEMAPHORES_NOMMES
 2419:                     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 2420: #               else
 2421:                     if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 2422: #               endif
 2423:                 {
 2424:                     (*s_etat_processus).erreur_systeme = d_es_processus;
 2425:                     return;
 2426:                 }
 2427: 
 2428:                 if ((*((struct_socket *) (*s_objet_argument_1).objet))
 2429:                         .domaine == PF_UNIX)
 2430:                 {
 2431:                     longueur_adresse = sizeof(adresse_unix);
 2432: 
 2433:                     do
 2434:                     {
 2435:                         ios = (int) recvfrom((*((struct_socket *)
 2436:                                 (*s_objet_argument_1).objet)).socket,
 2437:                                 tampon_lecture, (size_t) (longueur_effective +
 2438:                                 longueur_questure),
 2439:                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
 2440:                                 &adresse_unix, &longueur_adresse);
 2441:                     } while((ios == -1) && (errno == EINTR));
 2442:                 }
 2443:                 else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 2444:                         .domaine == PF_INET)
 2445:                 {
 2446:                     longueur_adresse = sizeof(adresse_ipv4);
 2447: 
 2448:                     do
 2449:                     {
 2450:                         ios = (int) recvfrom((*((struct_socket *)
 2451:                                 (*s_objet_argument_1).objet)).socket,
 2452:                                 tampon_lecture, (size_t) (longueur_effective +
 2453:                                 longueur_questure),
 2454:                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
 2455:                                 &adresse_ipv4, &longueur_adresse);
 2456:                     } while((ios == -1) && (errno == EINTR));
 2457:                 }
 2458:                 else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 2459:                         .domaine == PF_INET6)
 2460:                 {
 2461: #                   ifdef IPV6
 2462:                     longueur_adresse = sizeof(adresse_ipv6);
 2463:                     
 2464:                     do
 2465:                     {
 2466:                         ios = (int) recvfrom((*((struct_socket *)
 2467:                                 (*s_objet_argument_1).objet)).socket,
 2468:                                 tampon_lecture, (size_t) (longueur_effective +
 2469:                                 longueur_questure),
 2470:                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
 2471:                                 &adresse_ipv6, &longueur_adresse);
 2472:                     } while((ios == -1) && (errno == EINTR));
 2473: #                   else
 2474:                     if ((*s_etat_processus).langue == 'F')
 2475:                     {
 2476:                         printf("+++Attention : Support du protocole"
 2477:                                 " IPv6 indisponible\n");
 2478:                     }
 2479:                     else
 2480:                     {
 2481:                         printf("+++Warning : IPv6 support "
 2482:                                 "unavailable\n");
 2483:                     }
 2484: 
 2485:                     longueur_adresse = 0;
 2486:                     longueur_effective = 0;
 2487:                     ios = 0;
 2488: #                   endif
 2489:                 }
 2490:                 else
 2491:                 {
 2492:                     free(tampon_lecture);
 2493:                     liberation(s_etat_processus, s_objet_argument_1);
 2494: 
 2495: #                   ifndef SEMAPHORES_NOMMES
 2496:                         while(sem_wait(&((*s_etat_processus)
 2497:                                 .semaphore_fork)) != 0)
 2498: #                   else
 2499:                         while(sem_wait((*s_etat_processus)
 2500:                                 .semaphore_fork) != 0)
 2501: #                   endif
 2502:                     {
 2503:                         (*s_etat_processus).erreur_systeme =
 2504:                                 d_es_processus;
 2505:                     }
 2506: 
 2507:                     (*s_etat_processus).erreur_execution =
 2508:                             d_ex_erreur_acces_fichier;
 2509:                     return;
 2510:                 }
 2511: 
 2512:                 if (ios <= 0)
 2513:                 {
 2514:                     nanosleep(&attente, NULL);
 2515:                     INCR_GRANULARITE(attente.tv_nsec);
 2516:                 }
 2517:                 else
 2518:                 {
 2519:                     attente.tv_sec = 0;
 2520:                     attente.tv_nsec = GRANULARITE_us * 1000;
 2521:                 }
 2522: 
 2523:                 scrutation_injection(s_etat_processus);
 2524: 
 2525:                 if ((*s_etat_processus).var_volatile_requete_arret == -1)
 2526:                 {
 2527:                     if (ios >= 0)
 2528:                     {
 2529:                         longueur_effective = ios;
 2530:                     }
 2531: 
 2532:                     break;
 2533:                 }
 2534: 
 2535:                 // Une donnée a été reçue.
 2536: 
 2537:                 if (ios >= 0)
 2538:                 {
 2539:                     longueur_effective = ios;
 2540:                     position_initiale = 0;
 2541:                     presence_indicateur = d_faux;
 2542: 
 2543:                     do
 2544:                     {
 2545:                         if (tampon_lecture[position_initiale] == '{')
 2546:                         {
 2547:                             presence_indicateur = d_vrai;
 2548:                             break;
 2549:                         }
 2550: 
 2551:                         position_initiale++;
 2552:                     } while(position_initiale < longueur_effective);
 2553: 
 2554:                     if (presence_indicateur == d_vrai)
 2555:                     {
 2556:                         position_finale = position_initiale + 1;
 2557:                         presence_chaine = d_faux;
 2558:                         presence_indicateur = d_faux;
 2559:                         niveau = 1;
 2560: 
 2561:                         while(position_finale < longueur_effective)
 2562:                         {
 2563:                             caractere = tampon_lecture[position_finale];
 2564: 
 2565:                             if (caractere == '"')
 2566:                             {
 2567:                                 if (position_finale > 0)
 2568:                                 {
 2569:                                     if (tampon_lecture[position_finale - 1]
 2570:                                             != '\\')
 2571:                                     {
 2572:                                         presence_chaine = (presence_chaine ==
 2573:                                                 d_vrai) ? d_faux : d_vrai;
 2574:                                     }
 2575:                                 }
 2576:                                 else
 2577:                                 {
 2578:                                     presence_chaine =
 2579:                                             (presence_chaine == d_vrai)
 2580:                                             ? d_faux : d_vrai;
 2581:                                 }
 2582:                             }
 2583:                             else
 2584:                             {
 2585:                                 if (presence_chaine == d_faux)
 2586:                                 {
 2587:                                     if (caractere == '{')
 2588:                                     {
 2589:                                         niveau++;
 2590:                                     }
 2591:                                     else if (caractere == '}')
 2592:                                     {
 2593:                                         niveau--;
 2594:                                     }
 2595:                                 }
 2596:                             }
 2597: 
 2598:                             if (niveau == 0)
 2599:                             {
 2600:                                 presence_indicateur = d_vrai;
 2601:                                 trame_complete = d_vrai;
 2602:                                 break;
 2603:                             }
 2604: 
 2605:                             position_finale++;
 2606:                         }
 2607:                     }
 2608: 
 2609:                     // On retire une trame du buffer.
 2610: 
 2611:                     if (trame_complete == d_vrai)
 2612:                     {
 2613:                         if ((*((struct_socket *) (*s_objet_argument_1).objet))
 2614:                                 .domaine == PF_UNIX)
 2615:                         {
 2616:                             do
 2617:                             {
 2618:                                 longueur_adresse = sizeof(adresse_unix);
 2619:                                 recvfrom((*((struct_socket *)
 2620:                                         (*s_objet_argument_1).objet)).socket,
 2621:                                         tampon_lecture,
 2622:                                         (size_t) longueur_effective,
 2623:                                         0, (struct sockaddr *)
 2624:                                         &adresse_unix, &longueur_adresse);
 2625:                             } while((ios == -1) && (errno == EINTR));
 2626:                         }
 2627:                         else if ((*((struct_socket *) (*s_objet_argument_1)
 2628:                                 .objet)).domaine == PF_INET)
 2629:                         {
 2630:                             do
 2631:                             {
 2632:                                 longueur_adresse = sizeof(adresse_ipv4);
 2633:                                 recvfrom((*((struct_socket *)
 2634:                                         (*s_objet_argument_1).objet)).socket,
 2635:                                         tampon_lecture,
 2636:                                         (size_t) longueur_effective,
 2637:                                         0, (struct sockaddr *)
 2638:                                         &adresse_ipv4, &longueur_adresse);
 2639:                             } while((ios == -1) && (errno == EINTR));
 2640:                         }
 2641:                         else if ((*((struct_socket *) (*s_objet_argument_1)
 2642:                                 .objet)) .domaine == PF_INET6)
 2643:                         {
 2644: #                           ifdef IPV6
 2645:                             do
 2646:                             {
 2647:                                 longueur_adresse = sizeof(adresse_ipv6);
 2648:                                 recvfrom((*((struct_socket *)
 2649:                                         (*s_objet_argument_1).objet)).socket,
 2650:                                         tampon_lecture,
 2651:                                         (size_t) longueur_effective,
 2652:                                         0, (struct sockaddr *)
 2653:                                         &adresse_ipv6, &longueur_adresse);
 2654:                             } while((ios == -1) && (errno == EINTR));
 2655: #                           else
 2656:                             if ((*s_etat_processus).langue == 'F')
 2657:                             {
 2658:                                 printf("+++Attention : Support du protocole"
 2659:                                         " IPv6 indisponible\n");
 2660:                             }
 2661:                             else
 2662:                             {
 2663:                                 printf("+++Warning : IPv6 support "
 2664:                                         "unavailable\n");
 2665:                             }
 2666: 
 2667: #                           endif
 2668:                         }
 2669: 
 2670:                         longueur_effective = ios;
 2671:                     }
 2672:                     else
 2673:                     {
 2674:                         // Si on a lu toute une trame et qu'on n'a pas
 2675:                         // réussi à en trouver la structure, on remonte
 2676:                         // une erreur de syntaxe.
 2677: 
 2678:                         if (longueur_effective == ios)
 2679:                         {
 2680:                             if ((*((struct_socket *) (*s_objet_argument_1)
 2681:                                     .objet)).domaine == PF_UNIX)
 2682:                             {
 2683:                                 do
 2684:                                 {
 2685:                                     longueur_adresse = sizeof(adresse_unix);
 2686:                                     recvfrom((*((struct_socket *)
 2687:                                             (*s_objet_argument_1).objet))
 2688:                                             .socket, tampon_lecture,
 2689:                                             (size_t) longueur_effective,
 2690:                                             0, (struct sockaddr *)
 2691:                                             &adresse_unix, &longueur_adresse);
 2692:                                 } while((ios == -1) && (errno == EINTR));
 2693:                             }
 2694:                             else if ((*((struct_socket *) (*s_objet_argument_1)
 2695:                                     .objet)).domaine == PF_INET)
 2696:                             {
 2697:                                 do
 2698:                                 {
 2699:                                     longueur_adresse = sizeof(adresse_ipv4);
 2700:                                     recvfrom((*((struct_socket *)
 2701:                                             (*s_objet_argument_1).objet))
 2702:                                             .socket, tampon_lecture,
 2703:                                             (size_t) longueur_effective,
 2704:                                             0, (struct sockaddr *)
 2705:                                             &adresse_ipv4, &longueur_adresse);
 2706:                                 } while((ios == -1) && (errno == EINTR));
 2707:                             }
 2708:                             else if ((*((struct_socket *) (*s_objet_argument_1)
 2709:                                     .objet)) .domaine == PF_INET6)
 2710:                             {
 2711: #                               ifdef IPV6
 2712:                                 do
 2713:                                 {
 2714:                                     longueur_adresse = sizeof(adresse_ipv6);
 2715:                                     recvfrom((*((struct_socket *)
 2716:                                             (*s_objet_argument_1).objet))
 2717:                                             .socket, tampon_lecture,
 2718:                                             (size_t) longueur_effective,
 2719:                                             0, (struct sockaddr *)
 2720:                                             &adresse_ipv6, &longueur_adresse);
 2721:                                 } while((ios == -1) && (errno == EINTR));
 2722: #                               else
 2723:                                 if ((*s_etat_processus).langue == 'F')
 2724:                                 {
 2725:                                     printf("+++Attention : Support du protocole"
 2726:                                             " IPv6 indisponible\n");
 2727:                                 }
 2728:                                 else
 2729:                                 {
 2730:                                     printf("+++Warning : IPv6 support "
 2731:                                             "unavailable\n");
 2732:                                 }
 2733: 
 2734: #                               endif
 2735:                             }
 2736: 
 2737:                             liberation(s_etat_processus, s_objet_argument_1);
 2738:                             free(tampon_lecture);
 2739: 
 2740:                             (*s_etat_processus).erreur_execution = d_ex_syntaxe;
 2741:                             return;
 2742:                         }
 2743:                     }
 2744:                 }
 2745: 
 2746: #               ifndef SEMAPHORES_NOMMES
 2747:                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 2748: #               else
 2749:                     while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 2750: #               endif
 2751:                 {
 2752:                     if (errno == EINTR)
 2753:                     {
 2754:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 2755:                         return;
 2756:                     }
 2757:                 }
 2758: 
 2759:                 if ((*s_etat_processus).var_volatile_requete_arret == -1)
 2760:                 {
 2761: 
 2762:                     /*
 2763:                      * Si le père tue le processus courant grâce au signal
 2764:                      * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
 2765:                      * correspond à l'utilisation de STOP sur le processus
 2766:                      * en cours. La variable longueur_effective vaut '-1'.
 2767:                      */
 2768: 
 2769:                     free(tampon_lecture);
 2770:                     liberation(s_etat_processus, s_objet_argument_1);
 2771:                     return;
 2772:                 }
 2773: 
 2774:                 if (longueur_effective == -1)
 2775:                 {
 2776:                     free(tampon_lecture);
 2777:                     liberation(s_etat_processus, s_objet_argument_1);
 2778: 
 2779:                     (*s_etat_processus).erreur_execution =
 2780:                             d_ex_erreur_acces_fichier;
 2781:                     return;
 2782:                 }
 2783:             } while(trame_complete == d_faux);
 2784: 
 2785:             tampon_lecture[++position_finale] = d_code_fin_chaine;
 2786:             tampon = (*s_etat_processus).instruction_courante;
 2787:             (*s_etat_processus).instruction_courante = tampon_lecture;
 2788: 
 2789:             indicateur_48 = test_cfsf(s_etat_processus, 48);
 2790:             cf(s_etat_processus, 48);
 2791: 
 2792:             (*s_etat_processus).type_en_cours = NON;
 2793:             recherche_type(s_etat_processus);
 2794: 
 2795:             if ((*s_etat_processus).erreur_execution != d_ex)
 2796:             {
 2797:                 (*s_etat_processus).instruction_courante = tampon;
 2798:                 free(tampon_lecture);
 2799:                 
 2800:                 if (indicateur_48 == d_vrai)
 2801:                 {
 2802:                     sf(s_etat_processus, 48);
 2803:                 }
 2804:                 else
 2805:                 {
 2806:                     cf(s_etat_processus, 48);
 2807:                 }
 2808: 
 2809:                 if ((*s_etat_processus).var_volatile_requete_arret == -1)
 2810:                 {
 2811:                     (*s_etat_processus).erreur_execution = d_ex;
 2812:                 }
 2813: 
 2814:                 liberation(s_etat_processus, s_objet_argument_1);
 2815:                 return;
 2816:             }
 2817: 
 2818:             if (indicateur_48 == d_vrai)
 2819:             {
 2820:                 sf(s_etat_processus, 48);
 2821:             }
 2822:             else
 2823:             {
 2824:                 cf(s_etat_processus, 48);
 2825:             }
 2826: 
 2827:             (*s_etat_processus).instruction_courante = tampon;
 2828: 
 2829:             /*
 2830:              * Création de la liste de sortie
 2831:              */
 2832: 
 2833:             if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 2834:                     &s_objet_type) == d_erreur)
 2835:             {
 2836:                 (*s_etat_processus).erreur_execution = d_ex_manque_argument;
 2837:                 return;
 2838:             }
 2839: 
 2840:             if ((s_objet_resultat = allocation(s_etat_processus, LST))
 2841:                     == NULL)
 2842:             {
 2843:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 2844:                 return;
 2845:             }
 2846: 
 2847:             if (((*s_objet_resultat).objet =
 2848:                     allocation_maillon(s_etat_processus)) == NULL)
 2849:             {
 2850:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 2851:                 return;
 2852:             }
 2853: 
 2854:             (*((struct_liste_chainee *) (*s_objet_resultat).objet))
 2855:                     .donnee = s_objet_type;
 2856: 
 2857:             if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
 2858:                     .suivant = allocation_maillon(s_etat_processus)) == NULL)
 2859:             {
 2860:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 2861:                 return;
 2862:             }
 2863: 
 2864:             (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
 2865:                     .suivant = NULL;
 2866: 
 2867:             if ((s_objet_adresse = allocation(s_etat_processus, LST))
 2868:                     == NULL)
 2869:             {
 2870:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 2871:                 return;
 2872:             }
 2873: 
 2874:             (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
 2875:                     .donnee = s_objet_adresse;
 2876: 
 2877:             /*
 2878:              * Les informations concernant la cible sont valides si
 2879:              * la socket est non connectée et des domaines INET ou INET6.
 2880:              * Dans tous les autres cas, on renvoie une liste vide.
 2881:              */
 2882: 
 2883:             if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
 2884:                     == PF_UNIX) || (strcmp((*((struct_socket *)
 2885:                     (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
 2886:                     (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
 2887:                     .type, "SEQUENTIAL DATAGRAM") == 0))
 2888:             {
 2889:                 (*s_objet_adresse).objet = NULL;
 2890:             }
 2891:             else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 2892:                     .domaine == PF_INET)
 2893:             {
 2894:                 if (((*s_objet_adresse).objet =
 2895:                         allocation_maillon(s_etat_processus)) == NULL)
 2896:                 {
 2897:                     (*s_etat_processus).erreur_systeme =
 2898:                             d_es_allocation_memoire;
 2899:                     return;
 2900:                 }
 2901: 
 2902:                 if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
 2903:                         .donnee = allocation(s_etat_processus, VIN)) == NULL)
 2904:                 {
 2905:                     (*s_etat_processus).erreur_systeme =
 2906:                             d_es_allocation_memoire;
 2907:                     return;
 2908:                 }
 2909: 
 2910:                 (*((struct_vecteur *) (*(*((struct_liste_chainee *)
 2911:                         (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
 2912: 
 2913:                 if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
 2914:                         (*s_objet_adresse).objet)).donnee).objet)).tableau =
 2915:                         malloc(4 * sizeof(integer8))) == NULL)
 2916:                 {
 2917:                     (*s_etat_processus).erreur_systeme =
 2918:                             d_es_allocation_memoire;
 2919:                     return;
 2920:                 }
 2921: 
 2922:                 ((integer8 *) (*((struct_vecteur *)
 2923:                         (*(*((struct_liste_chainee *) (*s_objet_adresse)
 2924:                         .objet)).donnee).objet)).tableau)[0] =
 2925:                         (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
 2926:                 ((integer8 *) (*((struct_vecteur *)
 2927:                         (*(*((struct_liste_chainee *) (*s_objet_adresse)
 2928:                         .objet)).donnee).objet)).tableau)[1] =
 2929:                         (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
 2930:                 ((integer8 *) (*((struct_vecteur *)
 2931:                         (*(*((struct_liste_chainee *) (*s_objet_adresse)
 2932:                         .objet)).donnee).objet)).tableau)[2] =
 2933:                         (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
 2934:                 ((integer8 *) (*((struct_vecteur *)
 2935:                         (*(*((struct_liste_chainee *) (*s_objet_adresse)
 2936:                         .objet)).donnee).objet)).tableau)[3] =
 2937:                         ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
 2938: 
 2939:                 if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
 2940:                         .suivant = allocation_maillon(s_etat_processus))
 2941:                         == NULL)
 2942:                 {
 2943:                     (*s_etat_processus).erreur_systeme =
 2944:                             d_es_allocation_memoire;
 2945:                     return;
 2946:                 }
 2947: 
 2948:                 if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
 2949:                         .suivant).donnee = allocation(s_etat_processus, INT))
 2950:                         == NULL)
 2951:                 {
 2952:                     (*s_etat_processus).erreur_systeme =
 2953:                             d_es_allocation_memoire;
 2954:                     return;
 2955:                 }
 2956: 
 2957:                 (*((integer8 *) (*(*(*((struct_liste_chainee *)
 2958:                         (*s_objet_adresse).objet)).suivant).donnee).objet)) =
 2959:                         (integer8) ntohs(adresse_ipv4.sin_port);
 2960: 
 2961:                 (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
 2962:                         .suivant).suivant = NULL;
 2963:             }
 2964:             else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 2965:                     .domaine == PF_INET6)
 2966:             {
 2967: #               ifdef IPV6
 2968:                 if (((*s_objet_adresse).objet =
 2969:                         allocation_maillon(s_etat_processus)) == NULL)
 2970:                 {
 2971:                     (*s_etat_processus).erreur_systeme =
 2972:                             d_es_allocation_memoire;
 2973:                     return;
 2974:                 }
 2975: 
 2976:                 if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
 2977:                         .donnee = allocation(s_etat_processus, VIN)) == NULL)
 2978:                 {
 2979:                     (*s_etat_processus).erreur_systeme =
 2980:                             d_es_allocation_memoire;
 2981:                     return;
 2982:                 }
 2983: 
 2984:                 (*((struct_vecteur *) (*(*((struct_liste_chainee *)
 2985:                         (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
 2986: 
 2987:                 if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
 2988:                         (*s_objet_adresse).objet)).donnee).objet)).tableau =
 2989:                         malloc(16 * sizeof(integer8))) == NULL)
 2990:                 {
 2991:                     (*s_etat_processus).erreur_systeme =
 2992:                             d_es_allocation_memoire;
 2993:                     return;
 2994:                 }
 2995: 
 2996:                 for(i = 0; i < 16; i++)
 2997:                 {
 2998:                     ((integer8 *) (*((struct_vecteur *)
 2999:                             (*(*((struct_liste_chainee *) (*s_objet_adresse)
 3000:                             .objet)).donnee).objet)).tableau)[0] =
 3001:                             adresse_ipv6.sin6_addr.s6_addr[i];
 3002:                 }
 3003: 
 3004:                 if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3005:                         .suivant = allocation_maillon(s_etat_processus))
 3006:                         == NULL)
 3007:                 {
 3008:                     (*s_etat_processus).erreur_systeme =
 3009:                             d_es_allocation_memoire;
 3010:                     return;
 3011:                 }
 3012: 
 3013:                 if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3014:                         .suivant).donnee = allocation(s_etat_processus, INT))
 3015:                         == NULL)
 3016:                 {
 3017:                     (*s_etat_processus).erreur_systeme =
 3018:                             d_es_allocation_memoire;
 3019:                     return;
 3020:                 }
 3021: 
 3022:                 (*((integer8 *) (*(*(*((struct_liste_chainee *)
 3023:                         (*s_objet_adresse).objet)).suivant).donnee).objet)) =
 3024:                         (integer8) ntohs(adresse_ipv6.sin6_port);
 3025: 
 3026:                 (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3027:                         .suivant).suivant = NULL;
 3028: #               else
 3029:                 if ((*s_etat_processus).langue == 'F')
 3030:                 {
 3031:                     printf("+++Attention : Support du protocole"
 3032:                             " IPv6 indisponible\n");
 3033:                 }
 3034:                 else
 3035:                 {
 3036:                     printf("+++Warning : IPv6 support "
 3037:                             "unavailable\n");
 3038:                 }
 3039: #               endif
 3040:             }
 3041:             else
 3042:             {
 3043:                 longueur_adresse = 0;
 3044:                 recvfrom((*((struct_socket *)
 3045:                         (*s_objet_argument_1).objet)).socket, tampon_lecture,
 3046:                         (size_t) position_finale, MSG_DONTWAIT,
 3047:                         NULL, &longueur_adresse);
 3048:             }
 3049: 
 3050:             free(tampon_lecture);
 3051: 
 3052:             if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 3053:                     s_objet_resultat) == d_erreur)
 3054:             {
 3055:                 return;
 3056:             }
 3057:         }
 3058:         else if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire
 3059:                 == 'Y')
 3060:         { // socket non formatée
 3061:             longueur_questure = 4096;
 3062:             longueur_effective = 0;
 3063:             tampon_lecture = NULL;
 3064: 
 3065:             attente.tv_sec = 0;
 3066:             attente.tv_nsec = GRANULARITE_us * 1000;
 3067: 
 3068:             trame_complete = d_faux;
 3069:             position_initiale = 0;
 3070:             position_finale = 0;
 3071: 
 3072:             do
 3073:             {
 3074:                 presence_indicateur = d_faux;
 3075: 
 3076:                 if ((tampon_lecture = realloc(tampon_lecture,
 3077:                         ((size_t) (longueur_effective + longueur_questure) + 1)
 3078:                         * sizeof(unsigned char))) == NULL)
 3079:                 {
 3080:                     (*s_etat_processus).erreur_systeme =
 3081:                             d_es_allocation_memoire;
 3082:                     return;
 3083:                 }
 3084: 
 3085: #               ifndef SEMAPHORES_NOMMES
 3086:                     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 3087: #               else
 3088:                     if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 3089: #               endif
 3090:                 {
 3091:                     (*s_etat_processus).erreur_systeme = d_es_processus;
 3092:                     return;
 3093:                 }
 3094: 
 3095:                 if ((*((struct_socket *) (*s_objet_argument_1).objet))
 3096:                         .domaine == PF_UNIX)
 3097:                 {
 3098:                     longueur_adresse = sizeof(adresse_unix);
 3099: 
 3100:                     do
 3101:                     {
 3102:                         ios = (int) recvfrom((*((struct_socket *)
 3103:                                 (*s_objet_argument_1).objet)).socket,
 3104:                                 tampon_lecture, (size_t)
 3105:                                 (longueur_effective + longueur_questure),
 3106:                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
 3107:                                 &adresse_unix, &longueur_adresse);
 3108:                     } while((ios == -1) && (errno == EINTR));
 3109:                 }
 3110:                 else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 3111:                         .domaine == PF_INET)
 3112:                 {
 3113:                     longueur_adresse = sizeof(adresse_ipv4);
 3114: 
 3115:                     do
 3116:                     {
 3117:                         ios = (int) recvfrom((*((struct_socket *)
 3118:                                 (*s_objet_argument_1).objet)).socket,
 3119:                                 tampon_lecture, (size_t)
 3120:                                 (longueur_effective + longueur_questure),
 3121:                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
 3122:                                 &adresse_ipv4, &longueur_adresse);
 3123:                     } while((ios == -1) && (errno == EINTR));
 3124:                 }
 3125:                 else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 3126:                         .domaine == PF_INET6)
 3127:                 {
 3128: #                   ifdef IPV6
 3129:                     longueur_adresse = sizeof(adresse_ipv6);
 3130:                     
 3131:                     do
 3132:                     {
 3133:                         ios = (int) recvfrom((*((struct_socket *)
 3134:                                 (*s_objet_argument_1).objet)).socket,
 3135:                                 tampon_lecture, (size_t)
 3136:                                 (longueur_effective + longueur_questure),
 3137:                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
 3138:                                 &adresse_ipv6, &longueur_adresse);
 3139:                     } while((ios == -1) && (errno == EINTR));
 3140: #                   else
 3141:                     if ((*s_etat_processus).langue == 'F')
 3142:                     {
 3143:                         printf("+++Attention : Support du protocole"
 3144:                                 " IPv6 indisponible\n");
 3145:                     }
 3146:                     else
 3147:                     {
 3148:                         printf("+++Warning : IPv6 support "
 3149:                                 "unavailable\n");
 3150:                     }
 3151: 
 3152:                     longueur_adresse = 0;
 3153:                     longueur_effective = 0;
 3154:                     ios = 0;
 3155: #                   endif
 3156:                 }
 3157:                 else
 3158:                 {
 3159:                     free(tampon_lecture);
 3160:                     liberation(s_etat_processus, s_objet_argument_1);
 3161: 
 3162: #                   ifndef SEMAPHORES_NOMMES
 3163:                         while(sem_wait(&((*s_etat_processus)
 3164:                                 .semaphore_fork)) != 0)
 3165: #                   else
 3166:                         while(sem_wait((*s_etat_processus)
 3167:                                 .semaphore_fork) != 0)
 3168: #                   endif
 3169:                     {
 3170:                         (*s_etat_processus).erreur_systeme =
 3171:                                 d_es_processus;
 3172:                     }
 3173: 
 3174:                     (*s_etat_processus).erreur_execution =
 3175:                             d_ex_erreur_acces_fichier;
 3176:                     return;
 3177:                 }
 3178: 
 3179:                 if (ios <= 0)
 3180:                 {
 3181:                     nanosleep(&attente, NULL);
 3182:                     INCR_GRANULARITE(attente.tv_nsec);
 3183:                 }
 3184:                 else
 3185:                 {
 3186:                     attente.tv_sec = 0;
 3187:                     attente.tv_nsec = GRANULARITE_us * 1000;
 3188:                 }
 3189: 
 3190:                 scrutation_injection(s_etat_processus);
 3191: 
 3192:                 if ((*s_etat_processus).var_volatile_requete_arret == -1)
 3193:                 {
 3194:                     if (ios >= 0)
 3195:                     {
 3196:                         longueur_effective += ios;
 3197:                     }
 3198: 
 3199:                     break;
 3200:                 }
 3201: 
 3202:                 // Une donnée a été reçue.
 3203: 
 3204:                 if (ios == (longueur_effective + longueur_questure))
 3205:                 {
 3206:                     longueur_effective = ios;
 3207:                     position_initiale = 0;
 3208:                     presence_indicateur = d_faux;
 3209:                 }
 3210:                 else if (ios > 0)
 3211:                 {
 3212:                     // On retire une trame du buffer.
 3213: 
 3214:                     if ((*((struct_socket *) (*s_objet_argument_1).objet))
 3215:                             .domaine == PF_UNIX)
 3216:                     {
 3217:                         do
 3218:                         {
 3219:                             longueur_adresse = sizeof(adresse_unix);
 3220:                             recvfrom((*((struct_socket *)
 3221:                                     (*s_objet_argument_1).objet)).socket,
 3222:                                     tampon_lecture, (size_t) longueur_effective,
 3223:                                     0, (struct sockaddr *)
 3224:                                     &adresse_unix, &longueur_adresse);
 3225:                         } while((ios == -1) && (errno == EINTR));
 3226:                     }
 3227:                     else if ((*((struct_socket *) (*s_objet_argument_1)
 3228:                             .objet)).domaine == PF_INET)
 3229:                     {
 3230:                         do
 3231:                         {
 3232:                             longueur_adresse = sizeof(adresse_ipv4);
 3233:                             recvfrom((*((struct_socket *)
 3234:                                     (*s_objet_argument_1).objet)).socket,
 3235:                                     tampon_lecture, (size_t) longueur_effective,
 3236:                                     0, (struct sockaddr *)
 3237:                                     &adresse_ipv4, &longueur_adresse);
 3238:                         } while((ios == -1) && (errno == EINTR));
 3239:                     }
 3240:                     else if ((*((struct_socket *) (*s_objet_argument_1)
 3241:                             .objet)) .domaine == PF_INET6)
 3242:                     {
 3243: #                       ifdef IPV6
 3244:                         do
 3245:                         {
 3246:                             longueur_adresse = sizeof(adresse_ipv6);
 3247:                             recvfrom((*((struct_socket *)
 3248:                                     (*s_objet_argument_1).objet)).socket,
 3249:                                     tampon_lecture, (size_t) longueur_effective,
 3250:                                     0, (struct sockaddr *)
 3251:                                     &adresse_ipv6, &longueur_adresse);
 3252:                         } while((ios == -1) && (errno == EINTR));
 3253: #                       else
 3254:                         if ((*s_etat_processus).langue == 'F')
 3255:                         {
 3256:                             printf("+++Attention : Support du protocole"
 3257:                                     " IPv6 indisponible\n");
 3258:                         }
 3259:                         else
 3260:                         {
 3261:                             printf("+++Warning : IPv6 support "
 3262:                                     "unavailable\n");
 3263:                         }
 3264: #                       endif
 3265:                     }
 3266: 
 3267:                     longueur_effective = ios;
 3268:                     trame_complete = d_vrai;
 3269:                 }
 3270: 
 3271: #               ifndef SEMAPHORES_NOMMES
 3272:                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 3273: #               else
 3274:                     while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 3275: #               endif
 3276:                 {
 3277:                     if (errno == EINTR)
 3278:                     {
 3279:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 3280:                         return;
 3281:                     }
 3282:                 }
 3283: 
 3284:                 if ((*s_etat_processus).var_volatile_requete_arret == -1)
 3285:                 {
 3286: 
 3287:                     /*
 3288:                      * Si le père tue le processus courant grâce au signal
 3289:                      * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
 3290:                      * correspond à l'utilisation de STOP sur le processus
 3291:                      * en cours. La variable longueur_effective vaut '-1'.
 3292:                      */
 3293: 
 3294:                     free(tampon_lecture);
 3295:                     liberation(s_etat_processus, s_objet_argument_1);
 3296:                     return;
 3297:                 }
 3298: 
 3299:                 if (longueur_effective == -1)
 3300:                 {
 3301:                     free(tampon_lecture);
 3302:                     liberation(s_etat_processus, s_objet_argument_1);
 3303: 
 3304:                     (*s_etat_processus).erreur_execution =
 3305:                             d_ex_erreur_acces_fichier;
 3306:                     return;
 3307:                 }
 3308:             } while(trame_complete == d_faux);
 3309: 
 3310:             /*
 3311:              * Création de la liste de sortie
 3312:              */
 3313: 
 3314:             ptr = tampon_lecture;
 3315: 
 3316:             if ((s_objet_type = lecture_fichier_non_formate(s_etat_processus,
 3317:                     &ptr, longueur_effective, d_faux)) == NULL)
 3318:             {
 3319:                 free(tampon_lecture);
 3320: 
 3321:                 (*s_etat_processus).erreur_execution = d_ex_syntaxe;
 3322:                 return;
 3323:             }
 3324: 
 3325:             if ((s_objet_resultat = allocation(s_etat_processus, LST))
 3326:                     == NULL)
 3327:             {
 3328:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 3329:                 return;
 3330:             }
 3331: 
 3332:             if (((*s_objet_resultat).objet =
 3333:                     allocation_maillon(s_etat_processus)) == NULL)
 3334:             {
 3335:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 3336:                 return;
 3337:             }
 3338: 
 3339:             (*((struct_liste_chainee *) (*s_objet_resultat).objet))
 3340:                     .donnee = s_objet_type;
 3341: 
 3342:             if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
 3343:                     .suivant = allocation_maillon(s_etat_processus)) == NULL)
 3344:             {
 3345:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 3346:                 return;
 3347:             }
 3348: 
 3349:             (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
 3350:                     .suivant = NULL;
 3351: 
 3352:             if ((s_objet_adresse = allocation(s_etat_processus, LST))
 3353:                     == NULL)
 3354:             {
 3355:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 3356:                 return;
 3357:             }
 3358: 
 3359:             (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
 3360:                     .donnee = s_objet_adresse;
 3361: 
 3362:             /*
 3363:              * Les informations concernant la cible sont valides si
 3364:              * la socket est non connectée et des domaines INET ou INET6.
 3365:              * Dans tous les autres cas, on renvoie une liste vide.
 3366:              */
 3367: 
 3368:             if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
 3369:                     == PF_UNIX) || (strcmp((*((struct_socket *)
 3370:                     (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
 3371:                     (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
 3372:                     .type, "SEQUENTIAL DATAGRAM") == 0))
 3373:             {
 3374:                 (*s_objet_adresse).objet = NULL;
 3375:             }
 3376:             else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 3377:                     .domaine == PF_INET)
 3378:             {
 3379:                 if (((*s_objet_adresse).objet =
 3380:                         allocation_maillon(s_etat_processus)) == NULL)
 3381:                 {
 3382:                     (*s_etat_processus).erreur_systeme =
 3383:                             d_es_allocation_memoire;
 3384:                     return;
 3385:                 }
 3386: 
 3387:                 if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3388:                         .donnee = allocation(s_etat_processus, VIN)) == NULL)
 3389:                 {
 3390:                     (*s_etat_processus).erreur_systeme =
 3391:                             d_es_allocation_memoire;
 3392:                     return;
 3393:                 }
 3394: 
 3395:                 (*((struct_vecteur *) (*(*((struct_liste_chainee *)
 3396:                         (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
 3397: 
 3398:                 if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
 3399:                         (*s_objet_adresse).objet)).donnee).objet)).tableau =
 3400:                         malloc(4 * sizeof(integer8))) == NULL)
 3401:                 {
 3402:                     (*s_etat_processus).erreur_systeme =
 3403:                             d_es_allocation_memoire;
 3404:                     return;
 3405:                 }
 3406: 
 3407:                 ((integer8 *) (*((struct_vecteur *)
 3408:                         (*(*((struct_liste_chainee *) (*s_objet_adresse)
 3409:                         .objet)).donnee).objet)).tableau)[0] =
 3410:                         (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
 3411:                 ((integer8 *) (*((struct_vecteur *)
 3412:                         (*(*((struct_liste_chainee *) (*s_objet_adresse)
 3413:                         .objet)).donnee).objet)).tableau)[1] =
 3414:                         (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
 3415:                 ((integer8 *) (*((struct_vecteur *)
 3416:                         (*(*((struct_liste_chainee *) (*s_objet_adresse)
 3417:                         .objet)).donnee).objet)).tableau)[2] =
 3418:                         (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
 3419:                 ((integer8 *) (*((struct_vecteur *)
 3420:                         (*(*((struct_liste_chainee *) (*s_objet_adresse)
 3421:                         .objet)).donnee).objet)).tableau)[3] =
 3422:                         ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
 3423: 
 3424:                 if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3425:                         .suivant = allocation_maillon(s_etat_processus))
 3426:                         == NULL)
 3427:                 {
 3428:                     (*s_etat_processus).erreur_systeme =
 3429:                             d_es_allocation_memoire;
 3430:                     return;
 3431:                 }
 3432: 
 3433:                 if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3434:                         .suivant).donnee = allocation(s_etat_processus, INT))
 3435:                         == NULL)
 3436:                 {
 3437:                     (*s_etat_processus).erreur_systeme =
 3438:                             d_es_allocation_memoire;
 3439:                     return;
 3440:                 }
 3441: 
 3442:                 (*((integer8 *) (*(*(*((struct_liste_chainee *)
 3443:                         (*s_objet_adresse).objet)).suivant).donnee).objet)) =
 3444:                         (integer8) ntohs(adresse_ipv4.sin_port);
 3445: 
 3446:                 (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3447:                         .suivant).suivant = NULL;
 3448:             }
 3449:             else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 3450:                     .domaine == PF_INET6)
 3451:             {
 3452: #               ifdef IPV6
 3453:                 if (((*s_objet_adresse).objet =
 3454:                         allocation_maillon(s_etat_processus)) == NULL)
 3455:                 {
 3456:                     (*s_etat_processus).erreur_systeme =
 3457:                             d_es_allocation_memoire;
 3458:                     return;
 3459:                 }
 3460: 
 3461:                 if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3462:                         .donnee = allocation(s_etat_processus, VIN)) == NULL)
 3463:                 {
 3464:                     (*s_etat_processus).erreur_systeme =
 3465:                             d_es_allocation_memoire;
 3466:                     return;
 3467:                 }
 3468: 
 3469:                 (*((struct_vecteur *) (*(*((struct_liste_chainee *)
 3470:                         (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
 3471: 
 3472:                 if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
 3473:                         (*s_objet_adresse).objet)).donnee).objet)).tableau =
 3474:                         malloc(16 * sizeof(integer8))) == NULL)
 3475:                 {
 3476:                     (*s_etat_processus).erreur_systeme =
 3477:                             d_es_allocation_memoire;
 3478:                     return;
 3479:                 }
 3480: 
 3481:                 for(i = 0; i < 16; i++)
 3482:                 {
 3483:                     ((integer8 *) (*((struct_vecteur *)
 3484:                             (*(*((struct_liste_chainee *) (*s_objet_adresse)
 3485:                             .objet)).donnee).objet)).tableau)[0] =
 3486:                             adresse_ipv6.sin6_addr.s6_addr[i];
 3487:                 }
 3488: 
 3489:                 if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3490:                         .suivant = allocation_maillon(s_etat_processus))
 3491:                         == NULL)
 3492:                 {
 3493:                     (*s_etat_processus).erreur_systeme =
 3494:                             d_es_allocation_memoire;
 3495:                     return;
 3496:                 }
 3497: 
 3498:                 if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3499:                         .suivant).donnee = allocation(s_etat_processus, INT))
 3500:                         == NULL)
 3501:                 {
 3502:                     (*s_etat_processus).erreur_systeme =
 3503:                             d_es_allocation_memoire;
 3504:                     return;
 3505:                 }
 3506: 
 3507:                 (*((integer8 *) (*(*(*((struct_liste_chainee *)
 3508:                         (*s_objet_adresse).objet)).suivant).donnee).objet)) =
 3509:                         (integer8) ntohs(adresse_ipv6.sin6_port);
 3510: 
 3511:                 (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3512:                         .suivant).suivant = NULL;
 3513: #               else
 3514:                 if ((*s_etat_processus).langue == 'F')
 3515:                 {
 3516:                     printf("+++Attention : Support du protocole"
 3517:                             " IPv6 indisponible\n");
 3518:                 }
 3519:                 else
 3520:                 {
 3521:                     printf("+++Warning : IPv6 support "
 3522:                             "unavailable\n");
 3523:                 }
 3524: #               endif
 3525:             }
 3526:             else
 3527:             {
 3528:                 longueur_adresse = 0;
 3529:                 recvfrom((*((struct_socket *)
 3530:                         (*s_objet_argument_1).objet)).socket, tampon_lecture,
 3531:                         (size_t) position_finale, MSG_DONTWAIT,
 3532:                         NULL, &longueur_adresse);
 3533:             }
 3534: 
 3535:             free(tampon_lecture);
 3536: 
 3537:             if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 3538:                     s_objet_resultat) == d_erreur)
 3539:             {
 3540:                 return;
 3541:             }
 3542:         }
 3543:         else
 3544:         { // FLOW
 3545:             longueur_questure = 256;
 3546: 
 3547:             do
 3548:             {
 3549:                 if ((tampon_lecture = malloc((((size_t) longueur_questure) + 1)
 3550:                         * sizeof(unsigned char))) == NULL)
 3551:                 {
 3552:                     (*s_etat_processus).erreur_systeme =
 3553:                             d_es_allocation_memoire;
 3554:                     return;
 3555:                 }
 3556: 
 3557: #               ifndef SEMAPHORES_NOMMES
 3558:                     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 3559: #               else
 3560:                     if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 3561: #               endif
 3562:                 {
 3563:                     (*s_etat_processus).erreur_systeme = d_es_processus;
 3564:                     return;
 3565:                 }
 3566: 
 3567:                 attente.tv_sec = 0;
 3568:                 attente.tv_nsec = GRANULARITE_us * 1000;
 3569: 
 3570:                 for(;;)
 3571:                 {
 3572:                     if ((*((struct_socket *) (*s_objet_argument_1).objet))
 3573:                             .domaine == PF_UNIX)
 3574:                     {
 3575:                         longueur_adresse = sizeof(adresse_unix);
 3576:                         longueur_effective = recvfrom((*((struct_socket *)
 3577:                                 (*s_objet_argument_1).objet)).socket,
 3578:                                 tampon_lecture, (long unsigned int)
 3579:                                 longueur_questure,
 3580:                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
 3581:                                 &adresse_unix, &longueur_adresse);
 3582:                     }
 3583:                     else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 3584:                             .domaine == PF_INET)
 3585:                     {
 3586:                         longueur_adresse = sizeof(adresse_ipv4);
 3587:                         longueur_effective = recvfrom((*((struct_socket *)
 3588:                                 (*s_objet_argument_1).objet)).socket,
 3589:                                 tampon_lecture, (long unsigned int)
 3590:                                 longueur_questure,
 3591:                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
 3592:                                 &adresse_ipv4, &longueur_adresse);
 3593:                     }
 3594:                     else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 3595:                             .domaine == PF_INET6)
 3596:                     {
 3597: #                       ifdef IPV6
 3598:                         longueur_adresse = sizeof(adresse_ipv6);
 3599:                         longueur_effective = recvfrom((*((struct_socket *)
 3600:                                 (*s_objet_argument_1).objet)).socket,
 3601:                                 tampon_lecture, (long unsigned int)
 3602:                                 longueur_questure,
 3603:                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
 3604:                                 &adresse_ipv6, &longueur_adresse);
 3605: #                       else
 3606:                         if ((*s_etat_processus).langue == 'F')
 3607:                         {
 3608:                             printf("+++Attention : Support du protocole"
 3609:                                     " IPv6 indisponible\n");
 3610:                         }
 3611:                         else
 3612:                         {
 3613:                             printf("+++Warning : IPv6 support "
 3614:                                     "unavailable\n");
 3615:                         }
 3616: 
 3617:                         longueur_adresse = 0;
 3618:                         longueur_effective = 0;
 3619: #                       endif
 3620:                     }
 3621:                     else
 3622:                     {
 3623:                         free(tampon_lecture);
 3624:                         liberation(s_etat_processus, s_objet_argument_1);
 3625: 
 3626: #                       ifndef SEMAPHORES_NOMMES
 3627:                             while(sem_wait(&((*s_etat_processus)
 3628:                                     .semaphore_fork)) != 0)
 3629: #                       else
 3630:                             while(sem_wait((*s_etat_processus)
 3631:                                     .semaphore_fork) != 0)
 3632: #                       endif
 3633:                         {
 3634:                             if (errno != EINTR)
 3635:                             {
 3636:                                 (*s_etat_processus).erreur_systeme =
 3637:                                         d_es_processus;
 3638:                                 return;
 3639:                             }
 3640:                         }
 3641: 
 3642:                         (*s_etat_processus).erreur_execution =
 3643:                                 d_ex_erreur_acces_fichier;
 3644:                         return;
 3645:                     }
 3646: 
 3647:                     if (longueur_effective < 0)
 3648:                     {
 3649:                         nanosleep(&attente, NULL);
 3650:                         INCR_GRANULARITE(attente.tv_nsec);
 3651:                         scrutation_injection(s_etat_processus);
 3652:                     }
 3653: 
 3654:                     if (((*s_etat_processus).var_volatile_requete_arret == -1)
 3655:                             || (longueur_effective >= 0))
 3656:                     {
 3657:                         break;
 3658:                     }
 3659:                 }
 3660: 
 3661: #               ifndef SEMAPHORES_NOMMES
 3662:                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 3663: #               else
 3664:                     while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 3665: #               endif
 3666:                 {
 3667:                     if (errno != EINTR)
 3668:                     {
 3669:                         (*s_etat_processus).erreur_systeme = d_es_processus;
 3670:                         return;
 3671:                     }
 3672:                 }
 3673: 
 3674:                 if ((*s_etat_processus).var_volatile_requete_arret == -1)
 3675:                 {
 3676: 
 3677:                     /*
 3678:                      * Si le père tue le processus courant grâce au signal
 3679:                      * SIGFSTOP, on ne renvoie pas d'erreur. Ce fonctionnement
 3680:                      * correspond à l'utilisation de STOP sur le processus
 3681:                      * en cours. La variable longueur_effective vaut '-1'.
 3682:                      */
 3683: 
 3684:                     free(tampon_lecture);
 3685:                     liberation(s_etat_processus, s_objet_argument_1);
 3686:                     return;
 3687:                 }
 3688: 
 3689:                 if (longueur_effective == -1)
 3690:                 {
 3691:                     free(tampon_lecture);
 3692:                     liberation(s_etat_processus, s_objet_argument_1);
 3693: 
 3694:                     (*s_etat_processus).erreur_execution =
 3695:                             d_ex_erreur_acces_fichier;
 3696:                     return;
 3697:                 }
 3698: 
 3699:                 if (longueur_effective == longueur_questure)
 3700:                 {
 3701:                     free(tampon_lecture);
 3702:                     longueur_questure *= 2;
 3703:                 }
 3704:             } while(longueur_effective == longueur_questure);
 3705: 
 3706:             longueur_enregistrement = 1;
 3707: 
 3708:             for(i = 0; i < longueur_effective; i++)
 3709:             {
 3710:                 if (isprint(tampon_lecture[i]) != 0)
 3711:                 {
 3712:                     longueur_enregistrement += 4;
 3713:                 }
 3714:                 else
 3715:                 {
 3716:                     longueur_enregistrement++;
 3717:                 }
 3718:             }
 3719: 
 3720:             /*
 3721:              * Création de la liste de sortie
 3722:              */
 3723: 
 3724:             if ((s_objet_type = allocation(s_etat_processus, CHN)) == NULL)
 3725:             {
 3726:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 3727:                 return;
 3728:             }
 3729: 
 3730:             if (((*s_objet_type).objet = malloc((size_t) longueur_enregistrement
 3731:                     * sizeof(unsigned char))) == NULL)
 3732:             {
 3733:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 3734:                 return;
 3735:             }
 3736: 
 3737:             ptr = (*s_objet_type).objet;
 3738: 
 3739:             for(i = 0; i < longueur_effective; i++)
 3740:             {
 3741:                 if (isprint(tampon_lecture[i]) != 0)
 3742:                 {
 3743:                     (*ptr) = tampon_lecture[i];
 3744:                     ptr++;
 3745:                 }
 3746:                 else
 3747:                 {
 3748:                     (*ptr) = '\\';
 3749:                     ptr++;
 3750:                     (*ptr) = 'x';
 3751:                     ptr++;
 3752:                     sprintf(ptr, "%02X", tampon_lecture[i]);
 3753:                     ptr += 2;
 3754:                 }
 3755:             }
 3756: 
 3757:             (*ptr) = d_code_fin_chaine;
 3758: 
 3759:             if ((s_objet_resultat = allocation(s_etat_processus, LST))
 3760:                     == NULL)
 3761:             {
 3762:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 3763:                 return;
 3764:             }
 3765: 
 3766:             if (((*s_objet_resultat).objet =
 3767:                     allocation_maillon(s_etat_processus)) == NULL)
 3768:             {
 3769:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 3770:                 return;
 3771:             }
 3772: 
 3773:             (*((struct_liste_chainee *) (*s_objet_resultat).objet))
 3774:                     .donnee = s_objet_type;
 3775: 
 3776:             if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))
 3777:                     .suivant = allocation_maillon(s_etat_processus)) == NULL)
 3778:             {
 3779:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 3780:                 return;
 3781:             }
 3782: 
 3783:             (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
 3784:                     .suivant = NULL;
 3785: 
 3786:             if ((s_objet_adresse = allocation(s_etat_processus, LST))
 3787:                     == NULL)
 3788:             {
 3789:                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 3790:                 return;
 3791:             }
 3792: 
 3793:             (*(*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant)
 3794:                     .donnee = s_objet_adresse;
 3795: 
 3796:             /*
 3797:              * Les informations concernant la cible sont valides si
 3798:              * la socket est non connectée et que les domaines sont
 3799:              * INET ou INET6.
 3800:              * Dans tous les autres cas, on renvoie une liste vide.
 3801:              */
 3802: 
 3803:             if (((*((struct_socket *) (*s_objet_argument_1).objet)).domaine
 3804:                     == PF_UNIX) || (strcmp((*((struct_socket *)
 3805:                     (*s_objet_argument_1).objet)).type, "STREAM") == 0) ||
 3806:                     (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
 3807:                     .type, "SEQUENTIAL DATAGRAM") == 0))
 3808:             {
 3809:                 // POSITION_FINALE peut être utilisée sans être initialisée !
 3810:                 // virer position_finale pour longueur_effective
 3811:                 longueur_adresse = 0;
 3812:                 recvfrom((*((struct_socket *)
 3813:                         (*s_objet_argument_1).objet)).socket, tampon_lecture,
 3814:                         (long unsigned int) longueur_effective, MSG_DONTWAIT,
 3815:                         NULL, &longueur_adresse);
 3816: 
 3817:                 (*s_objet_adresse).objet = NULL;
 3818:             }
 3819:             else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 3820:                     .domaine == PF_INET)
 3821:             {
 3822:                 longueur_adresse = sizeof(adresse_ipv4);
 3823:                 recvfrom((*((struct_socket *)
 3824:                         (*s_objet_argument_1).objet)).socket, tampon_lecture,
 3825:                         (long unsigned int) longueur_effective, MSG_DONTWAIT,
 3826:                         (struct sockaddr *) &adresse_ipv4, &longueur_adresse);
 3827: 
 3828:                 if (((*s_objet_adresse).objet =
 3829:                         allocation_maillon(s_etat_processus)) == NULL)
 3830:                 {
 3831:                     (*s_etat_processus).erreur_systeme =
 3832:                             d_es_allocation_memoire;
 3833:                     return;
 3834:                 }
 3835: 
 3836:                 if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3837:                         .donnee = allocation(s_etat_processus, VIN)) == NULL)
 3838:                 {
 3839:                     (*s_etat_processus).erreur_systeme =
 3840:                             d_es_allocation_memoire;
 3841:                     return;
 3842:                 }
 3843: 
 3844:                 (*((struct_vecteur *) (*(*((struct_liste_chainee *)
 3845:                         (*s_objet_adresse).objet)).donnee).objet)).taille = 4;
 3846: 
 3847:                 if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
 3848:                         (*s_objet_adresse).objet)).donnee).objet)).tableau =
 3849:                         malloc(4 * sizeof(integer8))) == NULL)
 3850:                 {
 3851:                     (*s_etat_processus).erreur_systeme =
 3852:                             d_es_allocation_memoire;
 3853:                     return;
 3854:                 }
 3855: 
 3856:                 ((integer8 *) (*((struct_vecteur *)
 3857:                         (*(*((struct_liste_chainee *) (*s_objet_adresse)
 3858:                         .objet)).donnee).objet)).tableau)[0] =
 3859:                         (ntohl(adresse_ipv4.sin_addr.s_addr) >> 24) & 0xFF;
 3860:                 ((integer8 *) (*((struct_vecteur *)
 3861:                         (*(*((struct_liste_chainee *) (*s_objet_adresse)
 3862:                         .objet)).donnee).objet)).tableau)[1] =
 3863:                         (ntohl(adresse_ipv4.sin_addr.s_addr) >> 16) & 0xFF;
 3864:                 ((integer8 *) (*((struct_vecteur *)
 3865:                         (*(*((struct_liste_chainee *) (*s_objet_adresse)
 3866:                         .objet)).donnee).objet)).tableau)[2] =
 3867:                         (ntohl(adresse_ipv4.sin_addr.s_addr) >> 8) & 0xFF;
 3868:                 ((integer8 *) (*((struct_vecteur *)
 3869:                         (*(*((struct_liste_chainee *) (*s_objet_adresse)
 3870:                         .objet)).donnee).objet)).tableau)[3] =
 3871:                         ntohl(adresse_ipv4.sin_addr.s_addr) & 0xFF;
 3872: 
 3873:                 if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3874:                         .suivant = allocation_maillon(s_etat_processus))
 3875:                         == NULL)
 3876:                 {
 3877:                     (*s_etat_processus).erreur_systeme =
 3878:                             d_es_allocation_memoire;
 3879:                     return;
 3880:                 }
 3881: 
 3882:                 if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3883:                         .suivant).donnee = allocation(s_etat_processus, INT))
 3884:                         == NULL)
 3885:                 {
 3886:                     (*s_etat_processus).erreur_systeme =
 3887:                             d_es_allocation_memoire;
 3888:                     return;
 3889:                 }
 3890: 
 3891:                 (*((integer8 *) (*(*(*((struct_liste_chainee *)
 3892:                         (*s_objet_adresse).objet)).suivant).donnee).objet)) =
 3893:                         (integer8) ntohs(adresse_ipv4.sin_port);
 3894: 
 3895:                 (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3896:                         .suivant).suivant = NULL;
 3897:             }
 3898:             else if ((*((struct_socket *) (*s_objet_argument_1).objet))
 3899:                     .domaine == PF_INET6)
 3900:             {
 3901: #               ifdef IPV6
 3902:                 longueur_adresse = sizeof(adresse_ipv6);
 3903:                 recvfrom((*((struct_socket *)
 3904:                         (*s_objet_argument_1).objet)).socket, tampon_lecture,
 3905:                         (long unsigned int) longueur_effective, MSG_DONTWAIT,
 3906:                         (struct sockaddr *) &adresse_ipv6, &longueur_adresse);
 3907: 
 3908:                 if (((*s_objet_adresse).objet =
 3909:                         allocation_maillon(s_etat_processus)) == NULL)
 3910:                 {
 3911:                     (*s_etat_processus).erreur_systeme =
 3912:                             d_es_allocation_memoire;
 3913:                     return;
 3914:                 }
 3915: 
 3916:                 if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3917:                         .donnee = allocation(s_etat_processus, VIN)) == NULL)
 3918:                 {
 3919:                     (*s_etat_processus).erreur_systeme =
 3920:                             d_es_allocation_memoire;
 3921:                     return;
 3922:                 }
 3923: 
 3924:                 (*((struct_vecteur *) (*(*((struct_liste_chainee *)
 3925:                         (*s_objet_adresse).objet)).donnee).objet)).taille = 16;
 3926: 
 3927:                 if (((*((struct_vecteur *) (*(*((struct_liste_chainee *)
 3928:                         (*s_objet_adresse).objet)).donnee).objet)).tableau =
 3929:                         malloc(16 * sizeof(integer8))) == NULL)
 3930:                 {
 3931:                     (*s_etat_processus).erreur_systeme =
 3932:                             d_es_allocation_memoire;
 3933:                     return;
 3934:                 }
 3935: 
 3936:                 for(i = 0; i < 16; i++)
 3937:                 {
 3938:                     ((integer8 *) (*((struct_vecteur *)
 3939:                             (*(*((struct_liste_chainee *) (*s_objet_adresse)
 3940:                             .objet)).donnee).objet)).tableau)[0] =
 3941:                             adresse_ipv6.sin6_addr.s6_addr[i];
 3942:                 }
 3943: 
 3944:                 if (((*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3945:                         .suivant = allocation_maillon(s_etat_processus))
 3946:                         == NULL)
 3947:                 {
 3948:                     (*s_etat_processus).erreur_systeme =
 3949:                             d_es_allocation_memoire;
 3950:                     return;
 3951:                 }
 3952: 
 3953:                 if (((*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3954:                         .suivant).donnee = allocation(s_etat_processus, INT))
 3955:                         == NULL)
 3956:                 {
 3957:                     (*s_etat_processus).erreur_systeme =
 3958:                             d_es_allocation_memoire;
 3959:                     return;
 3960:                 }
 3961: 
 3962:                 (*((integer8 *) (*(*(*((struct_liste_chainee *)
 3963:                         (*s_objet_adresse).objet)).suivant).donnee).objet)) =
 3964:                         (integer8) ntohs(adresse_ipv6.sin6_port);
 3965: 
 3966:                 (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
 3967:                         .suivant).suivant = NULL;
 3968: #               else
 3969:                 if ((*s_etat_processus).langue == 'F')
 3970:                 {
 3971:                     printf("+++Attention : Support du protocole"
 3972:                             " IPv6 indisponible\n");
 3973:                 }
 3974:                 else
 3975:                 {
 3976:                     printf("+++Warning : IPv6 support "
 3977:                             "unavailable\n");
 3978:                 }
 3979: #               endif
 3980:             }
 3981:             else
 3982:             {
 3983:                 longueur_adresse = 0;
 3984:                 recvfrom((*((struct_socket *)
 3985:                         (*s_objet_argument_1).objet)).socket, tampon_lecture,
 3986:                         (long unsigned int) longueur_effective, MSG_DONTWAIT,
 3987:                         NULL, &longueur_adresse);
 3988:             }
 3989: 
 3990:             free(tampon_lecture);
 3991: 
 3992:             if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 3993:                     s_objet_resultat) == d_erreur)
 3994:             {
 3995:                 return;
 3996:             }
 3997:         }
 3998:     }
 3999:     else
 4000:     {
 4001:         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
 4002:         return;
 4003:     }
 4004: 
 4005:     liberation(s_etat_processus, s_objet_argument_1);
 4006: 
 4007:     return;
 4008: }
 4009: 
 4010: // vim: ts=4

CVSweb interface <joel.bertrand@systella.fr>