Return to transliteration.c CVS log

Up to [local] / rpl / src

Correction d'un problème de signaux sous NetBSD. Le lancement du programme
pouvait échouer sur une erreur système car le thread de gestion des signaux
RPL/2 pouvait recevoir des signaux POSIX. Ce problème était aléatoire.
Typiquement, ave NetBSD 6 dans un DomU, cela fonctionnait, avec un NetBSD 6
dans VirtualBox, cela échouait à tous les coups.

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.12
    4:   Copyright (C) 1989-2012 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: #include "tex-conv.h"
   25: 
   26: #include <stdarg.h>
   27: 
   28: #undef fprintf
   29: #undef printf
   30: 
   31: 
   32: /*
   33: ================================================================================
   34:   Fonction de translitération
   35: ================================================================================
   36:   Entrées :
   37: --------------------------------------------------------------------------------
   38:   Sorties :
   39: --------------------------------------------------------------------------------
   40:   Effets de bord : néant
   41: ================================================================================
   42: */
   43: 
   44: unsigned char *
   45: transliteration(struct_processus *s_etat_processus,
   46:         unsigned char *chaine_entree,
   47:         unsigned char *codage_entree,
   48:         unsigned char *codage_sortie)
   49: {
   50:     unsigned char       *codage_sortie_transliteral;
   51:     unsigned char       *tampon;
   52: 
   53:     if ((codage_sortie_transliteral = malloc((strlen(codage_sortie)
   54:             + strlen("//TRANSLIT") + 1) * sizeof(unsigned char))) == NULL)
   55:     {
   56:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
   57:         return(NULL);
   58:     }
   59: 
   60:     sprintf(codage_sortie_transliteral, "%s//TRANSLIT", codage_sortie);
   61: 
   62:     tampon = reencodage(s_etat_processus, chaine_entree,
   63:             codage_entree, codage_sortie_transliteral);
   64:     free(codage_sortie_transliteral);
   65: 
   66:     return(tampon);
   67: }
   68: 
   69: 
   70: unsigned char *
   71: reencodage(struct_processus *s_etat_processus,
   72:         unsigned char *chaine_entree,
   73:         unsigned char *codage_entree,
   74:         unsigned char *codage_sortie)
   75: {
   76: #   define              d_LONGUEUR  1024
   77: 
   78:     iconv_t             transcodage;
   79: 
   80:     size_t              ios;
   81:     size_t              longueur_entree;
   82:     size_t              longueur_sortie;
   83: 
   84:     unsigned char       *buffer_entree;
   85:     unsigned char       *buffer_sortie;
   86:     unsigned char       *chaine_sortie;
   87:     unsigned char       *pointeur;
   88:     unsigned char       *tampon;
   89: 
   90:     if ((transcodage = iconv_open(codage_sortie, codage_entree)) ==
   91:             (iconv_t) -1)
   92:     {
   93:         // On affiche une erreur ici car la fonction d'affichage
   94:         // de l'erreur utilise la macro printf() donc une
   95:         // opération de translitération qui échouera elle aussi.
   96:         // Le positionnement de l'erreur permet de sortir du programme.
   97: 
   98:         if ((*s_etat_processus).langue == 'F')
   99:         {
  100:             fprintf(stderr, "+++Erreur : Erreur de transcodage\n");
  101:         }
  102:         else
  103:         {
  104:             fprintf(stderr, "+++Error : Transcodage error\n");
  105:         }
  106: 
  107:         (*s_etat_processus).erreur_execution = d_ex_erreur_transcodage;
  108:         return(NULL);
  109:     }
  110: 
  111:     buffer_entree = chaine_entree;
  112:     longueur_entree = strlen(chaine_entree);
  113: 
  114:     if ((chaine_sortie = malloc(sizeof(unsigned char))) == NULL)
  115:     {
  116:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  117:         return(NULL);
  118:     }
  119: 
  120:     chaine_sortie[0] = d_code_fin_chaine;
  121: 
  122:     if ((buffer_sortie = malloc((d_LONGUEUR + 1) * sizeof(unsigned char)))
  123:             == NULL)
  124:     {
  125:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  126:         return(NULL);
  127:     }
  128: 
  129:     do
  130:     {
  131:         longueur_sortie = d_LONGUEUR;
  132:         pointeur = buffer_sortie;
  133: 
  134:         if ((ios = iconv(transcodage, (char **) &buffer_entree,
  135:                 &longueur_entree, (char **) &pointeur, &longueur_sortie))
  136:                 == (size_t) -1)
  137:         {
  138:             // On autorise les erreurs EINVAL et EILSEQ
  139:             if (errno == EILSEQ)
  140:             {
  141:                 free(buffer_sortie);
  142:                 free(chaine_sortie);
  143: 
  144:                 // On affiche une erreur ici car la fonction d'affichage
  145:                 // de l'erreur utilise la macro printf() donc une
  146:                 // opération de translitération qui échouera elle aussi.
  147:                 // Le positionnement de l'erreur permet de sortir du programme.
  148: 
  149:                 if ((*s_etat_processus).langue == 'F')
  150:                 {
  151:                     fprintf(stderr, "+++Erreur : Erreur de transcodage\n");
  152:                 }
  153:                 else
  154:                 {
  155:                     fprintf(stderr, "+++Error : Transcodage error\n");
  156:                 }
  157: 
  158:                 (*s_etat_processus).erreur_execution = d_ex_erreur_transcodage;
  159:                 return(NULL);
  160:             }
  161:         }
  162: 
  163:         tampon = chaine_sortie;
  164:         (*pointeur) = d_code_fin_chaine;
  165: 
  166:         if ((chaine_sortie = malloc((strlen(tampon) + strlen(buffer_sortie) + 1)
  167:                 * sizeof(unsigned char))) == NULL)
  168:         {
  169:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  170:             return(NULL);
  171:         }
  172: 
  173:         sprintf(chaine_sortie, "%s%s", tampon, buffer_sortie);
  174:         free(tampon);
  175:     } while((*buffer_entree) != d_code_fin_chaine);
  176: 
  177:     free(buffer_sortie);
  178:     iconv_close(transcodage);
  179: 
  180:     return(chaine_sortie);
  181: }
  182: 
  183: 
  184: /*
  185: ================================================================================
  186:   Fonctions spécifiques
  187: ================================================================================
  188:   Entrées :
  189: --------------------------------------------------------------------------------
  190:   Sorties :
  191: --------------------------------------------------------------------------------
  192:   Effets de bord : néant
  193: ================================================================================
  194: */
  195: 
  196: void
  197: localisation_courante(struct_processus *s_etat_processus)
  198: {
  199:     char                        **arguments;
  200: 
  201:     int                         ios;
  202:     int                         pipes_entree[2];
  203:     int                         pipes_erreur[2];
  204:     int                         pipes_sortie[2];
  205:     int                         status;
  206: 
  207:     long                        i;
  208:     long                        nombre_arguments;
  209: 
  210:     pid_t                       pid;
  211: 
  212:     unsigned char               *tampon;
  213: 
  214:     unsigned long               longueur_lecture;
  215:     unsigned long               nombre_iterations;
  216:     unsigned long               pointeur;
  217: 
  218:     if ((arguments = malloc(3 * sizeof(char **))) == NULL)
  219:     {
  220:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  221:         return;
  222:     }
  223: 
  224:     if ((arguments[0] = malloc((strlen("locale") + 1) * sizeof(char))) == NULL)
  225:     {
  226:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  227:         return;
  228:     }
  229: 
  230:     if ((arguments[1] = malloc((strlen("charmap") + 1) * sizeof(char))) == NULL)
  231:     {
  232:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  233:         return;
  234:     }
  235: 
  236:     strcpy(arguments[0], "locale");
  237:     strcpy(arguments[1], "charmap");
  238:     arguments[2] = NULL;
  239: 
  240:     nombre_arguments = 2;
  241: 
  242:     if (pipe(pipes_entree) != 0)
  243:     {
  244:         (*s_etat_processus).erreur_systeme = d_es_processus;
  245:         return;
  246:     }
  247:         
  248:     if (pipe(pipes_sortie) != 0)
  249:     {
  250:         (*s_etat_processus).erreur_systeme = d_es_processus;
  251:         return;
  252:     }
  253: 
  254:     if (pipe(pipes_erreur) != 0)
  255:     {
  256:         (*s_etat_processus).erreur_systeme = d_es_processus;
  257:         return;
  258:     }
  259: 
  260:     verrouillage_threads_concurrents(s_etat_processus);
  261:     pid = fork();
  262:     deverrouillage_threads_concurrents(s_etat_processus);
  263: 
  264:     if (pid < 0)
  265:     {
  266:         if (close(pipes_entree[0]) != 0)
  267:         {
  268:             (*s_etat_processus).erreur_systeme = d_es_processus;
  269:             return;
  270:         }
  271: 
  272:         if (close(pipes_entree[1]) != 0)
  273:         {
  274:             (*s_etat_processus).erreur_systeme = d_es_processus;
  275:             return;
  276:         }
  277: 
  278:         if (close(pipes_sortie[0]) != 0)
  279:         {
  280:             (*s_etat_processus).erreur_systeme = d_es_processus;
  281:             return;
  282:         }
  283: 
  284:         if (close(pipes_sortie[1]) != 0)
  285:         {
  286:             (*s_etat_processus).erreur_systeme = d_es_processus;
  287:             return;
  288:         }
  289: 
  290:         if (close(pipes_erreur[0]) != 0)
  291:         {
  292:             (*s_etat_processus).erreur_systeme = d_es_processus;
  293:             return;
  294:         }
  295: 
  296:         if (close(pipes_erreur[1]) != 0)
  297:         {
  298:             (*s_etat_processus).erreur_systeme = d_es_processus;
  299:             return;
  300:         }
  301: 
  302:         (*s_etat_processus).erreur_systeme = d_es_processus;
  303:         return;
  304:     }
  305:     else if (pid == 0)
  306:     {
  307:         if (close(pipes_entree[1]) != 0)
  308:         {
  309:             (*s_etat_processus).erreur_systeme = d_es_processus;
  310:             return;
  311:         }
  312: 
  313:         if (close(pipes_sortie[0]) != 0)
  314:         {
  315:             (*s_etat_processus).erreur_systeme = d_es_processus;
  316:             return;
  317:         }
  318: 
  319:         if (close(pipes_erreur[0]) != 0)
  320:         {
  321:             (*s_etat_processus).erreur_systeme = d_es_processus;
  322:             return;
  323:         }
  324: 
  325:         if (pipes_entree[0] != STDIN_FILENO)
  326:         {
  327:             if (dup2(pipes_entree[0], STDIN_FILENO) == -1)
  328:             {
  329:                 (*s_etat_processus).erreur_systeme = d_es_processus;
  330:                 return;
  331:             }
  332:         }
  333: 
  334:         if (pipes_sortie[1] != STDOUT_FILENO)
  335:         {
  336:             if (dup2(pipes_sortie[1], STDOUT_FILENO) == -1)
  337:             {
  338:                 (*s_etat_processus).erreur_systeme = d_es_processus;
  339:                 return;
  340:             }
  341:         }
  342: 
  343:         if (pipes_sortie[1] != STDERR_FILENO)
  344:         {
  345:             if (dup2(pipes_sortie[1], STDERR_FILENO) == -1)
  346:             {
  347:                 (*s_etat_processus).erreur_systeme = d_es_processus;
  348:                 return;
  349:             }
  350:         }
  351: 
  352:         if (nombre_arguments != 0)
  353:         {
  354:             execvp(arguments[0], arguments);
  355:         }
  356:         else
  357:         {
  358:             exit(EXIT_SUCCESS);
  359:         }
  360: 
  361:         /*
  362:          * L'appel système execvp() a généré une erreur et n'a pu exécuter
  363:          * argument[0] (fichier non exécutable ou inexistant).
  364:          */
  365: 
  366:         close(pipes_entree[0]);
  367:         close(pipes_sortie[1]);
  368: 
  369:         for(i = 0; i < nombre_arguments; i++)
  370:         {
  371:             free(arguments[i]);
  372:         }
  373: 
  374:         free(arguments);
  375:         (*s_etat_processus).erreur_systeme = d_es_processus;
  376: 
  377:         /*
  378:          * Envoi d'une erreur dans le pipe idoine. On ne regarde pas
  379:          * le nombre d'octets écrits car l'erreur ne pourra de toute
  380:          * façon pas être traitée.
  381:          */
  382: 
  383:         write_atomic(s_etat_processus, pipes_erreur[1], " ", 1);
  384:         close(pipes_erreur[1]);
  385: 
  386:         exit(EXIT_SUCCESS);
  387:     }
  388:     else
  389:     {
  390:         if (close(pipes_entree[0]) != 0)
  391:         {
  392:             (*s_etat_processus).erreur_systeme = d_es_processus;
  393:             return;
  394:         }
  395: 
  396:         if (close(pipes_sortie[1]) != 0)
  397:         {
  398:             (*s_etat_processus).erreur_systeme = d_es_processus;
  399:             return;
  400:         }
  401: 
  402:         if (close(pipes_erreur[1]) != 0)
  403:         {
  404:             (*s_etat_processus).erreur_systeme = d_es_processus;
  405:             return;
  406:         }
  407: 
  408:         if (close(pipes_entree[1]) != 0)
  409:         {
  410:             (*s_etat_processus).erreur_systeme = d_es_processus;
  411:             return;
  412:         }
  413: 
  414:         do
  415:         {
  416:             if (kill(pid, 0) != 0)
  417:             {
  418:                 break;
  419:             }
  420: 
  421:             /*
  422:              * Récupération de la valeur de retour du processus détaché
  423:              */
  424: 
  425: #           ifndef SEMAPHORES_NOMMES
  426:                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
  427: #           else
  428:                 if (sem_post((*s_etat_processus).semaphore_fork) != 0)
  429: #           endif
  430:             {
  431:                 (*s_etat_processus).erreur_systeme = d_es_processus;
  432:                 return;
  433:             }
  434: 
  435:             if (waitpid(pid, &status, 0) == -1)
  436:             {
  437: #               ifndef SEMAPHORES_NOMMES
  438:                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
  439: #               else
  440:                     while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
  441: #               endif
  442:                 {
  443:                     if (errno != EINTR)
  444:                     {
  445:                         (*s_etat_processus).erreur_systeme = d_es_processus;
  446:                         return;
  447:                     }
  448:                 }
  449: 
  450:                 (*s_etat_processus).erreur_systeme = d_es_processus;
  451:                 return;
  452:             }
  453: 
  454: #           ifndef SEMAPHORES_NOMMES
  455:                 while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
  456: #           else
  457:                 while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
  458: #           endif
  459:             {
  460:                 if (errno != EINTR)
  461:                 {
  462:                     (*s_etat_processus).erreur_systeme = d_es_processus;
  463:                     return;
  464:                 }
  465:             }
  466:         } while((!WIFEXITED(status)) && (!WIFSIGNALED(status)));
  467: 
  468:         longueur_lecture = 256;
  469:         pointeur = 0;
  470:         nombre_iterations = 1;
  471: 
  472:         if ((tampon = malloc((longueur_lecture + 1) *
  473:                 sizeof(unsigned char))) == NULL)
  474:         {
  475:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  476:             return;
  477:         }
  478: 
  479:         tampon[0] = d_code_fin_chaine;
  480: 
  481: #       ifndef SEMAPHORES_NOMMES
  482:             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
  483: #       else
  484:             if (sem_post((*s_etat_processus).semaphore_fork) != 0)
  485: #       endif
  486:         {
  487:             (*s_etat_processus).erreur_systeme = d_es_processus;
  488:             return;
  489:         }
  490: 
  491:         while((ios = read_atomic(s_etat_processus,
  492:                 pipes_sortie[0], &(tampon[pointeur]),
  493:                 longueur_lecture)) > 0)
  494:         {
  495: #           ifndef SEMAPHORES_NOMMES
  496:                 while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
  497: #           else
  498:                 while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
  499: #           endif
  500:             {
  501:                 if (errno != EINTR)
  502:                 {
  503:                     (*s_etat_processus).erreur_systeme = d_es_processus;
  504:                     return;
  505:                 }
  506:             }
  507: 
  508:             tampon[pointeur + ios] = d_code_fin_chaine;
  509:             pointeur += longueur_lecture;
  510:             nombre_iterations++;
  511: 
  512:             if ((tampon = realloc(tampon,
  513:                     ((nombre_iterations * longueur_lecture) + 1) *
  514:                     sizeof(unsigned char))) == NULL)
  515:             {
  516:                 (*s_etat_processus).erreur_systeme =
  517:                         d_es_allocation_memoire;
  518:                 return;
  519:             }
  520: 
  521: #           ifndef SEMAPHORES_NOMMES
  522:                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
  523: #           else
  524:                 if (sem_post((*s_etat_processus).semaphore_fork) != 0)
  525: #           endif
  526:             {
  527:                 (*s_etat_processus).erreur_systeme = d_es_processus;
  528:                 return;
  529:             }
  530:         }
  531: 
  532: #       ifndef SEMAPHORES_NOMMES
  533:             while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
  534: #       else
  535:             while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
  536: #       endif
  537:         {
  538:             if (errno != EINTR)
  539:             {
  540:                 (*s_etat_processus).erreur_systeme = d_es_processus;
  541:                 return;
  542:             }
  543:         }
  544: 
  545:         if (strlen(tampon) == 0)
  546:         {
  547:             (*s_etat_processus).erreur_systeme = d_es_processus;
  548:             return;
  549:         }
  550: 
  551:         tampon[strlen(tampon) - 1] = d_code_fin_chaine;
  552: 
  553:         if (ios == -1)
  554:         {
  555:             (*s_etat_processus).erreur_systeme = d_es_processus;
  556:             return;
  557:         }
  558: 
  559:         if (close(pipes_sortie[0]) != 0)
  560:         {
  561:             (*s_etat_processus).erreur_systeme = d_es_processus;
  562:             return;
  563:         }
  564: 
  565:         if (strlen(tampon) > 0)
  566:         {
  567:             (*s_etat_processus).localisation = tampon;
  568:         }
  569:         else
  570:         {
  571:             free(tampon);
  572: 
  573:             if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
  574:                     + 1) * sizeof(unsigned char))) == NULL)
  575:             {
  576:                 (*s_etat_processus).erreur_systeme = d_es_processus;
  577:                 return;
  578:             }
  579: 
  580:             strcpy((*s_etat_processus).localisation, d_locale);
  581:         }
  582: 
  583:         for(i = 0; i < nombre_arguments; i++)
  584:         {
  585:             free(arguments[i]);
  586:         }
  587: 
  588:         free(arguments);
  589: 
  590: #       ifndef SEMAPHORES_NOMMES
  591:             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
  592: #       else
  593:             if (sem_post((*s_etat_processus).semaphore_fork) != 0)
  594: #       endif
  595:         {
  596:             (*s_etat_processus).erreur_systeme = d_es_processus;
  597:             return;
  598:         }
  599: 
  600:         if (read_atomic(s_etat_processus, pipes_erreur[0], tampon, 1) > 0)
  601:         {
  602:             // Le processus fils renvoie une erreur.
  603: 
  604:             free(tampon);
  605: 
  606:             if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
  607:                     + 1) * sizeof(unsigned char))) == NULL)
  608:             {
  609:                 (*s_etat_processus).erreur_systeme = d_es_processus;
  610:                 return;
  611:             }
  612: 
  613:             strcpy((*s_etat_processus).localisation, d_locale);
  614:         }
  615: 
  616: #       ifndef SEMAPHORES_NOMMES
  617:             while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
  618: #       else
  619:             while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
  620: #       endif
  621:         {
  622:             if (errno != EINTR)
  623:             {
  624:                 (*s_etat_processus).erreur_systeme = d_es_processus;
  625:                 return;
  626:             }
  627:         }
  628: 
  629:         if (close(pipes_erreur[0]) != 0)
  630:         {
  631:             (*s_etat_processus).erreur_systeme = d_es_processus;
  632:             return;
  633:         }
  634:     }
  635: 
  636:     return;
  637: }
  638: 
  639: 
  640: int
  641: transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
  642:         const char *format, ...)
  643: {
  644:     int             ios;
  645: 
  646:     unsigned char   *tampon;
  647:     unsigned char   *tampon2;
  648: 
  649:     va_list         arguments;
  650: 
  651:     va_start(arguments, format);
  652: 
  653: #   ifdef OS2
  654:     unsigned char       *ptr_e;;
  655:     unsigned char       *ptr_l;;
  656:     unsigned char       *tampon3;
  657: 
  658:     unsigned long       i;
  659: #   endif
  660: 
  661:     if (valsprintf(&tampon, format, arguments) < 0)
  662:     {
  663:         va_end(arguments);
  664: 
  665:         if (s_etat_processus != NULL)
  666:         {
  667:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  668:         }
  669: 
  670:         return(-1);
  671:     }
  672: 
  673:     va_end(arguments);
  674: 
  675:     if (s_etat_processus != NULL)
  676:     {
  677:         if ((tampon2 = transliteration(s_etat_processus, tampon,
  678:                 d_locale, (*s_etat_processus).localisation)) == NULL)
  679:         {
  680:             free(tampon);
  681:             return(-1);
  682:         }
  683: 
  684:         free(tampon);
  685:     }
  686:     else
  687:     {
  688:         tampon2 = tampon;
  689:     }
  690: 
  691: #   ifdef OS2
  692:     if ((flux == stderr) || (flux == stdout))
  693:     {
  694:         i = 0;
  695:         ptr_l = tampon2;
  696: 
  697:         while((*ptr_l) != d_code_fin_chaine)
  698:         {
  699:             if ((*ptr_l) == '\n')
  700:             {
  701:                 i++;
  702:             }
  703: 
  704:             ptr_l++;
  705:         }
  706: 
  707:         if ((tampon3 = malloc((strlen(tampon2) + i + 1) *
  708:                 sizeof(unsigned char))) == NULL)
  709:         {
  710:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  711:             return(-1);
  712:         }
  713: 
  714:         ptr_e = tampon3;
  715:         ptr_l = tampon2;
  716: 
  717:         while((*ptr_l) != d_code_fin_chaine)
  718:         {
  719:             (*ptr_e) = (*ptr_l);
  720: 
  721:             if ((*ptr_l) == '\n')
  722:             {
  723:                 (*(++ptr_e)) = '\r';
  724:                 ptr_e++;
  725:                 ptr_l++;
  726:             }
  727:             else
  728:             {
  729:                 ptr_e++;
  730:                 ptr_l++;
  731:             }
  732:         }
  733: 
  734:         (*ptr_e) = d_code_fin_chaine;
  735: 
  736:         free(tampon2);
  737:         tampon2 = tampon3;
  738:     }
  739: #   endif
  740: 
  741: #   ifdef SunOS
  742:     while((ios = fprintf(flux, "%s", tampon2)) < 0)
  743:     {
  744:         if ((errno != EINTR) && (errno != 0))
  745:         {
  746:             break;
  747:         }
  748:     }
  749: #   else
  750:     ios = fprintf(flux, "%s", tampon2);
  751: #   endif
  752: 
  753:     free(tampon2);
  754: 
  755:     return(ios);
  756: }
  757: 
  758: 
  759: int
  760: tex_fprintf(struct_processus *s_etat_processus,
  761:         file *flux, const char *format, ...)
  762: {
  763:     int             ios;
  764: 
  765:     unsigned char   *tampon;
  766:     unsigned char   *tampon2;
  767: 
  768:     va_list         arguments;
  769: 
  770:     va_start(arguments, format);
  771: 
  772:     if (valsprintf(&tampon, format, arguments) < 0)
  773:     {
  774:         va_end(arguments);
  775: 
  776:         if (s_etat_processus != NULL)
  777:         {
  778:             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  779:         }
  780: 
  781:         return(-1);
  782:     }
  783: 
  784:     va_end(arguments);
  785: 
  786:     if ((tampon2 = transliteration(s_etat_processus, tampon,
  787:             d_locale, ds_tex_encodage_3)) == NULL)
  788:     {
  789:         free(tampon);
  790:         return(-1);
  791:     }
  792: 
  793:     free(tampon);
  794: 
  795: #   ifdef SunOS
  796:     while((ios = fprintf(flux, "%s", tampon2)) < 0)
  797:     {
  798:         if ((errno != EINTR) && (errno != 0))
  799:         {
  800:             break;
  801:         }
  802:     }
  803: #   else
  804:     ios = fprintf(flux, "%s", tampon2);
  805: #   endif
  806: 
  807:     free(tampon2);
  808: 
  809:     return(ios);
  810: }
  811: 
  812: #undef readline
  813: 
  814: unsigned char *
  815: readline_wrapper(unsigned char *invite)
  816: {
  817:     unsigned char       *chaine;
  818: 
  819:     chaine = readline(invite);
  820:     printf("\r");
  821: 
  822:     return(chaine);
  823: }
  824: 
  825: 
  826: #define fprintf NULL
  827: #define printf NULL
  828: 
  829: // vim: ts=4