rpl/src/transliteration.c - diff

Return to transliteration.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/transliteration.c between versions 1.17 and 1.100

version 1.17, 2010/08/13 21:00:37	version 1.100, 2019/02/09 13:36:43
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.18	RPL/2 (R) version 4.1.31
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2019 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.

Line 90 reencodage(struct_processus *s_etat_proc	Line 90 reencodage(struct_processus *s_etat_proc
if ((transcodage = iconv_open(codage_sortie, codage_entree)) ==	if ((transcodage = iconv_open(codage_sortie, codage_entree)) ==
(iconv_t) -1)	(iconv_t) -1)
{	{
	// On affiche une erreur ici car la fonction d'affichage
	// de l'erreur utilise la macro printf() donc une
	// opération de translitération qui échouera elle aussi.
	// Le positionnement de l'erreur permet de sortir du programme.

	if ((*s_etat_processus).langue == 'F')
	{
	fprintf(stderr, "+++Erreur : Erreur de transcodage\n");
	}
	else
	{
	fprintf(stderr, "+++Error : Transcodage error\n");
	}

(*s_etat_processus).erreur_execution = d_ex_erreur_transcodage;	(*s_etat_processus).erreur_execution = d_ex_erreur_transcodage;
return(NULL);	return(NULL);
}	}
Line 105 reencodage(struct_processus *s_etat_proc	Line 119 reencodage(struct_processus *s_etat_proc

chaine_sortie[0] = d_code_fin_chaine;	chaine_sortie[0] = d_code_fin_chaine;

if ((buffer_sortie = malloc((d_LONGUEUR + 1) * sizeof(char))) == NULL)	if ((buffer_sortie = malloc((d_LONGUEUR + 1) * sizeof(unsigned char)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 116 reencodage(struct_processus *s_etat_proc	Line 131 reencodage(struct_processus *s_etat_proc
longueur_sortie = d_LONGUEUR;	longueur_sortie = d_LONGUEUR;
pointeur = buffer_sortie;	pointeur = buffer_sortie;

if ((ios = iconv(transcodage, (char **) &buffer_entree,	if ((ios = iconv(transcodage,
	# if defined(Linux)
	(char **)
	# elif defined(NetBSD)
	(const char **)
	# else
	(char **)
	# endif
	&buffer_entree,
&longueur_entree, (char **) &pointeur, &longueur_sortie))	&longueur_entree, (char **) &pointeur, &longueur_sortie))
== (size_t) -1)	== (size_t) -1)
{	{
// On autorise les erreurs EINVAL et EILSEQ	// On autorise les erreurs EINVAL si le caractère suivant est non
if (errno == EILSEQ)	// nul : la séquence d'entrée est continue sur le bloc suivant.

	if (errno == EINVAL)
	{
	if ((*(buffer_entree + 1)) == d_code_fin_chaine)
	{
	free(buffer_sortie);
	free(chaine_sortie);

	// On affiche une erreur ici car la fonction d'affichage
	// de l'erreur utilise la macro printf() donc une
	// opération de translitération qui échouera elle aussi.
	// Le positionnement de l'erreur permet de sortir du
	// programme.

	if ((*s_etat_processus).langue == 'F')
	{
	fprintf(stderr, "+++Erreur : Erreur de transcodage\n");
	}
	else
	{
	fprintf(stderr, "+++Error : Transcodage error\n");
	}

	(*s_etat_processus).erreur_execution =
	d_ex_erreur_transcodage;
	return(NULL);
	}
	}

	// Si la séquence d'entrée est invalide, on reçoit une erreur
	// EILSEQ.
	else if (errno == EILSEQ)
{	{
free(buffer_sortie);	free(buffer_sortie);
free(chaine_sortie);	free(chaine_sortie);

	// On affiche une erreur ici car la fonction d'affichage
	// de l'erreur utilise la macro printf() donc une
	// opération de translitération qui échouera elle aussi.
	// Le positionnement de l'erreur permet de sortir du programme.

	if ((*s_etat_processus).langue == 'F')
	{
	fprintf(stderr, "+++Erreur : Erreur de transcodage\n");
	}
	else
	{
	fprintf(stderr, "+++Error : Transcodage error\n");
	}

(*s_etat_processus).erreur_execution = d_ex_erreur_transcodage;	(*s_etat_processus).erreur_execution = d_ex_erreur_transcodage;
return(NULL);	return(NULL);
}	}
}	}

tampon = (unsigned char *) chaine_sortie;	tampon = chaine_sortie;
(*pointeur) = d_code_fin_chaine;	(*pointeur) = d_code_fin_chaine;

if ((chaine_sortie = malloc((strlen(tampon) + strlen(buffer_sortie) + 1)	if ((chaine_sortie = malloc((strlen(tampon) + strlen(buffer_sortie) + 1)
Line 158 reencodage(struct_processus *s_etat_proc	Line 227 reencodage(struct_processus *s_etat_proc
================================================================================	================================================================================
Entrées :	Entrées :
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
	Sorties :
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
iorties :
Effets de bord : néant	Effets de bord : néant
================================================================================	================================================================================
*/	*/
Line 175 localisation_courante(struct_processus *	Line 244 localisation_courante(struct_processus *
int pipes_sortie[2];	int pipes_sortie[2];
int status;	int status;

logical1 drapeau_fin;	integer8 i;
	integer8 longueur_lecture;
	integer8 nombre_arguments;
	integer8 nombre_iterations;
	integer8 pointeur;

long i;
long nombre_arguments;

pid_t pid;	pid_t pid;

sigset_t oldset;
sigset_t set;

struct sigaction action_passee;

unsigned char *tampon;	unsigned char *tampon;

unsigned long longueur_lecture;
unsigned long nombre_iterations;
unsigned long pointeur;

if ((arguments = malloc(3 * sizeof(char **))) == NULL)	if ((arguments = malloc(3 * sizeof(char **))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 216 localisation_courante(struct_processus *	Line 278 localisation_courante(struct_processus *
arguments[2] = NULL;	arguments[2] = NULL;

nombre_arguments = 2;	nombre_arguments = 2;
drapeau_fin = d_faux;

if (pipe(pipes_entree) != 0)	if (pipe(pipes_entree) != 0)
{	{
Line 236 localisation_courante(struct_processus *	Line 297 localisation_courante(struct_processus *
return;	return;
}	}

sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);

verrouillage_threads_concurrents(s_etat_processus);	verrouillage_threads_concurrents(s_etat_processus);
pid = fork();	pid = fork();

# ifdef OS2
if (pid == 0)
{
sem_init(&semaphore_liste_threads, 0, 1);
sem_init(&semaphore_gestionnaires_signaux, 0, 0);
sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
}
# endif

deverrouillage_threads_concurrents(s_etat_processus);

pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

if (pid < 0)	if (pid < 0)
{	{
if (close(pipes_entree[0]) != 0)	if (close(pipes_entree[0]) != 0)
Line 383 localisation_courante(struct_processus *	Line 426 localisation_courante(struct_processus *
}	}
else	else
{	{
	deverrouillage_threads_concurrents(s_etat_processus);

if (close(pipes_entree[0]) != 0)	if (close(pipes_entree[0]) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 419 localisation_courante(struct_processus *	Line 464 localisation_courante(struct_processus *
*/	*/

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
if (sem_post((*s_etat_processus).semaphore_fork) != 0)	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
# endif	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

if (waitpid(pid, &status, 0) == -1)	while(waitpid(pid, &status, 0) == -1)
{	{
# ifndef SEMAPHORES_NOMMES	if (errno != EINTR)
if (sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else
if (sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	# ifndef SEMAPHORES_NOMMES
	while(sem_wait(&((*s_etat_processus).semaphore_fork))
	!= 0)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	if (errno != EINTR)
return;	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
}	}
}

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
	}
}	}

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
if (sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
if (sem_wait((*s_etat_processus).semaphore_fork) == -1)	while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
# endif	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
Line 465 localisation_courante(struct_processus *	Line 514 localisation_courante(struct_processus *
pointeur = 0;	pointeur = 0;
nombre_iterations = 1;	nombre_iterations = 1;

if ((tampon = malloc((longueur_lecture + 1) *	if ((tampon = malloc(((size_t) (longueur_lecture + 1)) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

	tampon[0] = d_code_fin_chaine;

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
if (sem_post((*s_etat_processus).semaphore_fork) != 0)	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
# endif	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

while((ios = read_atomic(s_etat_processus,	while((ios = (int) read_atomic(s_etat_processus,
pipes_sortie[0], &(tampon[pointeur]),	pipes_sortie[0], &(tampon[pointeur]),
longueur_lecture)) > 0)	(size_t) longueur_lecture)) > 0)
{	{
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)	while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
# endif	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
Line 504 localisation_courante(struct_processus *	Line 555 localisation_courante(struct_processus *
nombre_iterations++;	nombre_iterations++;

if ((tampon = realloc(tampon,	if ((tampon = realloc(tampon,
((nombre_iterations * longueur_lecture) + 1) *	((size_t) ((nombre_iterations * longueur_lecture) + 1)) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 513 localisation_courante(struct_processus *	Line 564 localisation_courante(struct_processus *
}	}

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
if (sem_post((*s_etat_processus).semaphore_fork) != 0)	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
# endif	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 524 localisation_courante(struct_processus *	Line 575 localisation_courante(struct_processus *
}	}

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)	while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
# endif	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
Line 574 localisation_courante(struct_processus *	Line 625 localisation_courante(struct_processus *
strcpy((*s_etat_processus).localisation, d_locale);	strcpy((*s_etat_processus).localisation, d_locale);
}	}

if (sigaction(SIGINT, &action_passee, NULL) != 0)
{
for(i = 0; i < nombre_arguments; i++)
{
free(arguments[i]);
}

free(arguments);
(*s_etat_processus).erreur_systeme = d_es_signal;
return;
}

for(i = 0; i < nombre_arguments; i++)	for(i = 0; i < nombre_arguments; i++)
{	{
free(arguments[i]);	free(arguments[i]);
Line 594 localisation_courante(struct_processus *	Line 633 localisation_courante(struct_processus *
free(arguments);	free(arguments);

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
if (sem_post((*s_etat_processus).semaphore_fork) != 0)	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
# endif	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 607 localisation_courante(struct_processus *	Line 646 localisation_courante(struct_processus *
{	{
// Le processus fils renvoie une erreur.	// Le processus fils renvoie une erreur.

# ifndef SEMAPHORES_NOMMES	free(tampon);
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else	if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)	+ 1) * sizeof(unsigned char))) == NULL)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

(*s_etat_processus).erreur_execution = d_ex_erreur_processus;	strcpy((*s_etat_processus).localisation, d_locale);
return;
}	}

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
# else	# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)	while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
# endif	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
Line 669 transliterated_fprintf(struct_processus	Line 703 transliterated_fprintf(struct_processus
unsigned long i;	unsigned long i;
# endif	# endif

if (valsprintf(&tampon, format, arguments) < 0)	if (valsprintf(s_etat_processus, &tampon, format, arguments) < 0)
{	{
va_end(arguments);	va_end(arguments);

Line 700 transliterated_fprintf(struct_processus	Line 734 transliterated_fprintf(struct_processus
}	}

# ifdef OS2	# ifdef OS2
i = 0;	if ((flux == stderr) \|\| (flux == stdout))
ptr_l = tampon2;

while((*ptr_l) != d_code_fin_chaine)
{	{
if ((*ptr_l) == '\n')	i = 0;
{	ptr_l = tampon2;
i++;
}

ptr_l++;	while((*ptr_l) != d_code_fin_chaine)
}	{
	if ((*ptr_l) == '\n')
if ((tampon3 = malloc((strlen(tampon2) + i + 1) * sizeof(unsigned char)))	{
== NULL)	i++;
{	}
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);
}

ptr_e = tampon3;
ptr_l = tampon2;

while((*ptr_l) != d_code_fin_chaine)	ptr_l++;
{	}
(ptr_e) = (ptr_l);

if ((*ptr_l) == '\n')	if ((tampon3 = malloc((strlen(tampon2) + i + 1) *
	sizeof(unsigned char))) == NULL)
{	{
(*(++ptr_e)) = '\r';	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
ptr_e++;	return(-1);
ptr_l++;
}	}
else
	ptr_e = tampon3;
	ptr_l = tampon2;

	while((*ptr_l) != d_code_fin_chaine)
{	{
ptr_e++;	(ptr_e) = (ptr_l);
ptr_l++;
	if ((*ptr_l) == '\n')
	{
	(*(++ptr_e)) = '\r';
	ptr_e++;
	ptr_l++;
	}
	else
	{
	ptr_e++;
	ptr_l++;
	}
}	}
}

(*ptr_e) = d_code_fin_chaine;	(*ptr_e) = d_code_fin_chaine;

free(tampon2);	free(tampon2);
tampon2 = tampon3;	tampon2 = tampon3;
	}
# endif	# endif

# ifdef SunOS	# ifdef SunOS
Line 765 transliterated_fprintf(struct_processus	Line 802 transliterated_fprintf(struct_processus


int	int
	std_fprintf(file flux, const char format, ...)
	{
	int ios;

	va_list arguments;

	va_start(arguments, format);
	ios = vfprintf(flux, format, arguments);
	va_end(arguments);

	// Pas de parenthèses pour ne pas appeler la macro.
	return ios;
	}


	int
tex_fprintf(struct_processus *s_etat_processus,	tex_fprintf(struct_processus *s_etat_processus,
file flux, const char format, ...)	file flux, const char format, ...)
{	{
Line 777 tex_fprintf(struct_processus *s_etat_pro	Line 830 tex_fprintf(struct_processus *s_etat_pro

va_start(arguments, format);	va_start(arguments, format);

if (valsprintf(&tampon, format, arguments) < 0)	if (valsprintf(s_etat_processus, &tampon, format, arguments) < 0)
{	{
va_end(arguments);	va_end(arguments);

Line 817 tex_fprintf(struct_processus *s_etat_pro	Line 870 tex_fprintf(struct_processus *s_etat_pro
return(ios);	return(ios);
}	}

	#undef readline

	unsigned char *
	readline_wrapper(struct_processus s_etat_processus, unsigned char invite)
	{
	unsigned char *rpl_chaine;
	unsigned char *sys_chaine;

	association_etat_processus_readline(s_etat_processus);
	sys_chaine = readline(invite);

	# ifdef OS2
	printf("\r");
	# endif

	if (sys_chaine == NULL)
	{
	return(NULL);
	}

	if ((rpl_chaine = rpl_malloc(s_etat_processus, (strlen(sys_chaine) + 1) *
	sizeof(unsigned char *))) == NULL)
	{
	sys_free(sys_chaine);
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(NULL);
	}

	strcpy(rpl_chaine, sys_chaine);
	sys_free(sys_chaine);

	return(rpl_chaine);
	}


#define fprintf NULL	#define fprintf NULL
#define printf NULL	#define printf NULL

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.17
changed lines
	Added in v.1.100