Annotation of rpl/src/transliteration.c, revision 1.82
1.1 bertrand 1: /*
2: ================================================================================
1.80 bertrand 3: RPL/2 (R) version 4.1.21
1.77 bertrand 4: Copyright (C) 1989-2015 Dr. BERTRAND Joël
1.1 bertrand 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:
1.14 bertrand 23: #include "rpl-conv.h"
24: #include "tex-conv.h"
1.5 bertrand 25:
1.1 bertrand 26: #include <stdarg.h>
1.5 bertrand 27:
1.1 bertrand 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: {
1.59 bertrand 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:
1.1 bertrand 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:
1.39 bertrand 122: if ((buffer_sortie = malloc((d_LONGUEUR + 1) * sizeof(unsigned char)))
123: == NULL)
1.1 bertrand 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:
1.68 bertrand 134: if ((ios = iconv(transcodage, (char **) &buffer_entree,
1.1 bertrand 135: &longueur_entree, (char **) &pointeur, &longueur_sortie))
136: == (size_t) -1)
137: {
1.65 bertrand 138: // On autorise les erreurs EINVAL si le caractère suivant est non
139: // nul : la séquence d'entrée est continue sur le bloc suivant.
140:
141: if (errno == EINVAL)
142: {
143: if ((*(buffer_entree + 1)) == d_code_fin_chaine)
144: {
145: free(buffer_sortie);
146: free(chaine_sortie);
147:
148: // On affiche une erreur ici car la fonction d'affichage
149: // de l'erreur utilise la macro printf() donc une
150: // opération de translitération qui échouera elle aussi.
151: // Le positionnement de l'erreur permet de sortir du
152: // programme.
153:
154: if ((*s_etat_processus).langue == 'F')
155: {
156: fprintf(stderr, "+++Erreur : Erreur de transcodage\n");
157: }
158: else
159: {
160: fprintf(stderr, "+++Error : Transcodage error\n");
161: }
162:
163: (*s_etat_processus).erreur_execution =
164: d_ex_erreur_transcodage;
165: return(NULL);
166: }
167: }
168:
169: // Si la séquence d'entrée est invalide, on reçoit une erreur
170: // EILSEQ.
171: else if (errno == EILSEQ)
1.1 bertrand 172: {
173: free(buffer_sortie);
1.3 bertrand 174: free(chaine_sortie);
175:
1.59 bertrand 176: // On affiche une erreur ici car la fonction d'affichage
177: // de l'erreur utilise la macro printf() donc une
178: // opération de translitération qui échouera elle aussi.
179: // Le positionnement de l'erreur permet de sortir du programme.
180:
181: if ((*s_etat_processus).langue == 'F')
182: {
183: fprintf(stderr, "+++Erreur : Erreur de transcodage\n");
184: }
185: else
186: {
187: fprintf(stderr, "+++Error : Transcodage error\n");
188: }
189:
1.1 bertrand 190: (*s_etat_processus).erreur_execution = d_ex_erreur_transcodage;
191: return(NULL);
192: }
193: }
194:
1.38 bertrand 195: tampon = chaine_sortie;
1.1 bertrand 196: (*pointeur) = d_code_fin_chaine;
197:
198: if ((chaine_sortie = malloc((strlen(tampon) + strlen(buffer_sortie) + 1)
199: * sizeof(unsigned char))) == NULL)
200: {
201: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
202: return(NULL);
203: }
204:
205: sprintf(chaine_sortie, "%s%s", tampon, buffer_sortie);
206: free(tampon);
207: } while((*buffer_entree) != d_code_fin_chaine);
208:
209: free(buffer_sortie);
210: iconv_close(transcodage);
211:
212: return(chaine_sortie);
213: }
214:
215:
216: /*
217: ================================================================================
218: Fonctions spécifiques
219: ================================================================================
220: Entrées :
221: --------------------------------------------------------------------------------
1.26 bertrand 222: Sorties :
1.1 bertrand 223: --------------------------------------------------------------------------------
224: Effets de bord : néant
225: ================================================================================
226: */
227:
228: void
229: localisation_courante(struct_processus *s_etat_processus)
230: {
231: char **arguments;
232:
233: int ios;
234: int pipes_entree[2];
235: int pipes_erreur[2];
236: int pipes_sortie[2];
237: int status;
238:
1.69 bertrand 239: integer8 i;
240: integer8 longueur_lecture;
241: integer8 nombre_arguments;
242: integer8 nombre_iterations;
243: integer8 pointeur;
244:
1.1 bertrand 245:
246: pid_t pid;
247:
248: unsigned char *tampon;
249:
250: if ((arguments = malloc(3 * sizeof(char **))) == NULL)
251: {
252: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
253: return;
254: }
255:
256: if ((arguments[0] = malloc((strlen("locale") + 1) * sizeof(char))) == NULL)
257: {
258: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
259: return;
260: }
261:
262: if ((arguments[1] = malloc((strlen("charmap") + 1) * sizeof(char))) == NULL)
263: {
264: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
265: return;
266: }
267:
268: strcpy(arguments[0], "locale");
269: strcpy(arguments[1], "charmap");
270: arguments[2] = NULL;
271:
272: nombre_arguments = 2;
273:
274: if (pipe(pipes_entree) != 0)
275: {
276: (*s_etat_processus).erreur_systeme = d_es_processus;
277: return;
278: }
279:
280: if (pipe(pipes_sortie) != 0)
281: {
282: (*s_etat_processus).erreur_systeme = d_es_processus;
283: return;
284: }
285:
286: if (pipe(pipes_erreur) != 0)
287: {
288: (*s_etat_processus).erreur_systeme = d_es_processus;
289: return;
290: }
291:
292: verrouillage_threads_concurrents(s_etat_processus);
293: pid = fork();
294: deverrouillage_threads_concurrents(s_etat_processus);
295:
296: if (pid < 0)
297: {
298: if (close(pipes_entree[0]) != 0)
299: {
300: (*s_etat_processus).erreur_systeme = d_es_processus;
301: return;
302: }
303:
304: if (close(pipes_entree[1]) != 0)
305: {
306: (*s_etat_processus).erreur_systeme = d_es_processus;
307: return;
308: }
309:
310: if (close(pipes_sortie[0]) != 0)
311: {
312: (*s_etat_processus).erreur_systeme = d_es_processus;
313: return;
314: }
315:
316: if (close(pipes_sortie[1]) != 0)
317: {
318: (*s_etat_processus).erreur_systeme = d_es_processus;
319: return;
320: }
321:
322: if (close(pipes_erreur[0]) != 0)
323: {
324: (*s_etat_processus).erreur_systeme = d_es_processus;
325: return;
326: }
327:
328: if (close(pipes_erreur[1]) != 0)
329: {
330: (*s_etat_processus).erreur_systeme = d_es_processus;
331: return;
332: }
333:
334: (*s_etat_processus).erreur_systeme = d_es_processus;
335: return;
336: }
337: else if (pid == 0)
338: {
339: if (close(pipes_entree[1]) != 0)
340: {
341: (*s_etat_processus).erreur_systeme = d_es_processus;
342: return;
343: }
344:
345: if (close(pipes_sortie[0]) != 0)
346: {
347: (*s_etat_processus).erreur_systeme = d_es_processus;
348: return;
349: }
350:
351: if (close(pipes_erreur[0]) != 0)
352: {
353: (*s_etat_processus).erreur_systeme = d_es_processus;
354: return;
355: }
356:
357: if (pipes_entree[0] != STDIN_FILENO)
358: {
359: if (dup2(pipes_entree[0], STDIN_FILENO) == -1)
360: {
361: (*s_etat_processus).erreur_systeme = d_es_processus;
362: return;
363: }
364: }
365:
366: if (pipes_sortie[1] != STDOUT_FILENO)
367: {
368: if (dup2(pipes_sortie[1], STDOUT_FILENO) == -1)
369: {
370: (*s_etat_processus).erreur_systeme = d_es_processus;
371: return;
372: }
373: }
374:
375: if (pipes_sortie[1] != STDERR_FILENO)
376: {
377: if (dup2(pipes_sortie[1], STDERR_FILENO) == -1)
378: {
379: (*s_etat_processus).erreur_systeme = d_es_processus;
380: return;
381: }
382: }
383:
384: if (nombre_arguments != 0)
385: {
386: execvp(arguments[0], arguments);
387: }
388: else
389: {
390: exit(EXIT_SUCCESS);
391: }
392:
393: /*
394: * L'appel système execvp() a généré une erreur et n'a pu exécuter
395: * argument[0] (fichier non exécutable ou inexistant).
396: */
397:
398: close(pipes_entree[0]);
399: close(pipes_sortie[1]);
400:
401: for(i = 0; i < nombre_arguments; i++)
402: {
403: free(arguments[i]);
404: }
405:
406: free(arguments);
407: (*s_etat_processus).erreur_systeme = d_es_processus;
408:
409: /*
410: * Envoi d'une erreur dans le pipe idoine. On ne regarde pas
411: * le nombre d'octets écrits car l'erreur ne pourra de toute
412: * façon pas être traitée.
413: */
414:
415: write_atomic(s_etat_processus, pipes_erreur[1], " ", 1);
416: close(pipes_erreur[1]);
417:
418: exit(EXIT_SUCCESS);
419: }
420: else
421: {
422: if (close(pipes_entree[0]) != 0)
423: {
424: (*s_etat_processus).erreur_systeme = d_es_processus;
425: return;
426: }
427:
428: if (close(pipes_sortie[1]) != 0)
429: {
430: (*s_etat_processus).erreur_systeme = d_es_processus;
431: return;
432: }
433:
434: if (close(pipes_erreur[1]) != 0)
435: {
436: (*s_etat_processus).erreur_systeme = d_es_processus;
437: return;
438: }
439:
440: if (close(pipes_entree[1]) != 0)
441: {
442: (*s_etat_processus).erreur_systeme = d_es_processus;
443: return;
444: }
445:
446: do
447: {
448: if (kill(pid, 0) != 0)
449: {
450: break;
451: }
452:
453: /*
454: * Récupération de la valeur de retour du processus détaché
455: */
456:
1.44 bertrand 457: # ifndef SEMAPHORES_NOMMES
458: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
459: # else
460: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
461: # endif
1.1 bertrand 462: {
463: (*s_etat_processus).erreur_systeme = d_es_processus;
464: return;
465: }
466:
467: if (waitpid(pid, &status, 0) == -1)
468: {
1.44 bertrand 469: # ifndef SEMAPHORES_NOMMES
470: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
471: # else
472: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
473: # endif
1.1 bertrand 474: {
1.43 bertrand 475: if (errno != EINTR)
476: {
477: (*s_etat_processus).erreur_systeme = d_es_processus;
478: return;
479: }
1.1 bertrand 480: }
481:
482: (*s_etat_processus).erreur_systeme = d_es_processus;
483: return;
484: }
485:
1.44 bertrand 486: # ifndef SEMAPHORES_NOMMES
487: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
488: # else
489: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
490: # endif
1.1 bertrand 491: {
1.43 bertrand 492: if (errno != EINTR)
493: {
494: (*s_etat_processus).erreur_systeme = d_es_processus;
495: return;
496: }
1.1 bertrand 497: }
498: } while((!WIFEXITED(status)) && (!WIFSIGNALED(status)));
499:
500: longueur_lecture = 256;
501: pointeur = 0;
502: nombre_iterations = 1;
503:
1.69 bertrand 504: if ((tampon = malloc(((size_t) (longueur_lecture + 1)) *
1.1 bertrand 505: sizeof(unsigned char))) == NULL)
506: {
507: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
508: return;
509: }
510:
1.18 bertrand 511: tampon[0] = d_code_fin_chaine;
512:
1.44 bertrand 513: # ifndef SEMAPHORES_NOMMES
514: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
515: # else
516: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
517: # endif
1.1 bertrand 518: {
519: (*s_etat_processus).erreur_systeme = d_es_processus;
520: return;
521: }
522:
1.69 bertrand 523: while((ios = (int) read_atomic(s_etat_processus,
1.1 bertrand 524: pipes_sortie[0], &(tampon[pointeur]),
1.69 bertrand 525: (size_t) longueur_lecture)) > 0)
1.1 bertrand 526: {
1.44 bertrand 527: # ifndef SEMAPHORES_NOMMES
528: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
529: # else
530: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
531: # endif
1.1 bertrand 532: {
1.43 bertrand 533: if (errno != EINTR)
534: {
535: (*s_etat_processus).erreur_systeme = d_es_processus;
536: return;
537: }
1.1 bertrand 538: }
539:
540: tampon[pointeur + ios] = d_code_fin_chaine;
541: pointeur += longueur_lecture;
542: nombre_iterations++;
543:
544: if ((tampon = realloc(tampon,
1.69 bertrand 545: ((size_t) ((nombre_iterations * longueur_lecture) + 1)) *
1.1 bertrand 546: sizeof(unsigned char))) == NULL)
547: {
548: (*s_etat_processus).erreur_systeme =
549: d_es_allocation_memoire;
550: return;
551: }
552:
1.44 bertrand 553: # ifndef SEMAPHORES_NOMMES
554: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
555: # else
556: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
557: # endif
1.1 bertrand 558: {
559: (*s_etat_processus).erreur_systeme = d_es_processus;
560: return;
561: }
562: }
563:
1.44 bertrand 564: # ifndef SEMAPHORES_NOMMES
565: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
566: # else
567: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
568: # endif
1.1 bertrand 569: {
1.43 bertrand 570: if (errno != EINTR)
571: {
572: (*s_etat_processus).erreur_systeme = d_es_processus;
573: return;
574: }
1.1 bertrand 575: }
576:
577: if (strlen(tampon) == 0)
578: {
579: (*s_etat_processus).erreur_systeme = d_es_processus;
580: return;
581: }
582:
583: tampon[strlen(tampon) - 1] = d_code_fin_chaine;
584:
585: if (ios == -1)
586: {
587: (*s_etat_processus).erreur_systeme = d_es_processus;
588: return;
589: }
590:
591: if (close(pipes_sortie[0]) != 0)
592: {
593: (*s_etat_processus).erreur_systeme = d_es_processus;
594: return;
595: }
596:
1.17 bertrand 597: if (strlen(tampon) > 0)
598: {
599: (*s_etat_processus).localisation = tampon;
600: }
601: else
602: {
603: free(tampon);
604:
605: if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
606: + 1) * sizeof(unsigned char))) == NULL)
607: {
608: (*s_etat_processus).erreur_systeme = d_es_processus;
609: return;
610: }
611:
612: strcpy((*s_etat_processus).localisation, d_locale);
613: }
1.1 bertrand 614:
615: for(i = 0; i < nombre_arguments; i++)
616: {
617: free(arguments[i]);
618: }
619:
620: free(arguments);
621:
1.44 bertrand 622: # ifndef SEMAPHORES_NOMMES
623: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
624: # else
625: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
626: # endif
1.1 bertrand 627: {
628: (*s_etat_processus).erreur_systeme = d_es_processus;
629: return;
630: }
631:
632: if (read_atomic(s_etat_processus, pipes_erreur[0], tampon, 1) > 0)
633: {
634: // Le processus fils renvoie une erreur.
635:
1.18 bertrand 636: free(tampon);
637:
638: if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
639: + 1) * sizeof(unsigned char))) == NULL)
1.1 bertrand 640: {
1.18 bertrand 641: (*s_etat_processus).erreur_systeme = d_es_processus;
642: return;
1.1 bertrand 643: }
644:
1.18 bertrand 645: strcpy((*s_etat_processus).localisation, d_locale);
1.1 bertrand 646: }
647:
1.44 bertrand 648: # ifndef SEMAPHORES_NOMMES
649: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
650: # else
651: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
652: # endif
1.1 bertrand 653: {
1.43 bertrand 654: if (errno != EINTR)
655: {
656: (*s_etat_processus).erreur_systeme = d_es_processus;
657: return;
658: }
1.1 bertrand 659: }
660:
661: if (close(pipes_erreur[0]) != 0)
662: {
663: (*s_etat_processus).erreur_systeme = d_es_processus;
664: return;
665: }
666: }
667:
668: return;
669: }
670:
671:
672: int
673: transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
674: const char *format, ...)
675: {
676: int ios;
1.5 bertrand 677:
678: unsigned char *tampon;
1.1 bertrand 679: unsigned char *tampon2;
1.5 bertrand 680:
1.1 bertrand 681: va_list arguments;
682:
683: va_start(arguments, format);
684:
1.17 bertrand 685: # ifdef OS2
686: unsigned char *ptr_e;;
687: unsigned char *ptr_l;;
688: unsigned char *tampon3;
689:
690: unsigned long i;
691: # endif
692:
1.79 bertrand 693: if (valsprintf(s_etat_processus, &tampon, format, arguments) < 0)
1.1 bertrand 694: {
695: va_end(arguments);
696:
697: if (s_etat_processus != NULL)
698: {
699: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
700: }
701:
702: return(-1);
703: }
704:
705: va_end(arguments);
706:
707: if (s_etat_processus != NULL)
708: {
1.82 ! bertrand 709: uprintf("%s->%s\n", d_locale, (*s_etat_processus).localisation);
1.1 bertrand 710: if ((tampon2 = transliteration(s_etat_processus, tampon,
711: d_locale, (*s_etat_processus).localisation)) == NULL)
712: {
713: free(tampon);
714: return(-1);
715: }
716:
717: free(tampon);
718: }
719: else
720: {
721: tampon2 = tampon;
722: }
723:
1.17 bertrand 724: # ifdef OS2
1.46 bertrand 725: if ((flux == stderr) || (flux == stdout))
1.23 bertrand 726: {
727: i = 0;
728: ptr_l = tampon2;
1.17 bertrand 729:
1.23 bertrand 730: while((*ptr_l) != d_code_fin_chaine)
1.17 bertrand 731: {
1.23 bertrand 732: if ((*ptr_l) == '\n')
733: {
734: i++;
735: }
736:
737: ptr_l++;
1.17 bertrand 738: }
739:
1.23 bertrand 740: if ((tampon3 = malloc((strlen(tampon2) + i + 1) *
741: sizeof(unsigned char))) == NULL)
742: {
743: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1.46 bertrand 744: return(-1);
1.23 bertrand 745: }
1.17 bertrand 746:
1.23 bertrand 747: ptr_e = tampon3;
748: ptr_l = tampon2;
1.17 bertrand 749:
1.23 bertrand 750: while((*ptr_l) != d_code_fin_chaine)
751: {
752: (*ptr_e) = (*ptr_l);
1.17 bertrand 753:
1.23 bertrand 754: if ((*ptr_l) == '\n')
755: {
756: (*(++ptr_e)) = '\r';
757: ptr_e++;
758: ptr_l++;
759: }
760: else
761: {
762: ptr_e++;
763: ptr_l++;
764: }
1.17 bertrand 765: }
766:
1.23 bertrand 767: (*ptr_e) = d_code_fin_chaine;
1.17 bertrand 768:
1.23 bertrand 769: free(tampon2);
770: tampon2 = tampon3;
771: }
1.17 bertrand 772: # endif
773:
1.1 bertrand 774: # ifdef SunOS
775: while((ios = fprintf(flux, "%s", tampon2)) < 0)
776: {
777: if ((errno != EINTR) && (errno != 0))
778: {
779: break;
780: }
781: }
782: # else
783: ios = fprintf(flux, "%s", tampon2);
784: # endif
785:
786: free(tampon2);
787:
788: return(ios);
789: }
790:
1.5 bertrand 791:
792: int
1.79 bertrand 793: std_fprintf(file *flux, const char *format, ...)
794: {
795: int ios;
796:
797: va_list arguments;
798:
799: va_start(arguments, format);
800: ios = vfprintf(flux, format, arguments);
801: va_end(arguments);
802:
1.81 bertrand 803: // Pas de parenthèses pour ne pas appeler la macro.
804: return ios;
1.79 bertrand 805: }
806:
807:
808: int
1.5 bertrand 809: tex_fprintf(struct_processus *s_etat_processus,
810: file *flux, const char *format, ...)
811: {
812: int ios;
813:
814: unsigned char *tampon;
815: unsigned char *tampon2;
816:
817: va_list arguments;
818:
819: va_start(arguments, format);
820:
1.79 bertrand 821: if (valsprintf(s_etat_processus, &tampon, format, arguments) < 0)
1.5 bertrand 822: {
823: va_end(arguments);
824:
825: if (s_etat_processus != NULL)
826: {
827: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
828: }
829:
830: return(-1);
831: }
832:
833: va_end(arguments);
834:
835: if ((tampon2 = transliteration(s_etat_processus, tampon,
836: d_locale, ds_tex_encodage_3)) == NULL)
837: {
838: free(tampon);
839: return(-1);
840: }
841:
842: free(tampon);
843:
844: # ifdef SunOS
845: while((ios = fprintf(flux, "%s", tampon2)) < 0)
846: {
847: if ((errno != EINTR) && (errno != 0))
848: {
849: break;
850: }
851: }
852: # else
853: ios = fprintf(flux, "%s", tampon2);
854: # endif
855:
856: free(tampon2);
857:
858: return(ios);
859: }
860:
1.21 bertrand 861: #undef readline
1.19 bertrand 862:
863: unsigned char *
1.79 bertrand 864: readline_wrapper(struct_processus *s_etat_processus, unsigned char *invite)
1.19 bertrand 865: {
1.79 bertrand 866: unsigned char *rpl_chaine;
867: unsigned char *sys_chaine;
868:
869: association_etat_processus_readline(s_etat_processus);
870: sys_chaine = readline(invite);
1.19 bertrand 871:
1.79 bertrand 872: # ifdef OS2
1.19 bertrand 873: printf("\r");
1.79 bertrand 874: # endif
875:
876: if (sys_chaine == NULL)
877: {
878: return(NULL);
879: }
880:
881: if ((rpl_chaine = rpl_malloc(s_etat_processus, (strlen(sys_chaine) + 1) *
882: sizeof(unsigned char *))) == NULL)
883: {
884: sys_free(sys_chaine);
885: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
886: return(NULL);
887: }
888:
889: strcpy(rpl_chaine, sys_chaine);
890: sys_free(sys_chaine);
1.19 bertrand 891:
1.79 bertrand 892: return(rpl_chaine);
1.19 bertrand 893: }
894:
895:
1.1 bertrand 896: #define fprintf NULL
897: #define printf NULL
898:
899: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>