1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.25
4: Copyright (C) 1989-2016 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 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: if (waitpid(pid, &status, 0) == -1)
469: {
470: # ifndef SEMAPHORES_NOMMES
471: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
472: # else
473: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
474: # endif
475: {
476: if (errno != EINTR)
477: {
478: (*s_etat_processus).erreur_systeme = d_es_processus;
479: return;
480: }
481: }
482:
483: (*s_etat_processus).erreur_systeme = d_es_processus;
484: return;
485: }
486:
487: # ifndef SEMAPHORES_NOMMES
488: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
489: # else
490: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
491: # endif
492: {
493: if (errno != EINTR)
494: {
495: (*s_etat_processus).erreur_systeme = d_es_processus;
496: return;
497: }
498: }
499: } while((!WIFEXITED(status)) && (!WIFSIGNALED(status)));
500:
501: longueur_lecture = 256;
502: pointeur = 0;
503: nombre_iterations = 1;
504:
505: if ((tampon = malloc(((size_t) (longueur_lecture + 1)) *
506: sizeof(unsigned char))) == NULL)
507: {
508: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
509: return;
510: }
511:
512: tampon[0] = d_code_fin_chaine;
513:
514: # ifndef SEMAPHORES_NOMMES
515: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
516: # else
517: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
518: # endif
519: {
520: (*s_etat_processus).erreur_systeme = d_es_processus;
521: return;
522: }
523:
524: while((ios = (int) read_atomic(s_etat_processus,
525: pipes_sortie[0], &(tampon[pointeur]),
526: (size_t) longueur_lecture)) > 0)
527: {
528: # ifndef SEMAPHORES_NOMMES
529: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
530: # else
531: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
532: # endif
533: {
534: if (errno != EINTR)
535: {
536: (*s_etat_processus).erreur_systeme = d_es_processus;
537: return;
538: }
539: }
540:
541: tampon[pointeur + ios] = d_code_fin_chaine;
542: pointeur += longueur_lecture;
543: nombre_iterations++;
544:
545: if ((tampon = realloc(tampon,
546: ((size_t) ((nombre_iterations * longueur_lecture) + 1)) *
547: sizeof(unsigned char))) == NULL)
548: {
549: (*s_etat_processus).erreur_systeme =
550: d_es_allocation_memoire;
551: return;
552: }
553:
554: # ifndef SEMAPHORES_NOMMES
555: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
556: # else
557: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
558: # endif
559: {
560: (*s_etat_processus).erreur_systeme = d_es_processus;
561: return;
562: }
563: }
564:
565: # ifndef SEMAPHORES_NOMMES
566: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
567: # else
568: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
569: # endif
570: {
571: if (errno != EINTR)
572: {
573: (*s_etat_processus).erreur_systeme = d_es_processus;
574: return;
575: }
576: }
577:
578: if (strlen(tampon) == 0)
579: {
580: (*s_etat_processus).erreur_systeme = d_es_processus;
581: return;
582: }
583:
584: tampon[strlen(tampon) - 1] = d_code_fin_chaine;
585:
586: if (ios == -1)
587: {
588: (*s_etat_processus).erreur_systeme = d_es_processus;
589: return;
590: }
591:
592: if (close(pipes_sortie[0]) != 0)
593: {
594: (*s_etat_processus).erreur_systeme = d_es_processus;
595: return;
596: }
597:
598: if (strlen(tampon) > 0)
599: {
600: (*s_etat_processus).localisation = tampon;
601: }
602: else
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: for(i = 0; i < nombre_arguments; i++)
617: {
618: free(arguments[i]);
619: }
620:
621: free(arguments);
622:
623: # ifndef SEMAPHORES_NOMMES
624: if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
625: # else
626: if (sem_post((*s_etat_processus).semaphore_fork) != 0)
627: # endif
628: {
629: (*s_etat_processus).erreur_systeme = d_es_processus;
630: return;
631: }
632:
633: if (read_atomic(s_etat_processus, pipes_erreur[0], tampon, 1) > 0)
634: {
635: // Le processus fils renvoie une erreur.
636:
637: free(tampon);
638:
639: if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
640: + 1) * sizeof(unsigned char))) == NULL)
641: {
642: (*s_etat_processus).erreur_systeme = d_es_processus;
643: return;
644: }
645:
646: strcpy((*s_etat_processus).localisation, d_locale);
647: }
648:
649: # ifndef SEMAPHORES_NOMMES
650: while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
651: # else
652: while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
653: # endif
654: {
655: if (errno != EINTR)
656: {
657: (*s_etat_processus).erreur_systeme = d_es_processus;
658: return;
659: }
660: }
661:
662: if (close(pipes_erreur[0]) != 0)
663: {
664: (*s_etat_processus).erreur_systeme = d_es_processus;
665: return;
666: }
667: }
668:
669: return;
670: }
671:
672:
673: int
674: transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
675: const char *format, ...)
676: {
677: int ios;
678:
679: unsigned char *tampon;
680: unsigned char *tampon2;
681:
682: va_list arguments;
683:
684: va_start(arguments, format);
685:
686: # ifdef OS2
687: unsigned char *ptr_e;;
688: unsigned char *ptr_l;;
689: unsigned char *tampon3;
690:
691: unsigned long i;
692: # endif
693:
694: if (valsprintf(s_etat_processus, &tampon, format, arguments) < 0)
695: {
696: va_end(arguments);
697:
698: if (s_etat_processus != NULL)
699: {
700: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
701: }
702:
703: return(-1);
704: }
705:
706: va_end(arguments);
707:
708: if (s_etat_processus != NULL)
709: {
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:
724: # ifdef OS2
725: if ((flux == stderr) || (flux == stdout))
726: {
727: i = 0;
728: ptr_l = tampon2;
729:
730: while((*ptr_l) != d_code_fin_chaine)
731: {
732: if ((*ptr_l) == '\n')
733: {
734: i++;
735: }
736:
737: ptr_l++;
738: }
739:
740: if ((tampon3 = malloc((strlen(tampon2) + i + 1) *
741: sizeof(unsigned char))) == NULL)
742: {
743: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
744: return(-1);
745: }
746:
747: ptr_e = tampon3;
748: ptr_l = tampon2;
749:
750: while((*ptr_l) != d_code_fin_chaine)
751: {
752: (*ptr_e) = (*ptr_l);
753:
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: }
765: }
766:
767: (*ptr_e) = d_code_fin_chaine;
768:
769: free(tampon2);
770: tampon2 = tampon3;
771: }
772: # endif
773:
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:
791:
792: int
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:
803: // Pas de parenthèses pour ne pas appeler la macro.
804: return ios;
805: }
806:
807:
808: int
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:
821: if (valsprintf(s_etat_processus, &tampon, format, arguments) < 0)
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:
861: #undef readline
862:
863: unsigned char *
864: readline_wrapper(struct_processus *s_etat_processus, unsigned char *invite)
865: {
866: unsigned char *rpl_chaine;
867: unsigned char *sys_chaine;
868:
869: association_etat_processus_readline(s_etat_processus);
870: sys_chaine = readline(invite);
871:
872: # ifdef OS2
873: printf("\r");
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);
891:
892: return(rpl_chaine);
893: }
894:
895:
896: #define fprintf NULL
897: #define printf NULL
898:
899: // 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