1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.31
4: Copyright (C) 1989-2019 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, (const char **) &buffer_entree,
135: &longueur_entree, (char **) &pointeur, &longueur_sortie))
136: == (size_t) -1)
137: {
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)
172: {
173: free(buffer_sortie);
174: free(chaine_sortie);
175:
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:
190: (*s_etat_processus).erreur_execution = d_ex_erreur_transcodage;
191: return(NULL);
192: }
193: }
194:
195: tampon = chaine_sortie;
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: --------------------------------------------------------------------------------
222: Sorties :
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:
239: integer8 i;
240: integer8 longueur_lecture;
241: integer8 nombre_arguments;
242: integer8 nombre_iterations;
243: integer8 pointeur;
244:
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:
295: if (pid < 0)
296: {
297: if (close(pipes_entree[0]) != 0)
298: {
299: (*s_etat_processus).erreur_systeme = d_es_processus;
300: return;
301: }
302:
303: if (close(pipes_entree[1]) != 0)
304: {
305: (*s_etat_processus).erreur_systeme = d_es_processus;
306: return;
307: }
308:
309: if (close(pipes_sortie[0]) != 0)
310: {
311: (*s_etat_processus).erreur_systeme = d_es_processus;
312: return;
313: }
314:
315: if (close(pipes_sortie[1]) != 0)
316: {
317: (*s_etat_processus).erreur_systeme = d_es_processus;
318: return;
319: }
320:
321: if (close(pipes_erreur[0]) != 0)
322: {
323: (*s_etat_processus).erreur_systeme = d_es_processus;
324: return;
325: }
326:
327: if (close(pipes_erreur[1]) != 0)
328: {
329: (*s_etat_processus).erreur_systeme = d_es_processus;
330: return;
331: }
332:
333: (*s_etat_processus).erreur_systeme = d_es_processus;
334: return;
335: }
336: else if (pid == 0)
337: {
338: if (close(pipes_entree[1]) != 0)
339: {
340: (*s_etat_processus).erreur_systeme = d_es_processus;
341: return;
342: }
343:
344: if (close(pipes_sortie[0]) != 0)
345: {
346: (*s_etat_processus).erreur_systeme = d_es_processus;
347: return;
348: }
349:
350: if (close(pipes_erreur[0]) != 0)
351: {
352: (*s_etat_processus).erreur_systeme = d_es_processus;
353: return;
354: }
355:
356: if (pipes_entree[0] != STDIN_FILENO)
357: {
358: if (dup2(pipes_entree[0], STDIN_FILENO) == -1)
359: {
360: (*s_etat_processus).erreur_systeme = d_es_processus;
361: return;
362: }
363: }
364:
365: if (pipes_sortie[1] != STDOUT_FILENO)
366: {
367: if (dup2(pipes_sortie[1], STDOUT_FILENO) == -1)
368: {
369: (*s_etat_processus).erreur_systeme = d_es_processus;
370: return;
371: }
372: }
373:
374: if (pipes_sortie[1] != STDERR_FILENO)
375: {
376: if (dup2(pipes_sortie[1], STDERR_FILENO) == -1)
377: {
378: (*s_etat_processus).erreur_systeme = d_es_processus;
379: return;
380: }
381: }
382:
383: if (nombre_arguments != 0)
384: {
385: execvp(arguments[0], arguments);
386: }
387: else
388: {
389: exit(EXIT_SUCCESS);
390: }
391:
392: /*
393: * L'appel système execvp() a généré une erreur et n'a pu exécuter
394: * argument[0] (fichier non exécutable ou inexistant).
395: */
396:
397: close(pipes_entree[0]);
398: close(pipes_sortie[1]);
399:
400: for(i = 0; i < nombre_arguments; i++)
401: {
402: free(arguments[i]);
403: }
404:
405: free(arguments);
406: (*s_etat_processus).erreur_systeme = d_es_processus;
407:
408: /*
409: * Envoi d'une erreur dans le pipe idoine. On ne regarde pas
410: * le nombre d'octets écrits car l'erreur ne pourra de toute
411: * façon pas être traitée.
412: */
413:
414: write_atomic(s_etat_processus, pipes_erreur[1], " ", 1);
415: close(pipes_erreur[1]);
416:
417: exit(EXIT_SUCCESS);
418: }
419: else
420: {
421: deverrouillage_threads_concurrents(s_etat_processus);
422:
423: if (close(pipes_entree[0]) != 0)
424: {
425: (*s_etat_processus).erreur_systeme = d_es_processus;
426: return;
427: }
428:
429: if (close(pipes_sortie[1]) != 0)
430: {
431: (*s_etat_processus).erreur_systeme = d_es_processus;
432: return;
433: }
434:
435: if (close(pipes_erreur[1]) != 0)
436: {
437: (*s_etat_processus).erreur_systeme = d_es_processus;
438: return;
439: }
440:
441: if (close(pipes_entree[1]) != 0)
442: {
443: (*s_etat_processus).erreur_systeme = d_es_processus;
444: return;
445: }
446:
447: do
448: {
449: if (kill(pid, 0) != 0)
450: {
451: break;
452: }
453:
454: /*
455: * Récupération de la valeur de retour du processus détaché
456: */
457:
458: # ifndef SEMAPHORES_NOMMES
459: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
460: # else
461: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
462: # endif
463: {
464: (*s_etat_processus).erreur_systeme = d_es_processus;
465: return;
466: }
467:
468: while(waitpid(pid, &status, 0) == -1)
469: {
470: if (errno != EINTR)
471: {
472: # ifndef SEMAPHORES_NOMMES
473: while(sem_wait(&((*s_etat_processus).semaphore_fork))
474: != 0)
475: # else
476: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
477: # endif
478: {
479: if (errno != EINTR)
480: {
481: (*s_etat_processus).erreur_systeme = d_es_processus;
482: return;
483: }
484: }
485:
486: (*s_etat_processus).erreur_systeme = d_es_processus;
487: return;
488: }
489: }
490:
491: # ifndef SEMAPHORES_NOMMES
492: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
493: # else
494: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
495: # endif
496: {
497: if (errno != EINTR)
498: {
499: (*s_etat_processus).erreur_systeme = d_es_processus;
500: return;
501: }
502: }
503: } while((!WIFEXITED(status)) && (!WIFSIGNALED(status)));
504:
505: longueur_lecture = 256;
506: pointeur = 0;
507: nombre_iterations = 1;
508:
509: if ((tampon = malloc(((size_t) (longueur_lecture + 1)) *
510: sizeof(unsigned char))) == NULL)
511: {
512: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
513: return;
514: }
515:
516: tampon[0] = d_code_fin_chaine;
517:
518: # ifndef SEMAPHORES_NOMMES
519: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
520: # else
521: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
522: # endif
523: {
524: (*s_etat_processus).erreur_systeme = d_es_processus;
525: return;
526: }
527:
528: while((ios = (int) read_atomic(s_etat_processus,
529: pipes_sortie[0], &(tampon[pointeur]),
530: (size_t) longueur_lecture)) > 0)
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: tampon[pointeur + ios] = d_code_fin_chaine;
546: pointeur += longueur_lecture;
547: nombre_iterations++;
548:
549: if ((tampon = realloc(tampon,
550: ((size_t) ((nombre_iterations * longueur_lecture) + 1)) *
551: sizeof(unsigned char))) == NULL)
552: {
553: (*s_etat_processus).erreur_systeme =
554: d_es_allocation_memoire;
555: return;
556: }
557:
558: # ifndef SEMAPHORES_NOMMES
559: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
560: # else
561: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
562: # endif
563: {
564: (*s_etat_processus).erreur_systeme = d_es_processus;
565: return;
566: }
567: }
568:
569: # ifndef SEMAPHORES_NOMMES
570: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
571: # else
572: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
573: # endif
574: {
575: if (errno != EINTR)
576: {
577: (*s_etat_processus).erreur_systeme = d_es_processus;
578: return;
579: }
580: }
581:
582: if (strlen(tampon) == 0)
583: {
584: (*s_etat_processus).erreur_systeme = d_es_processus;
585: return;
586: }
587:
588: tampon[strlen(tampon) - 1] = d_code_fin_chaine;
589:
590: if (ios == -1)
591: {
592: (*s_etat_processus).erreur_systeme = d_es_processus;
593: return;
594: }
595:
596: if (close(pipes_sortie[0]) != 0)
597: {
598: (*s_etat_processus).erreur_systeme = d_es_processus;
599: return;
600: }
601:
602: if (strlen(tampon) > 0)
603: {
604: (*s_etat_processus).localisation = tampon;
605: }
606: else
607: {
608: free(tampon);
609:
610: if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
611: + 1) * sizeof(unsigned char))) == NULL)
612: {
613: (*s_etat_processus).erreur_systeme = d_es_processus;
614: return;
615: }
616:
617: strcpy((*s_etat_processus).localisation, d_locale);
618: }
619:
620: for(i = 0; i < nombre_arguments; i++)
621: {
622: free(arguments[i]);
623: }
624:
625: free(arguments);
626:
627: # ifndef SEMAPHORES_NOMMES
628: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
629: # else
630: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
631: # endif
632: {
633: (*s_etat_processus).erreur_systeme = d_es_processus;
634: return;
635: }
636:
637: if (read_atomic(s_etat_processus, pipes_erreur[0], tampon, 1) > 0)
638: {
639: // Le processus fils renvoie une erreur.
640:
641: free(tampon);
642:
643: if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
644: + 1) * sizeof(unsigned char))) == NULL)
645: {
646: (*s_etat_processus).erreur_systeme = d_es_processus;
647: return;
648: }
649:
650: strcpy((*s_etat_processus).localisation, d_locale);
651: }
652:
653: # ifndef SEMAPHORES_NOMMES
654: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
655: # else
656: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
657: # endif
658: {
659: if (errno != EINTR)
660: {
661: (*s_etat_processus).erreur_systeme = d_es_processus;
662: return;
663: }
664: }
665:
666: if (close(pipes_erreur[0]) != 0)
667: {
668: (*s_etat_processus).erreur_systeme = d_es_processus;
669: return;
670: }
671: }
672:
673: return;
674: }
675:
676:
677: int
678: transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
679: const char *format, ...)
680: {
681: int ios;
682:
683: unsigned char *tampon;
684: unsigned char *tampon2;
685:
686: va_list arguments;
687:
688: va_start(arguments, format);
689:
690: # ifdef OS2
691: unsigned char *ptr_e;;
692: unsigned char *ptr_l;;
693: unsigned char *tampon3;
694:
695: unsigned long i;
696: # endif
697:
698: if (valsprintf(s_etat_processus, &tampon, format, arguments) < 0)
699: {
700: va_end(arguments);
701:
702: if (s_etat_processus != NULL)
703: {
704: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
705: }
706:
707: return(-1);
708: }
709:
710: va_end(arguments);
711:
712: if (s_etat_processus != NULL)
713: {
714: if ((tampon2 = transliteration(s_etat_processus, tampon,
715: d_locale, (*s_etat_processus).localisation)) == NULL)
716: {
717: free(tampon);
718: return(-1);
719: }
720:
721: free(tampon);
722: }
723: else
724: {
725: tampon2 = tampon;
726: }
727:
728: # ifdef OS2
729: if ((flux == stderr) || (flux == stdout))
730: {
731: i = 0;
732: ptr_l = tampon2;
733:
734: while((*ptr_l) != d_code_fin_chaine)
735: {
736: if ((*ptr_l) == '\n')
737: {
738: i++;
739: }
740:
741: ptr_l++;
742: }
743:
744: if ((tampon3 = malloc((strlen(tampon2) + i + 1) *
745: sizeof(unsigned char))) == NULL)
746: {
747: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
748: return(-1);
749: }
750:
751: ptr_e = tampon3;
752: ptr_l = tampon2;
753:
754: while((*ptr_l) != d_code_fin_chaine)
755: {
756: (*ptr_e) = (*ptr_l);
757:
758: if ((*ptr_l) == '\n')
759: {
760: (*(++ptr_e)) = '\r';
761: ptr_e++;
762: ptr_l++;
763: }
764: else
765: {
766: ptr_e++;
767: ptr_l++;
768: }
769: }
770:
771: (*ptr_e) = d_code_fin_chaine;
772:
773: free(tampon2);
774: tampon2 = tampon3;
775: }
776: # endif
777:
778: # ifdef SunOS
779: while((ios = fprintf(flux, "%s", tampon2)) < 0)
780: {
781: if ((errno != EINTR) && (errno != 0))
782: {
783: break;
784: }
785: }
786: # else
787: ios = fprintf(flux, "%s", tampon2);
788: # endif
789:
790: free(tampon2);
791:
792: return(ios);
793: }
794:
795:
796: int
797: std_fprintf(file *flux, const char *format, ...)
798: {
799: int ios;
800:
801: va_list arguments;
802:
803: va_start(arguments, format);
804: ios = vfprintf(flux, format, arguments);
805: va_end(arguments);
806:
807: // Pas de parenthèses pour ne pas appeler la macro.
808: return ios;
809: }
810:
811:
812: int
813: tex_fprintf(struct_processus *s_etat_processus,
814: file *flux, const char *format, ...)
815: {
816: int ios;
817:
818: unsigned char *tampon;
819: unsigned char *tampon2;
820:
821: va_list arguments;
822:
823: va_start(arguments, format);
824:
825: if (valsprintf(s_etat_processus, &tampon, format, arguments) < 0)
826: {
827: va_end(arguments);
828:
829: if (s_etat_processus != NULL)
830: {
831: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
832: }
833:
834: return(-1);
835: }
836:
837: va_end(arguments);
838:
839: if ((tampon2 = transliteration(s_etat_processus, tampon,
840: d_locale, ds_tex_encodage_3)) == NULL)
841: {
842: free(tampon);
843: return(-1);
844: }
845:
846: free(tampon);
847:
848: # ifdef SunOS
849: while((ios = fprintf(flux, "%s", tampon2)) < 0)
850: {
851: if ((errno != EINTR) && (errno != 0))
852: {
853: break;
854: }
855: }
856: # else
857: ios = fprintf(flux, "%s", tampon2);
858: # endif
859:
860: free(tampon2);
861:
862: return(ios);
863: }
864:
865: #undef readline
866:
867: unsigned char *
868: readline_wrapper(struct_processus *s_etat_processus, unsigned char *invite)
869: {
870: unsigned char *rpl_chaine;
871: unsigned char *sys_chaine;
872:
873: association_etat_processus_readline(s_etat_processus);
874: sys_chaine = readline(invite);
875:
876: # ifdef OS2
877: printf("\r");
878: # endif
879:
880: if (sys_chaine == NULL)
881: {
882: return(NULL);
883: }
884:
885: if ((rpl_chaine = rpl_malloc(s_etat_processus, (strlen(sys_chaine) + 1) *
886: sizeof(unsigned char *))) == NULL)
887: {
888: sys_free(sys_chaine);
889: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
890: return(NULL);
891: }
892:
893: strcpy(rpl_chaine, sys_chaine);
894: sys_free(sys_chaine);
895:
896: return(rpl_chaine);
897: }
898:
899:
900: #define fprintf NULL
901: #define printf NULL
902:
903: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to transliteration.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src