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