/*************************************************************************************************************************************/
/* */
/* S U B S T I T U T I O N D E C A R A C T E R E S D A N S U N F I C H I E R : */
/* */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * ** * * * * * ** * */
/* * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * */
/* * * * * ** * * * * * ** */
/* * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* */
/* ATTENTION : */
/* */
/* Il est tres delicat et donc tres */
/* dangereux de modifier ce programme */
/* car, en effet, il est utilise dans */
/* 'v $xcc/cpp$Z substitue.01$X' et donc */
/* en cas de probleme, il peut devenir */
/* impossible de le recompiler. D'une part, */
/* on n'oubliera pas qu'avant toute compilation */
/* d'un programme, son '$X' anterieur est sauvegarde */
/* dans '$xTG' et d'autre part, on pourra avoir */
/* interet a faire la mise au point en dupliquant */
/* '$xcp/substitue.01$K' dans un fichier provisoire */
/* qui sera detruit ulterieurement, lorsque tout */
/* marchera bien ; c'est ce fichier provisoire que */
/* l'on compilera et testera... */
/* */
/* */
/* Nota : */
/* */
/* Le caractere '$' de fin de ligne */
/* propre aux programmes de type '$SE' */
/* est remplace simplement ici par "\n" */
/* qui est le caractere de changement */
/* de ligne et donc designe la fin de */
/* ligne (notion qui n'existe plus ici */
/* puisque '$xcp/substitue.01$X' n'a */
/* pas cette notion et manipule les */
/* fichiers globalement, ce pour quoi */
/* il a ete ecrit...). */
/* */
/* Par contre, le caractere '^' de */
/* debut de ligne propre aux programmes */
/* de type '$SE' fonctionne correctement */
/* ici. On notera que l'on peut aussi */
/* utiliser "\n" pour caracteriser le */
/* debut d'une ligne sauf s'il s'agit de */
/* la premiere ligne du fichier (auquel */
/* cas elle n'est pas precedee de ce */
/* caractere...). */
/* */
/* Le 20230313102005 je note malgre tout */
/* que '^' et '$' continuent a jouer leur */
/* role habituel ainsi que le montre le */
/* test suivant realise avec le fichier : */
/* */
/* aaaa */
/* bbbb */
/* cccc */
/* */
/* En appliquant les substitutions suivantes : */
/* */
/* c01='^' s01='-' */
/* c02='$' s02='+' */
/* */
/* on obtient : */
/* */
/* -aaaa+ */
/* -bbbb+ */
/* -cccc+ */
/* */
/* ce qui prouve le bon fonctionnement de */
/* '^' et '$'... */
/* */
/* Une question se pose alors : comment reperer */
/* le DEBUT et la FIN d'un fichier ? On notera la */
/* solution 'v $xcc/cpp$Z FLiStE_ChEcK_FoRmAt.vide' */
/* malgre son cote tres specifique... */
/* */
/* */
/* Nota sur les references a des sous-expressions : */
/* */
/* Comme avec '$SE', des sous-expressions */
/* peuvent etre referencees grace au "\" */
/* suivi d'un numero compris entre 1 et 9. */
/* Cela signifie que l'on ne peut pas referencer */
/* plus de 9 sous-expressions... */
/* */
/* */
/* Utilisation avec des fichiers de commandes : */
/* */
/* Il est possible d'utiliser '$xcp/substitue.01$X' */
/* de la facon suivante : */
/* */
/* callX $xcp/substitue.01$X DoubleDefinition=... */
/* ParameterFile=... */
/* (...) */
/* */
/* ainsi qu'on peut le voir dans 'v $xcc/cpp$Z ParameterFile'. */
/* Un des interets de cette methode, est que les fichiers */
/* commandes ("ParameterFile") peuvent utiliser sans aucune */
/* difficulte des variables du "shell"... */
/* */
/* */
/* Utilisation du type '$EGRE' : */
/* */
/* Le 20170422120827, je rappelle que pour */
/* rechercher, par exemple, les chaines "CHAINE1" */
/* et "CHAINE2" dans le fichier 'FICHIER', on */
/* pourra faire : */
/* */
/* $CA FICHIER | \ */
/* $xcp/substitue.01$X \ */
/* c01="CHAINE1" \ */
/* c02="CHAINE2" \ */
/* (...) \ */
/* EGRE=VRAI trace=VRAI sortir=FAUX */
/* */
/* ce qui permettra de voir les numeros des lignes */
/* dans lesquelles les chaine recherchees apparaissent. */
/* L'interet evident, par rapport a 'EGRE', est qu'ici */
/* les chaines recherchees peuvent etre "a cheval" sur */
/* plusieurs lignes... */
/* */
/* */
/* Nouvelles fonctionnalites : */
/* */
/* Le 20090108094506 fut introduit la */
/* possibilite de permuter les minuscules */
/* et les majuscules dans les sous-expressions */
/* en ecrivant quelque chose du type : */
/* */
/* s01="...\M\1\m..." */
/* */
/* comme cela se voit, par exemple, dans */
/* 'v $xau/LACT18.12$K$sub ".1.M.2.m"'. */
/* Ainsi "\M" ouvre cette possibilite de */
/* permutation, alors que "\m" la ferme... */
/* */
/* On notera le 20090112172243 qu'il reste */
/* de nombreux codes "\X" inutilises et qui */
/* pourraient l'etre afin d'implementer de */
/* nouvelles fonctionnalites. Actuellement, */
/* seuls : */
/* */
/* K_M */
/* K_N */
/* K_b */
/* K_k */
/* K_m */
/* K_n */
/* K_r */
/* K_t */
/* */
/* semblent utilises... */
/* */
/* */
/* Insertion d'un compteur : */
/* */
/* Le 20160813080723 fut introduit un */
/* compteur qui est incremente a chaque */
/* reference. Ainsi : */
/* */
/* s01="...\1\k..." */
/* */
/* concatenera ce compteur apres la chaine */
/* courante "\1", puis l'incrementera... */
/* */
/* Le 20160815080520 ont ete introduits */
/* "\+" et "\-" qui permettent de respectivement */
/* incrementer et decrementer explicitement le */
/* compteur... */
/* */
/* */
/* Remplacement d'un caractere quelconque : */
/* */
/* Le 20230414134056, l'option "remplacer=" */
/* a ete "etendue" en faisant que le caractere */
/* "caractereA=" puisse etre quelconque et ce */
/* via l'option "caractere_quelconque=VRAI". */
/* Seuls alors, les 'K_LF's sont conserves... */
/* */
/* */
/* Nota sur les versions : */
/* */
/* Deux versions peuvent etre generees. */
/* Malheureusement, elles possedent des */
/* differences fonctionnelles, en particulier */
/* dans la gestion de '\{...\}'. En ce qui */
/* concerne 'EXPRESSION_REGULIERE_VERSION_01', */
/* la forme '\{...\}' ne peut que suivre un */
/* caractere seul et par exemple : */
/* */
/* ...X\{3,\5\}... */
/* */
/* pour reperer les occurences de 3 a 5 */
/* caracteres "X". Par contre en ce qui */
/* concerne 'EXPRESSION_REGULIERE_VERSION_02', */
/* la forme '\{...\}' peut suivre n'importe */
/* quelle sous-expression et par exemple : */
/* */
/* ...\(ABCDEFGHIJ\)\{3,\5\}... */
/* */
/* pour reperer les occurences de 3 a 5 */
/* chaines "ABCDEFGHIJ". */
/* */
/* Cela ne va pas sans poser quelques problemes, */
/* par exemple, au niveau des fichiers du type */
/* '$xcc/cpp$D/*$sub' puisqu'en effet ces derniers */
/* doivent etre independants de la version... */
/* */
/* On notera que la page 'www file://$DarchivesG/Mosaic/regex$HTML' */
/* donne des informations precieuses sur ce sujet... */
/* */
/* */
/* Author of '$xcp/substitue.01$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 1996??????????). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E ' listG ' : */
/* */
/* */
/* :Debut_listG: */
/* :Fin_listG: */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T I V E S S P E C I F I Q U E S D E C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
@define PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES
@define PRAGMA_CL_____MODULE_NON_OPTIMISABLE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_MINI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define NOMBRE_D_ITERATIONS_DES_SUBSTITUTIONS \
UN \
/* Nombre d'iterations des substitutions (introduit le 20101227105651). */
#define LONGUEUR_MAXIMALE_DU_FICHIER_ARGUMENT \
MILLION \
/* Longueur maximale du fichier Argument. */
#define LONGUEUR_MAXIMALE_DE_L_EXPRESSION_REGULIERE_COMPILEE \
MILLE \
/* Longueur maximale de la chaine 'expression_reguliere' apres sa "compilation". On notera */ \
/* que ceci n'a en fait de sens qu'avec 'EXPRESSION_REGULIERE_VERSION_01'... */
#define FACTEUR_D_EXPANSION_DU_FICHIER_ARGUMENT \
GRO11(FRA10(FU)) \
/* Facteur de passage de la taille du fichier Argument a la taille du fichier Argument */ \
/* reellement utilisee. */
#define FACTEUR_D_EXPANSION_DU_FICHIER_RESULTAT \
GRO3(FRA2(FU)) \
/* Facteur de passage de la taille du fichier Argument a la taille du fichier Resultat. */
#define BACKSLASHER_LES_POINTS \
FAUX \
/* A priori, les "." ne devront pas etre remplaces par des "\." (fonctionnement de type */ \
/* '$SE') ; ceci a ete introduit le 20001227104156. Ce dispositif permet, en particulier, */ \
/* de manipuler des noms de fichiers, qui contiennent bien souvent des ".", sans ambiguite. */
#define CONSERVER_LES_K_LF_CONTENUS_DANS_LES_SOUS_CHAINES_DEFINIES \
VRAI \
/* Ce dispositif a ete introduit le 20040514150215 afin de permettre d'eliminer les 'K_LF' */ \
/* qui sont contenus dans les sous-chaines defines par '\(...\)' et qui sont ensuite */ \
/* dupliquees par des ecritures du type '\1'. Cela permet, par exemple, de regrouper les */ \
/* arguments d'une fonction en utilisant cet indicateur a 'FAUX' et les arguments : */ \
/* */ \
/* conserver_les_K_LF=FAUX */ \
/* c01="\(Fonction([^)][^)]*)\)" s01="\1" */ \
/* */ \
/* Pour regrouper les arguments d'une fonction avec leurs definitions, on utilisera : */ \
/* */ \
/* conserver_les_K_LF=FAUX */ \
/* c01="\(Fonction([^{][^{]*\)\({\)" s01="\1\n\2" */ \
/* */ \
/* Evidemment, cela concerne des fichiers de type '$c'... */
#define CONSERVER_LES_K_BLANC_CONTENUS_DANS_LES_SOUS_CHAINES_DEFINIES \
VRAI \
/* Ce dispositif a ete introduit le 20040526142735 afin de permettre d'eliminer les */ \
/* 'K_BLANC' dans les memes conditions que les 'K_LF' ci-dessus, mais cette fois en ce */ \
/* qui concerne des fichiers de type '$K' en utilisant cet indicateur a 'FAUX' (ainsi */ \
/* que celui relatif a 'K_LF') et les arguments : */ \
/* */ \
/* conserver_les_K_BLANC=FAUX */ \
/* conserver_les_K_LF=FAUX */ \
/* c01="^\(DEFV(Common,DEFV(Fonction[^;]*\)\n" s01="\1\n" */ \
/* */ \
/* Le 20040526161746, la commande 'v $xcg/LArgTypFo$vv$Z' a ete introduite pour automatiser */ \
/* ce type de modification... */
#define REMPLACER_UN_CARACTERE_CONTENU_DANS_LES_SOUS_CHAINES_DEFINIES \
FAUX
#define LE_CARACTERE_A_REMPLACER_DANS_LES_SOUS_CHAINES_DEFINIES_EST_QUELCONQUE \
FAUX
#define CARACTERE_A_REMPLACER_DANS_LES_SOUS_CHAINES_DEFINIES \
K_POINT_VIRGULE
#define CARACTERE_DE_REMPLACEMENT_DANS_LES_SOUS_CHAINES_DEFINIES \
K_VIRGULE
/* Ce dispositif a ete introduit le 20040601111701 afin de faciliter le passage de */
/* l'ecriture : */
/* */
/* type Fonction(arg1,arg2,...) */
/* type1 arg1; */
/* type2 arg2; */
/* (...) */
/* { */
/* */
/* a l'ecriture : */
/* */
/* type Fonction(type1 arg1,type2 arg2,...) */
/* { */
/* */
/* en utilisant specifiquement pour la fonction 'Fonction(...)' : */
/* */
/* conserver_les_K_BLANC=VRAI */
/* conserver_les_K_LF=FAUX */
/* remplacer_un_caractere=VRAI caractereA=";" caractereR="," */
/* c01="\([ \n]\)\(Fonction(\)[^)]*)\([^{][^{]*\)\({\)" s01="\1\2\3)\n\4" */
/* c02=", *\()\)" s02="\1" */
/* */
/* ou plus generalement (pour toutes les fonctions) ou 'DebutDeDefinitionDeFonction' est */
/* represente par 'Debut' (pour reduire la longueur des lignes ci-apres...) : */
/* */
/* conserver_les_K_BLANC=VRAI */
/* conserver_les_K_LF=FAUX */
/* remplacer_un_caractere=VRAI caractereA=";" caractereR="," */
/* c01="\n\(Debut [^(]*[^*](\)[^)]*)\([^{][^{]*\)\({\)" s01="\n\1\2)\n\3" */
/* c02="\n\(Debut [^(]*\*([^(]*(\)[^)]*))\([^{][^{]*\)\({\)" s02="\n\1\2))\n\3" */
/* c11=", *\()\)" s11="\1" */
/* */
/* Evidemment, cela concerne des fichiers de type '$c'... */
/* */
/* */
/* Le 20230414134056, fut donc introduite la bascule {\Q,\q} rendant quelconque le */
/* caractere a remplacer... */
#define VALEUR_INITIALE_DU_COMPTEUR \
ZERO
#define INCREMENT_DU_COMPTEUR \
UN
#define NOMBRE_DE_CHIFFRES_DU_COMPTEUR \
QUATRE
/* Le compteur a ete introduit le 20160813080723... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H O I X D E L A V E R S I O N A G E N E R E R */
/* E T " A S T U C E S " D E C O M P A T I B I L I T E : */
/* */
/*************************************************************************************************************************************/
#if ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
# define __STDC__ \
UNDEF \
/* Pour permettre l'interpretation de '<regex.h>' sans engendrer d'erreurs dues au fait */ \
/* que la variable '__STDC__' n'est pas definie, alors que sa valeur est testee dans le */ \
/* fichier '/usr/include/regex$h' par un : */ \
/* */ \
/* #if __STDC__ */ \
/* */ \
/* alors qu'il semblerait que partout ailleurs, c'est son existence qui est testee, par */ \
/* exemple dans '/usr/include/ansidecl$h'... */
# if (nC_RELEASE >= 295040000)
# define __restrict \
/* Pour permettre l'interpretation de '<regex.h>' sans engendrer d'erreurs dues au fait */ \
/* que la variable '__restrict' n'est pas definie, alors qu'une valeur vide permet */ \
/* d'assurer la compatibilite avec les versions anterieures au 20021212140844. Ceci a */ \
/* ete introduit a cette date lors de l'introduction de '$LACT15'... */
# Aif (nC_RELEASE >= 295040000)
# Eif (nC_RELEASE >= 295040000)
@ ifndef _STDLIB_H
@ define _STDLIB_H \
UNDEF
@ Aifndef _STDLIB_H
@ Eifndef _STDLIB_H
/* En effet, /usr/include/regexp$h' fait un include de '<stdlib.h>' qui alors definit les */
/* type de nombreuses fonctions comme 'getenv(...)' ; ces definitions rentrent alors en */
/* conflit avec les miennes, d'ou la definition de '_STDLIB_H' qui inhibera le contenu de */
/* '<stdlib.h>'... */
/* */
/* Le 20071121173341 furent introduits {ifndef,Aifndef,Eifndef} a cause de '$LACT18' et */
/* de 'SYSTEME_APC_LinuxUbuntu_GCC'... */
#Aif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
#Eif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
#if ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
# if (nC_RELEASE >= 303040000)
# define _SYS_TYPES_H \
/* Afin de bloquer l'include de '<sys/types.h>' qui est reference dans '<regex.h>'. Cela */ \
/* fut introduit le 20041206131906 lors du demarrage a froid de '$LACT17'... */
# define __restrict_arr \
/* Pour permettre l'interpretation de '<regex.h>' sans engendrer d'erreurs dues au fait */ \
/* que la variable '__restrict_arr' n'est pas definie, alors qu'une valeur vide permet */ \
/* d'assurer la compatibilite avec les versions anterieures au 20041206131906. Ceci a */ \
/* ete introduit a cette date lors de l'introduction de '$LACT17'... */
# Aif (nC_RELEASE >= 303040000)
# Eif (nC_RELEASE >= 303040000)
#Aif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
#Eif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
#if ( (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
)
# if (nC_RELEASE >= 303010000)
# define _SYS_TYPES_H \
/* Afin de bloquer l'include de '<sys/types.h>' qui est reference dans '<regex.h>'. Cela */ \
/* fut introduit le 20031028121749 lors du demarrage a froid de '$LACT16'... */
# define __restrict_arr \
/* Pour permettre l'interpretation de '<regex.h>' sans engendrer d'erreurs dues au fait */ \
/* que la variable '__restrict_arr' n'est pas definie, alors qu'une valeur vide permet */ \
/* d'assurer la compatibilite avec les versions anterieures au 20031028121749. Ceci a */ \
/* ete introduit a cette date lors de l'introduction de '$LACT16'... */
# Aif (nC_RELEASE >= 303010000)
# Eif (nC_RELEASE >= 303010000)
# if (nC_RELEASE >= 805000000)
# define _Restrict_
# define _Restrict_arr_
/* Introduit le 20220511093001 apres les mises a jour des serveurs de calcul de '$CMAP28' */
/* effectues au cours des semaines passees... */
# Aif (nC_RELEASE >= 805000000)
# Eif (nC_RELEASE >= 805000000)
#Aif ( (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
)
#Eif ( (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
)
#if ( (defined(SYSTEME_HP710_HPUX_CC)) \
|| (defined(SYSTEME_HP720_HPUX_CC)) \
|| (defined(SYSTEME_HP750_HPUX_CC)) \
|| (defined(SYSTEME_HP755_HPUX_CC)) \
|| (defined(SYSTEME_HP819_HPUX_CC)) \
)
# define _SYS_STDSYMS_INCLUDED \
UNDEF \
/* Pour permettre l'interpretation de '<sys/stdsyms.h>' ci-apres dans '<regex.h>' sans */ \
/* engendrer d'erreurs dues au fait que certaines variables du pre-processeur n'ont pas */ \
/* ete definies sur 'SYSTEME_HP???_HPUX_C'. On evite ainsi le probleme du message suivant : */ \
/* */ \
/* Error : /usr/include/sys/stdsyms.h: 66: */ \
/* undef symbol _POSIX_C_SOURCE in preprocessor if */ \
/* */ \
/* car, en effet, le fichier '/usr/include/sys/stdsyms$h' contient la ligne : */ \
/* */ \
/* #if defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE > 1) */ \
/* */ \
/* qui est incorrecte si '_POSIX_C_SOURCE' n'existe pas... */
#Aif ( (defined(SYSTEME_HP710_HPUX_CC)) \
|| (defined(SYSTEME_HP720_HPUX_CC)) \
|| (defined(SYSTEME_HP750_HPUX_CC)) \
|| (defined(SYSTEME_HP755_HPUX_CC)) \
|| (defined(SYSTEME_HP819_HPUX_CC)) \
)
#Eif ( (defined(SYSTEME_HP710_HPUX_CC)) \
|| (defined(SYSTEME_HP720_HPUX_CC)) \
|| (defined(SYSTEME_HP750_HPUX_CC)) \
|| (defined(SYSTEME_HP755_HPUX_CC)) \
|| (defined(SYSTEME_HP819_HPUX_CC)) \
)
#if ( (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
# define _SYS_TYPES_H \
UNDEF \
/* Pour permettre l'interpretation de '<sys/types.h>' ci-apres dans '<regex.h>' sans */ \
/* engendrer d'erreurs dues au fait que certaines variables du pre-processeur n'ont pas */ \
/* ete definies (par exemple '_MIPS_SIM', '_ABIN32',... sur 'SYSTEME_SGPCM801_IRIX_CC'). */
# if (nSYSTEM_RELEASE >= 605034800)
# define _SGIAPI \
UNDEF
# define _MIPS_SIM \
UNDEF
# define _ABIN32 \
UNDEF
# define _ABIAPI \
UNDEF
/* Pour permettre l'interpretation de '<regex.h>' dans le '#Einclude' qui va suivre, sans */
/* engendrer d'erreurs dues au fait que ces symboles n'existent pas... */
# Aif (nSYSTEM_RELEASE >= 605034800)
# Eif (nSYSTEM_RELEASE >= 605034800)
#Aif ( (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
#Eif ( (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
#define regex_t \
regex_t_pour_regex
#define regmatch_t \
regmatch_t_pour_regex
#define regoff_t \
regoff_t_pour_regex
#define regcomp \
regcomp_pour_regex
#define regerror \
regerror_pour_regex
#define regexec \
regexec_pour_regex
#define regfree \
regfree_pour_regex
#define active_reg_t \
active_reg_t_pour_regex
#define re_compile_pattern \
re_compile_pattern_pour_regex
#define re_compile_fastmap \
re_compile_fastmap_pour_regex
#define re_match \
re_match_pour_regex
#define re_match_2 \
re_match_2_pour_regex
#define re_pattern_buffer \
re_pattern_buffer_pour_regex
#define re_registers \
re_registers_pour_regex
#define re_search \
re_search_pour_regex
#define re_search_2 \
re_search_2_pour_regex
#define re_set_registers \
re_set_registers_pour_regex
#define reg_errcode_t \
reg_errcode_t_pour_regex
#define reg_syntax_t \
reg_syntax_t_pour_regex
#define s_reg_t \
s_reg_t_pour_regex
#if ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
/* A la date du 20210902101807, on passe ici sur '$LACT1A' et '$LACT1B'... */
# if ( (defined(LACT1B)) \
|| (defined(CMAP28)) \
)
/* Introduit le 20210903064354. Dans le cas ou d'autres MACHINEs ayant le meme */
/* comportement que l'$LACT1B', il faudra ajouter ici des lignes du type : */
/* */
/* || (defined(MACHINE)) \ */
/* */
/* Le 20220511093001, 'CMAP28' a ete introduit ici apres les mises a jour des serveurs */
/* de calcul de '$CMAP28' effectues au cours des semaines passees... */
/* */
/* Ce test a donc ete introduit le 20210903064354 a cause de '$LACT1B' et son fichier */
/* 'v /usr/include/regex.h' dans lequel on trouve : */
/* */
/* typedef enum */
/* { */
/* _REG_ENOSYS=-1, */
/* _REG_NOERROR=0, */
/* (...) */
/* } reg_errcode_t; */
/* */
/* #define REG_ENOSYS _REG_ENOSYS */
/* #define REG_NOERROR _REG_NOERROR */
/* (...) */
/* */
/* alors que, par exemple, sur '$LACT19' on trouve uniquement : */
/* */
/* typedef enum */
/* { */
/* REG_ENOSYS=-1, */
/* REG_NOERROR=0, */
/* (...) */
/* } reg_errcode_t; */
/* */
/* De plus, un autre tres tres gros probleme a ete decouvert un peu plus tard (apres le */
/* 20210903071115) : 'v /usr/include/regex.h elif', la directive '#elif' n'etant pas */
/* reconnu par 'v $xcpp/beau_cpp$c' a cette date. Que faire ? */
# define _REG_ENOSYS \
_REG_ENOSYS_pour_regex
# define _REG_NOERROR \
_REG_NOERROR_pour_regex
# define _REG_NOMATCH \
_REG_NOMATCH_pour_regex
# define _REG_BADPAT \
_REG_BADPAT_pour_regex
# define _REG_ECOLLATE \
_REG_ECOLLATE_pour_regex
# define _REG_ECTYPE \
_REG_ECTYPE_pour_regex
# define _REG_EESCAPE \
_REG_EESCAPE_pour_regex
# define _REG_ESUBREG \
_REG_ESUBREG_pour_regex
# define _REG_EBRACK \
_REG_EBRACK_pour_regex
# define _REG_EPAREN \
_REG_EPAREN_pour_regex
# define _REG_EBRACE \
_REG_EBRACE_pour_regex
# define _REG_BADBR \
_REG_BADBR_pour_regex
# define _REG_ERANGE \
_REG_ERANGE_pour_regex
# define _REG_ESPACE \
_REG_ESPACE_pour_regex
# define _REG_BADRPT \
_REG_BADRPT_pour_regex
# define _REG_EEND \
_REG_EEND_pour_regex
# define _REG_ESIZE \
_REG_ESIZE_pour_regex
# define _REG_ERPAREN \
_REG_ERPAREN_pour_regex
# Aif ( (defined(LACT1B)) \
|| (defined(CMAP28)) \
)
# define REG_NOERROR \
REG_NOERROR_pour_regex
# define REG_NOMATCH \
REG_NOMATCH_pour_regex
# define REG_BADPAT \
REG_BADPAT_pour_regex
# define REG_ECOLLATE \
REG_ECOLLATE_pour_regex
# define REG_ECTYPE \
REG_ECTYPE_pour_regex
# define REG_EESCAPE \
REG_EESCAPE_pour_regex
# define REG_ESUBREG \
REG_ESUBREG_pour_regex
# define REG_EBRACK \
REG_EBRACK_pour_regex
# define REG_EPAREN \
REG_EPAREN_pour_regex
# define REG_EBRACE \
REG_EBRACE_pour_regex
# define REG_BADBR \
REG_BADBR_pour_regex
# define REG_ERANGE \
REG_ERANGE_pour_regex
# define REG_ESPACE \
REG_ESPACE_pour_regex
# define REG_BADRPT \
REG_BADRPT_pour_regex
# define REG_EEND \
REG_EEND_pour_regex
# define REG_ESIZE \
REG_ESIZE_pour_regex
# define REG_ERPAREN \
REG_ERPAREN_pour_regex
# Eif ( (defined(LACT1B)) \
|| (defined(CMAP28)) \
)
#Aif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
#Eif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
/* Afin d'eliminer des problemes de double definition dus eventuellement a la double */
/* presence de '<regex.h>' via 'Einclude' et 'include'. Ainsi, lorsque, par exemple, */
/* 'regex_t' sera rencontre dans la premiere inclusion de '<regex.h>', il lui sera */
/* substitue 'regex_t_pour_regex', et adieu la double definition lors de la seconde */
/* de '<regex.h>'... */
/* */
/* {active_reg_t,re_pattern_buffer,re_registers,reg_errcode_t,reg_syntax_t,s_reg_t} ont */
/* ete introduits le 19990816123512 pour l'introduction de 'SYSTEME_APC_LinuxRedHat_GCC'. */
/* Il en va de meme des 'REG_.' qui partout ailleurs sont des '#define' et qui sont ici */
/* definis dans un 'enum(...)'. */
#if (defined(xREFERENCE))
# if ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
# nodefine GENERER_UNE_VERSION_BOOTSTRAPPABLE \
/* Malheureusement, il a fallu proceder ainsi le 20041021085548 car, a cette date, la */ \
/* MACHINE '$mREFERENCE' est '$LACT16' ('SYSTEME_APC_LinuxRedHat_GCC') et son fichier */ \
/* 'v /usr/include/regexp$h' ne definit pas {braslist,braelist}... */
# Aif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
# define GENERER_UNE_VERSION_BOOTSTRAPPABLE \
/* ATTENTION, ce programme devant pouvoir faire partie des programmes "bootstrappables" */ \
/* de '$xcp' doit pouvoir utiliser la version la plus repandue (qui est aussi la plus */ \
/* ancienne...), c'est-a-dire 'EXPRESSION_REGULIERE_VERSION_01', d'ou cette definition */ \
/* sur '$mREFERENCE'... */ \
/* */ \
/* ATTENTION, cette version "bootstrappable" contiendra les symboles (via '<regexp.h>') : */ \
/* */ \
/* {braslist,braelist} */ \
/* */ \
/* si l'on est sur une version anterieure a 601000000, et les symboles (via '<regexp.h>') : */ \
/* */ \
/* {_braslist,_braelist} */ \
/* */ \
/* sinon. Cela peut donc creer des problemes de bootstrapping sur une nouvelle machine. */ \
/* Cela s'est vu le 19970213143915 sur '$LACT29' qui est en version 604000000, alors que */ \
/* '$LACT12' ('$mREFERENCE') est en 503000000. Il conviendra, si besoin est, de corriger */ \
/* "a la main" le fichier '$xcp/substitue.01$c' en ce qui concerne ces deux symboles... */
# Eif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
#Aif (defined(xREFERENCE))
# nodefine GENERER_UNE_VERSION_BOOTSTRAPPABLE \
/* Sur les autres MACHINEs, la contrainte de "bootstrappabilite" n'existe pas... */
#Eif (defined(xREFERENCE))
#define __USE_GNU \
/* Introduit le 20100525132425 pour la procedure 'v /usr/include/regex$h __REPB_PREFIX' mal */ \
/* definie, probleme rencontre a cette date sur '$CMAP28' (="abbesses.polytechnique.fr")... */
#if ( (defined(LACT1B)) \
)
# Einclude regex_h__
#Aif ( (defined(LACT1B)) \
)
# Einclude <regex.h>
#Eif ( (defined(LACT1B)) \
)
/* Cet include est en fait la uniquement pour tester l'existence du fichier '<regex.h>' sur */
/* ce SYSTEME. Si il est present, alors le symbole '_REGEX_H' est defini, ce que l'on va */
/* tester ci-apres... */
/* */
/* ATTENTION, cet include etant fait immediatement en '$PASSE_1' provoque l'insertion de */
/* declarations de fonctions externes. Cela a donc exige la mise en place d'un traitement */
/* special ('v $xcc/cpp$Z regex$h') afin de les faire disparaitre... */
#undef __USE_GNU
/* A cause du '@include <regex.h>' qui est en '$PASSE_5' (et non pas en '$PASSE_1')... */
#if ( (defined(SYSTEME_HP710_HPUX_CC)) \
|| (defined(SYSTEME_HP720_HPUX_CC)) \
|| (defined(SYSTEME_HP750_HPUX_CC)) \
|| (defined(SYSTEME_HP755_HPUX_CC)) \
|| (defined(SYSTEME_HP819_HPUX_CC)) \
)
# undef _SYS_STDSYMS_INCLUDED
#Aif ( (defined(SYSTEME_HP710_HPUX_CC)) \
|| (defined(SYSTEME_HP720_HPUX_CC)) \
|| (defined(SYSTEME_HP750_HPUX_CC)) \
|| (defined(SYSTEME_HP755_HPUX_CC)) \
|| (defined(SYSTEME_HP819_HPUX_CC)) \
)
#Eif ( (defined(SYSTEME_HP710_HPUX_CC)) \
|| (defined(SYSTEME_HP720_HPUX_CC)) \
|| (defined(SYSTEME_HP750_HPUX_CC)) \
|| (defined(SYSTEME_HP755_HPUX_CC)) \
|| (defined(SYSTEME_HP819_HPUX_CC)) \
)
#if ( (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
# undef _SYS_TYPES_H
#Aif ( (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
#Eif ( (defined(SYSTEME_SG4D20G_IRIX_CC)) \
|| (defined(SYSTEME_SG4D25TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D310VGX_IRIX_CC)) \
|| (defined(SYSTEME_SG4D35TG_IRIX_CC)) \
|| (defined(SYSTEME_SG4D85GT_IRIX_CC)) \
|| (defined(SYSTEME_SGIND308_IRIX_CC)) \
|| (defined(SYSTEME_SGIND324_IRIX_CC)) \
|| (defined(SYSTEME_SGIND3GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND408_IRIX_CC)) \
|| (defined(SYSTEME_SGIND424_IRIX_CC)) \
|| (defined(SYSTEME_SGIND4GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND508_IRIX_CC)) \
|| (defined(SYSTEME_SGIND524_IRIX_CC)) \
|| (defined(SYSTEME_SGIND5GA_IRIX_CC)) \
|| (defined(SYSTEME_SGIND808_IRIX_CC)) \
|| (defined(SYSTEME_SGIND824_IRIX_CC)) \
|| (defined(SYSTEME_SGIND8GA_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA08_IRIX_CC)) \
|| (defined(SYSTEME_SGINDA24_IRIX_CC)) \
|| (defined(SYSTEME_SGINDAGA_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A1_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A2_IRIX_CC)) \
|| (defined(SYSTEME_SGO200A4_IRIX_CC)) \
|| (defined(SYSTEME_SGO25224_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VA_IRIX_CC)) \
|| (defined(SYSTEME_SGO252VN_IRIX_CC)) \
|| (defined(SYSTEME_SGPCM801_IRIX_CC)) \
|| (defined(SYSTEME_SGPCMA01_IRIX_CC)) \
)
#undef regex_t
#undef regmatch_t
#undef regoff_t
#undef regcomp
#undef regerror
#undef regexec
#undef regfree
#undef active_reg_t
#undef re_compile_pattern
#undef re_compile_fastmap
#undef re_match
#undef re_match_2
#undef re_pattern_buffer
#undef re_registers
#undef re_search
#undef re_search_2
#undef re_set_registers
#undef reg_errcode_t
#undef reg_syntax_t
#undef s_reg_t
#if ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
# if ( (defined(LACT1B)) \
)
/* Introduit le 20210903064354. Dans le cas ou d'autres MACHINEs ayant le meme */
/* comportement que l'$LACT1B', il faudra ajouter ici des lignes du type : */
/* */
/* || (defined(MACHINE)) \ */
/* */
# Aif ( (defined(LACT1B)) \
)
# undef REG_NOERROR
# undef REG_NOMATCH
# undef REG_BADPAT
# undef REG_ECOLLATE
# undef REG_ECTYPE
# undef REG_EESCAPE
# undef REG_ESUBREG
# undef REG_EBRACK
# undef REG_EPAREN
# undef REG_EBRACE
# undef REG_BADBR
# undef REG_ERANGE
# undef REG_ESPACE
# undef REG_BADRPT
# undef REG_EEND
# undef REG_ESIZE
# undef REG_ERPAREN
# Eif ( (defined(LACT1B)) \
)
#Aif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
#Eif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
/* Afin d'eliminer des problemes de double definition dus eventuellement a la double */
/* presence de '<regex.h>' via 'Einclude' et 'include'. Ainsi, lorsque, par exemple, */
/* 'regex_t' sera rencontre dans la premiere inclusion de '<regex.h>', il lui sera */
/* substitue 'regex_t_pour_regex', et adieu la double definition lors de la seconde */
/* de '<regex.h>'... */
#if ( (defined(_REGEX_H)) \
&& (! defined(GENERER_UNE_VERSION_BOOTSTRAPPABLE)) \
&& ( ( (! defined(SYSTEME_HP705_HPUX_CC)) \
&& (! defined(SYSTEME_HP710_HPUX_CC)) \
&& (! defined(SYSTEME_HP720_HPUX_CC)) \
&& (! defined(SYSTEME_HP750_HPUX_CC)) \
&& (! defined(SYSTEME_HP755_HPUX_CC)) \
&& (! defined(SYSTEME_HP819_HPUX_CC)) \
) \
&& ( (! defined(LACT71)) \
&& (! defined(LACT27)) \
&& (! defined(LACT28)) \
&& (! defined(LACT29)) \
) \
) \
)
# nodefine EXPRESSION_REGULIERE_VERSION_02 \
/* Version "moderne" avec '<regex.h>' de type 'POSIX' et donc limitee : en particulier la */ \
/* variable 're_syntax_options' n'est pas utilisee par la fonction 'regcomp(...)' et ce */ \
/* contrairement a la fonction 're_compile_pattern(...)' de type 'GNU'... */
# define EXPRESSION_REGULIERE_VERSION_03 \
/* Version "moderne" avec '<regex.h>' de type 'GNU' et donc beaucoup plus puissante. Elle */ \
/* a commence d'etre introduite le 20021205130954. En fait au lieu d'utiliser 'regcomp(...)' */ \
/* de type 'POSIX', elle utilise 're_compile_pattern(...)' de type 'GNU', mais ensuite */ \
/* continue d'utiliser, comme 'EXPRESSION_REGULIERE_VERSION_02' la fonction 'regexec(...)' */ \
/* de type 'POSIX'. Cette version a ete activee le 20021206163902... */
#Aif ( (defined(_REGEX_H)) \
&& (! defined(GENERER_UNE_VERSION_BOOTSTRAPPABLE)) \
&& ( ( (! defined(SYSTEME_HP705_HPUX_CC)) \
&& (! defined(SYSTEME_HP710_HPUX_CC)) \
&& (! defined(SYSTEME_HP720_HPUX_CC)) \
&& (! defined(SYSTEME_HP750_HPUX_CC)) \
&& (! defined(SYSTEME_HP755_HPUX_CC)) \
&& (! defined(SYSTEME_HP819_HPUX_CC)) \
) \
&& ( (! defined(LACT71)) \
&& (! defined(LACT27)) \
&& (! defined(LACT28)) \
&& (! defined(LACT29)) \
) \
) \
)
/* ATTENTION, j'ai essaye de mettre ci-apres : */
/* */
/* # define __STRING_H__ \ */
/* UNDEF */
/* */
/* pour permettre l'interpretation de '<string.h>' sur 'SYSTEME_SG...' ci-apres... */
/* */
/* # Einclude <regexp.h> */
/* */
/* cet include est en fait la uniquement pour tester l'existence du fichier '<regexp.h>' sur */
/* ce SYSTEME. Si il est present, alors le symbole '__REGEXP_H__' est defini, ce que l'on va */
/* tester ci-apres... */
/* */
/* # undef __STRING_H__ */
/* */
/* # ifdef __REGEXP_H__ */
/* # define EXPRESSION_REGULIERE_VERSION_01 \ */
/* */
/* version "ancienne" avec '<regexp.h>'. */
/* */
/* # Aifdef __REGEXP_H__ */
/* # message "gestion des expressions regulieres non disponible" */
/* # Eifdef __REGEXP_H__ */
/* */
/* mais malheureusement, cela implante le code utile une premiere fois et donc deux fois au */
/* total avec le deuxieme include qui suit en '$PASSE_5'... */
/* */
/* ATTENTION, on notera le cas particulier de 'SYSTEME_HP...' qui ne possede pas le mode */
/* 'REG_BASIC' mais uniquement 'REG_EXTENDED'... */
/* */
/* ATTENTION, on notera le cas particulier de 'SYSTEME_APC_LinuxRedHat...' qui ne possede */
/* pas le mode 'REG_BASIC' mais uniquement 'REG_EXTENDED' mais ce dernier etant equivalent */
/* au premier lorsque la variable 'POSIX' n'est pas definie... */
/* */
/* ATTENTION, on notera le cas particulier des MACHINEs 'LACT2?' qui ont visiblement des */
/* problemes de performances en 'EXPRESSION_REGULIERE_VERSION_02'. A titre d'exemple, sur */
/* '$LACT27' on observe les resultats suivants sur un fichier de 2081651 octets provenant */
/* de '$xbg/common$K' tel qu'il arrive a l'entree de la '$PASSE_1' de 'v $xcc/cpp$Z' : */
/* */
/* | "= define " | "# define " */
/* ----------------------------------------+-------------------+------------------- */
/* | | */
/* $SE | 01 seconde | 02 seconde */
/* | | */
/* ----------------------------------------+-------------------+------------------- */
/* | | */
/* $xcp/substitue.01$K | 03 secondes | 02 secondes */
/* ('EXPRESSION_REGULIERE_VERSION_01') | | */
/* | | */
/* ----------------------------------------+-------------------+------------------- */
/* | | */
/* $xcp/substitue.01$K | 27 secondes | 03 secondes */
/* ('EXPRESSION_REGULIERE_VERSION_02') | | */
/* | | */
/* */
/* et ce lors du remplacement de la chaine ". define " par n'importe quoi ("tutu" en */
/* l'occurence) le 19970103150000. Le 19970106085733, un test "grandeur nature" de */
/* compilation a ete fait sur '$LACT28' avec le module '$xbg/fonction$K' ; il a donne */
/* les resultats suivants : */
/* */
/* | */
/* $SE (mode 'sed') | 05:05 */
/* | */
/* ----------------------------------------+------------------- */
/* | */
/* $xcp/substitue.01$K (mode 'sub') | 06:18 */
/* ('EXPRESSION_REGULIERE_VERSION_01') | */
/* | */
/* ----------------------------------------+------------------- */
/* | */
/* $xcp/substitue.01$K (mode 'sub') | 22:01 */
/* ('EXPRESSION_REGULIERE_VERSION_02') | */
/* | */
/* */
/* d'ou la necessite evidente d'utiliser alors 'EXPRESSION_REGULIERE_VERSION_01'... */
# define EXPRESSION_REGULIERE_VERSION_01 \
/* Version "ancienne" avec '<regexp.h>'. */
#Eif ( (defined(_REGEX_H)) \
&& (! defined(GENERER_UNE_VERSION_BOOTSTRAPPABLE)) \
&& ( ( (! defined(SYSTEME_HP705_HPUX_CC)) \
&& (! defined(SYSTEME_HP710_HPUX_CC)) \
&& (! defined(SYSTEME_HP720_HPUX_CC)) \
&& (! defined(SYSTEME_HP750_HPUX_CC)) \
&& (! defined(SYSTEME_HP755_HPUX_CC)) \
&& (! defined(SYSTEME_HP819_HPUX_CC)) \
) \
&& ( (! defined(LACT71)) \
&& (! defined(LACT27)) \
&& (! defined(LACT28)) \
&& (! defined(LACT29)) \
) \
) \
)
/* Tout ceci est destine uniquement a savoir lequel de '<regex.h>' (version "moderne") ou de */
/* '<regexp.h>' (version "ancienne") on va utiliser... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A I D E A U P A R A M E T R A G E I N T R O D U I T L E 20021206174023 : */
/* */
/*************************************************************************************************************************************/
/* Le 20100320105316 tous les 'vrai_Positive_de_base's (dont finalement je ne vois pas */
/* vraiment l'utilite) ont ete remplace par des 'Positive's afin de ne plus creer de */
/* problemes de type dans les 'GET_ARGUMENT_Y(...)'s qui suivront et qui apparaissent */
/* dans le cas 'v $xil/defi_K1$vv$DEF 20100317125446'... */
#if ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
# define GET_ARGUMENT_I_D_AIDE_AU_PARAMETRAGE \
Bblock \
Eblock
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
)
DEFV(Local,DEFV(Positive,INIT(regcomp_REG_EXTENDED,REG_EXTENDED)));
DEFV(Local,DEFV(Positive,INIT(regcomp_REG_ICASE,REG_ICASE)));
DEFV(Local,DEFV(Positive,INIT(regcomp_REG_NEWLINE,REG_NEWLINE)));
DEFV(Local,DEFV(Positive,INIT(regcomp_REG_NOSUB,REG_NOSUB)));
DEFV(Local,DEFV(Positive,INIT(regexec_REG_NOTBOL,REG_NOTBOL)));
DEFV(Local,DEFV(Positive,INIT(regexec_REG_NOTEOL,REG_NOTEOL)));
# define GET_ARGUMENT_I_D_AIDE_AU_PARAMETRAGE \
Bblock \
GET_ARGUMENT_Y("regcomp_REG_EXTENDED=",regcomp_REG_EXTENDED); \
GET_ARGUMENT_Y("regcomp_REG_ICASE=",regcomp_REG_ICASE); \
GET_ARGUMENT_Y("regcomp_REG_NEWLINE=",regcomp_REG_NEWLINE); \
GET_ARGUMENT_Y("regcomp_REG_NOSUB=",regcomp_REG_NOSUB); \
\
GET_ARGUMENT_Y("regexec_REG_NOTBOL=",regexec_REG_NOTBOL); \
GET_ARGUMENT_Y("regexec_REG_NOTEOL=",regexec_REG_NOTEOL); \
Eblock
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_BACKSLASH_ESCAPE_IN_LISTS,RE_BACKSLASH_ESCAPE_IN_LISTS)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_BK_PLUS_QM,RE_BK_PLUS_QM)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_CHAR_CLASSES,RE_CHAR_CLASSES)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_CONTEXT_INDEP_ANCHORS,RE_CONTEXT_INDEP_ANCHORS)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_CONTEXT_INDEP_OPS,RE_CONTEXT_INDEP_OPS)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_CONTEXT_INVALID_OPS,RE_CONTEXT_INVALID_OPS)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_DOT_NEWLINE,RE_DOT_NEWLINE)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_DOT_NOT_NULL,RE_DOT_NOT_NULL)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_HAT_LISTS_NOT_NEWLINE,RE_HAT_LISTS_NOT_NEWLINE)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_INTERVALS,RE_INTERVALS)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_LIMITED_OPS,RE_LIMITED_OPS)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_NEWLINE_ALT,RE_NEWLINE_ALT)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_NO_BK_BRACES,RE_NO_BK_BRACES)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_NO_BK_PARENS,RE_NO_BK_PARENS)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_NO_BK_REFS,RE_NO_BK_REFS)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_NO_BK_VBAR,RE_NO_BK_VBAR)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_NO_EMPTY_RANGES,RE_NO_EMPTY_RANGES)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_UNMATCHED_RIGHT_PAREN_ORD,RE_UNMATCHED_RIGHT_PAREN_ORD)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_NO_POSIX_BACKTRACKING,RE_NO_POSIX_BACKTRACKING)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_NO_GNU_OPS,RE_NO_GNU_OPS)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_DEBUG,RE_DEBUG)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_SYNTAX_EMACS,RE_SYNTAX_EMACS)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_SYNTAX_AWK,RE_SYNTAX_AWK)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_SYNTAX_GNU_AWK,RE_SYNTAX_GNU_AWK)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_SYNTAX_POSIX_AWK,RE_SYNTAX_POSIX_AWK)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_SYNTAX_GREP,RE_SYNTAX_GREP)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_SYNTAX_EGREP,RE_SYNTAX_EGREP)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_SYNTAX_POSIX_EGREP,RE_SYNTAX_POSIX_EGREP)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_SYNTAX_ED,RE_SYNTAX_ED)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_SYNTAX_SED,RE_SYNTAX_SED)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern__RE_SYNTAX_POSIX_COMMON,_RE_SYNTAX_POSIX_COMMON)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_SYNTAX_POSIX_BASIC,RE_SYNTAX_POSIX_BASIC)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_SYNTAX_POSIX_MINIMAL_BASIC,RE_SYNTAX_POSIX_MINIMAL_BASIC)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_SYNTAX_POSIX_EXTENDED,RE_SYNTAX_POSIX_EXTENDED)));
DEFV(Local,DEFV(Positive,INIT(re_compile_pattern_RE_SYNTAX_POSIX_MINIMAL_EXTENDED,RE_SYNTAX_POSIX_MINIMAL_EXTENDED)));
DEFV(Local,DEFV(Positive,INIT(regexec_REG_NOTBOL,REG_NOTBOL)));
DEFV(Local,DEFV(Positive,INIT(regexec_REG_NOTEOL,REG_NOTEOL)));
# define GET_ARGUMENT_I_D_AIDE_AU_PARAMETRAGE \
Bblock \
GET_ARGUMENT_Y("re_compile_pattern_RE_BACKSLASH_ESCAPE_IN_LISTS=" \
,re_compile_pattern_RE_BACKSLASH_ESCAPE_IN_LISTS \
); \
GET_ARGUMENT_Y("re_compile_pattern_RE_BK_PLUS_QM=",re_compile_pattern_RE_BK_PLUS_QM); \
GET_ARGUMENT_Y("re_compile_pattern_RE_CHAR_CLASSES=",re_compile_pattern_RE_CHAR_CLASSES); \
GET_ARGUMENT_Y("re_compile_pattern_RE_CONTEXT_INDEP_ANCHORS=",re_compile_pattern_RE_CONTEXT_INDEP_ANCHORS); \
GET_ARGUMENT_Y("re_compile_pattern_RE_CONTEXT_INDEP_OPS=",re_compile_pattern_RE_CONTEXT_INDEP_OPS); \
GET_ARGUMENT_Y("re_compile_pattern_RE_CONTEXT_INVALID_OPS=",re_compile_pattern_RE_CONTEXT_INVALID_OPS); \
GET_ARGUMENT_Y("re_compile_pattern_RE_DOT_NEWLINE=",re_compile_pattern_RE_DOT_NEWLINE); \
GET_ARGUMENT_Y("re_compile_pattern_RE_DOT_NOT_NULL=",re_compile_pattern_RE_DOT_NOT_NULL); \
GET_ARGUMENT_Y("re_compile_pattern_RE_HAT_LISTS_NOT_NEWLINE=",re_compile_pattern_RE_HAT_LISTS_NOT_NEWLINE); \
GET_ARGUMENT_Y("re_compile_pattern_RE_INTERVALS=",re_compile_pattern_RE_INTERVALS); \
GET_ARGUMENT_Y("re_compile_pattern_RE_LIMITED_OPS=",re_compile_pattern_RE_LIMITED_OPS); \
GET_ARGUMENT_Y("re_compile_pattern_RE_NEWLINE_ALT=",re_compile_pattern_RE_NEWLINE_ALT); \
GET_ARGUMENT_Y("re_compile_pattern_RE_NO_BK_BRACES=",re_compile_pattern_RE_NO_BK_BRACES); \
GET_ARGUMENT_Y("re_compile_pattern_RE_NO_BK_PARENS=",re_compile_pattern_RE_NO_BK_PARENS); \
GET_ARGUMENT_Y("re_compile_pattern_RE_NO_BK_REFS=",re_compile_pattern_RE_NO_BK_REFS); \
GET_ARGUMENT_Y("re_compile_pattern_RE_NO_BK_VBAR=",re_compile_pattern_RE_NO_BK_VBAR); \
GET_ARGUMENT_Y("re_compile_pattern_RE_NO_EMPTY_RANGES=",re_compile_pattern_RE_NO_EMPTY_RANGES); \
GET_ARGUMENT_Y("re_compile_pattern_RE_UNMATCHED_RIGHT_PAREN_ORD=" \
,re_compile_pattern_RE_UNMATCHED_RIGHT_PAREN_ORD \
); \
GET_ARGUMENT_Y("re_compile_pattern_RE_NO_POSIX_BACKTRACKING=",re_compile_pattern_RE_NO_POSIX_BACKTRACKING); \
GET_ARGUMENT_Y("re_compile_pattern_RE_NO_GNU_OPS=",re_compile_pattern_RE_NO_GNU_OPS); \
GET_ARGUMENT_Y("re_compile_pattern_RE_DEBUG=",re_compile_pattern_RE_DEBUG); \
GET_ARGUMENT_Y("re_compile_pattern_RE_SYNTAX_EMACS=",re_compile_pattern_RE_SYNTAX_EMACS); \
GET_ARGUMENT_Y("re_compile_pattern_RE_SYNTAX_AWK=",re_compile_pattern_RE_SYNTAX_AWK); \
GET_ARGUMENT_Y("re_compile_pattern_RE_SYNTAX_GNU_AWK=",re_compile_pattern_RE_SYNTAX_GNU_AWK); \
GET_ARGUMENT_Y("re_compile_pattern_RE_SYNTAX_POSIX_AWK=",re_compile_pattern_RE_SYNTAX_POSIX_AWK); \
GET_ARGUMENT_Y("re_compile_pattern_RE_SYNTAX_GREP=",re_compile_pattern_RE_SYNTAX_GREP); \
GET_ARGUMENT_Y("re_compile_pattern_RE_SYNTAX_EGREP=",re_compile_pattern_RE_SYNTAX_EGREP); \
GET_ARGUMENT_Y("re_compile_pattern_RE_SYNTAX_POSIX_EGREP=",re_compile_pattern_RE_SYNTAX_POSIX_EGREP); \
GET_ARGUMENT_Y("re_compile_pattern_RE_SYNTAX_ED=",re_compile_pattern_RE_SYNTAX_ED); \
GET_ARGUMENT_Y("re_compile_pattern_RE_SYNTAX_SED=",re_compile_pattern_RE_SYNTAX_SED); \
GET_ARGUMENT_Y("re_compile_pattern__RE_SYNTAX_POSIX_COMMON=",re_compile_pattern__RE_SYNTAX_POSIX_COMMON); \
GET_ARGUMENT_Y("re_compile_pattern_RE_SYNTAX_POSIX_BASIC=",re_compile_pattern_RE_SYNTAX_POSIX_BASIC); \
GET_ARGUMENT_Y("re_compile_pattern_RE_SYNTAX_POSIX_MINIMAL_BASIC=" \
,re_compile_pattern_RE_SYNTAX_POSIX_MINIMAL_BASIC \
); \
GET_ARGUMENT_Y("re_compile_pattern_RE_SYNTAX_POSIX_EXTENDED=",re_compile_pattern_RE_SYNTAX_POSIX_EXTENDED); \
GET_ARGUMENT_Y("re_compile_pattern_RE_SYNTAX_POSIX_MINIMAL_EXTENDED=" \
,re_compile_pattern_RE_SYNTAX_POSIX_MINIMAL_EXTENDED \
); \
\
GET_ARGUMENT_Y("regexec_REG_NOTBOL=",regexec_REG_NOTBOL); \
GET_ARGUMENT_Y("regexec_REG_NOTEOL=",regexec_REG_NOTEOL); \
Eblock
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M P T E U R : */
/* */
/*************************************************************************************************************************************/
DEFV(Int,INIT(valeur_courante_du_compteur,VALEUR_INITIALE_DU_COMPTEUR));
DEFV(Int,INIT(increment_du_compteur,INCREMENT_DU_COMPTEUR));
DEFV(Int,INIT(nombre_de_chiffres_du_compteur,NOMBRE_DE_CHIFFRES_DU_COMPTEUR));
/* Le compteur a ete introduit le 20160813080723... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define MARQUEUR_DE_DEBUT_DE_LIGNE \
K_CIRCONFLEXE \
/* Pour reperer le debut de ligne dans une expression reguliere (le 20021206090948). */
#define MARQUEUR_DE_FIN_DE_LIGNE \
K_DOLLAR \
/* Pour reperer la fin de ligne dans une expression reguliere (le 20021207105825). */
#if ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
INIT_ERROR;
/* ATTENTION, la variable 'CODE_ERREUR' etant necessaire a 'ER ## ROR(code)' via la */
/* procedure 'CODE_ERROR(...)', le code de 'INIT_ERROR' doit etre defini avant ses */
/* references... */
DEFV(Local,DEFV(Char,INIT(POINTERc(expression_reguliere),ADRESSE_NON_ENCORE_DEFINIE)));
/* Chaine recherchee dans le fichier Argument. ATTENTION, cette definition doit etre */
/* imperativement avant l'include de '<regexp.h>' parce qu'elle lui est utile via la */
/* definition du pointeur 'sp'. Cette chaine est, dans le jargon de '$SE', ce que l'on */
/* appelle une "expression reguliere"... */
/* */
/* ATTENTION, on ne peut ecrire : */
/* */
/* DEFV(Local,DEFV(CHAR,INIC(POINTERc(expression_reguliere),C_VIDE))); */
/* */
/* car 'INIC(...)' utilise 'Finitialisation_d_une_constante_chaine_de_caracteres(...)' ce */
/* qui est interdit dans l'initialisation d'une variable 'Local'... */
DEFV(Local,DEFV(Char,INIT(POINTERc(expression_reguliere_compilee),ADRESSE_NON_ENCORE_DEFINIE)));
/* Chaine recherchee dans le fichier Argument apres sa "compilation"... */
@ define IN ## IT \
DEFV(Char,INIT(POINTERc(sp),expression_reguliere));
@ define GE ## TC() \
PARE(POINTEUR(SOUS(INCR(sp,I),I)))
@ define PE ## EKC() \
PARE(POINTEUR(sp))
@ define UNG ## ETC(caractere) \
DECR(sp,I)
@ define RET ## URN(pointeur) \
RETU(pointeur);
@ define ER ## ROR(code) \
CODE_ERROR(code);
/* ATTENTION, toutes les definitions ci-dessus sont transformees via l'operateur de */
/* concatenation ' ## ' afin qu'elles n'entrent pas en collision avec les miennes... */
@ define circf \
circf_pour_regexp
/* En effet, cette variable est deja definie (eventuellement, suivant les SYSTEMEs...) dans */
/* '/usr/include/gl/gl$h', d'ou cette astuce... */
/* A la date du 20210902101807, on NE passe PAS ici sur '$LACT1A' et '$LACT1B'... */
@ include <regexp.h>
/* ATTENTION cet include subit un traitement special ('v $xcc/cpp$Z regexp$h'). D'autre part */
/* differentes versions sont archivees dans '$DarchivesG/$ADMINISTRATEUR/?/usr/include/?/' */
/* au cas ou cette possibilite disparaitrait dans un avenir plus ou moins lointain (c'est */
/* ainsi annonce sur '$CMAP24' dans le manuel de 'regexp'...). */
/* */
/* ATTENTION : ci-dessus, les "*" ont ete remplacees par des '?' afin que le '/usr/include' */
/* ne ressemble pas a des commentaires... */
# if ( ((defined(SYSTEME_SG4D20G_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SG4D25TG_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SG4D310VGX_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SG4D35TG_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SG4D85GT_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND308_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
)
# define DEBUT_EXPRESSION(numero_de_l_expression) \
ptCARA(ITb1(_braslist,TRMU(numero_de_l_expression)))
# define SUITE_EXPRESSION(numero_de_l_expression) \
ptCARA(ITb1(_braelist,TRMU(numero_de_l_expression)))
/* Pour acceder a une sous-expressions avec un numero dans [0,9]... */
# Aif ( ((defined(SYSTEME_SG4D20G_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SG4D25TG_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SG4D310VGX_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SG4D35TG_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SG4D85GT_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND308_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
)
# define DEBUT_EXPRESSION(numero_de_l_expression) \
ptCARA(ITb1(braslist,TRMU(numero_de_l_expression)))
# define SUITE_EXPRESSION(numero_de_l_expression) \
ptCARA(ITb1(braelist,TRMU(numero_de_l_expression)))
/* Pour acceder a une sous-expressions avec un numero dans [0,9]... */
# Eif ( ((defined(SYSTEME_SG4D20G_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SG4D25TG_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SG4D310VGX_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SG4D35TG_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SG4D85GT_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND308_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND324_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND3GA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND408_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND424_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND4GA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND508_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND524_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND5GA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND808_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND824_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGIND8GA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGINDA08_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGINDA24_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGINDAGA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO200A1_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO200A2_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO200A4_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO25224_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO252VA_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGO252VN_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGPCM801_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
|| ((defined(SYSTEME_SGPCMA01_IRIX_CC)) && (nSYSTEM_RELEASE >= 601000000)) \
)
# define DEBUT_DE_L_OCCURENCE_COURANTE \
ptCARA(loc1)
# define SUITE_DE_L_OCCURENCE_COURANTE \
ptCARA(loc2)
/* Pour disposer de symboles plus significatifs et convertis du type 'Char' en 'CHAR'. */
# define NOMBRE_DE_SOUS_EXPRESSIONS \
nbra \
/* Nombre de sous-expressions de type "\X" ou 'X' est un entier dans [0,9]. */
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
@ define __USE_GNU
/* Introduit le 20100525132425 pour la procedure 'v /usr/include/regex$h __REPB_PREFIX' mal */
/* definie, probleme rencontre a cette date sur '$CMAP28' (="abbesses.polytechnique.fr")... */
/* A la date du 20210902101807, on passe ici sur '$LACT1A' et '$LACT1B'... */
# if ( (defined(LACT1B)) \
)
@ include regex_h__
# Aif ( (defined(LACT1B)) \
)
@ include <regex.h>
# Eif ( (defined(LACT1B)) \
)
/* ATTENTION, cet include subit un traitement special ('v $xcc/cpp$Z regex$h'). */
# if ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
# ifndef REG_BASIC
# if ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
)
@ define REG_BASIC \
REG_NEWLINE
# Aif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
)
# Eif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
)
# if ( (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
@ define REG_BASIC \
RE_SYNTAX_SED
# Aif ( (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
# Eif ( (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
/* ATTENTION, on notera le cas particulier de 'SYSTEME_APC_LinuxRedHat...' qui ne possede */
/* pas le mode 'REG_BASIC' mais uniquement des modes obtenus par combinaison de modes */
/* elementaires definis a partir de 'v /usr/include/regex.h REG_EXTENDED'. Certaines */
/* combinaisons sont predefinies telle 'v /usr/include/regex.h RE_SYNTAX_SED'... */
/* */
/* La variable 'RE_SYNTAX_SED' est definie comme un "ou logique" des indicateurs : */
/* */
/* RE_BK_PLUS_QM */
/* RE_CHAR_CLASSES */
/* RE_DOT_NEWLINE */
/* RE_DOT_NOT_NULL */
/* RE_INTERVALS */
/* RE_NO_EMPTY_RANGES */
/* */
/* le 19991207084551, en "release" 202050000. Malheureusement, ce mode ne gere pas les */
/* occurences "\n" dans les chaines Argument. Il a donc fallu introduire le 19991209094947 */
/* 'v $xig/fonct$vv$FON MOVE_CARACTERE_____substituer_K_LF_au_couple_K_ANTI_SLASH__K_n'. */
/* Au passage, je n'ai pas trouve de solution plus simple et ne faisant intervenir que */
/* '<regex.h>'... */
/* */
/* Le 20021108211604, j'ai efface l'indicateur 'REG_ICASE' qui, chose bizarre, contrairement */
/* a ce que l'on peut deduire de 'v /usr/include/regex$h REG_ICASE', semble faire partie de */
/* la definition de 'RE_SYNTAX_SED' (ou peut-etre est-il positionne par defaut dans la */
/* librairie correspondante...) car, en effet, avant cette date, les recherches de */
/* caracteres ignoraient les differences entre majuscules et minuscules ; cela a pu etre */
/* confirme et teste grace au programme 'v $xtc/regul_exp.31$c REG_ICASE'. Le 20021109232022 */
/* je suis passe de 'OUEX(...)' a 'MASQUE_RESET_BIT(...)' car, en effet, 'OUEX(...)' inverse */
/* le bit 'REG_ICASE' et si par malheur, dans une version future il etait a 0 (et non plus a */
/* 1 comme c'est le cas a cette date) le 'OUEX(...)' le positionnerait a 1... */
/* */
/* Le 20021202171344, j'ai essaye de remettre 'RE_DOT_NEWLINE' afin que le caractere "." */
/* puisse etre identifie a un "\n" dans une expression et ce via la definition : */
/* */
/* MASQUE___SET_BIT(MASQUE_RESET_BIT(RE_SYNTAX_SED,REG_ICASE),RE_DOT_NEWLINE) */
/* */
/* mais cela ne marche pas ; le "." ne represente jamais un "\n"... */
/* */
/* En fait, le 20021204141037, il semblerait que le probleme de 'REG_ICASE' resolu par : */
/* */
/* MASQUE_RESET_BIT(RE_SYNTAX_SED,REG_ICASE) */
/* */
/* et celui de 'RE_DOT_NEWLINE' soient resolus simultanement en utilisant 'ZERO' comme */
/* definition de 'REG_BASIC'. Le 20021204145824, je suis passe de 'ZERO' a la valeur */
/* 'REG_NEWLINE' afin que l'on puisse ecrire "^..." pour indiquer un debut de ligne. */
/* On notera au passage que le programme 'v $xtc/regul_exp.51$c' permet de connaitre la */
/* valeur en hexa-decimale de tous les parametres possibles... */
# Aifndef REG_BASIC
# Eifndef REG_BASIC
# Aif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
# Eif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
TypedefP(ExpressionReguliere,regex_t)
TypedefP(ListeOccurence,regmatch_t)
# define NOMBRE_D_OCCURENCES_RECHERCHEES \
SUCC(NEUF) \
/* Nombre d'occurences recherchees pour 'chaine_recherchee_dans_fichierA' ; 'NEUF' etant */ \
/* destine aux sous-expressions et 'SUCC(...)' aux eventuelles sous-expressions... */
# define OCCURENCE_COURANTE \
PRED(NUMERO_DE_L_EVENTUELLE_PREMIERE_SOUS_EXPRESSION) \
/* Numero de l'occurence courante. */
# define DEBUT_EXPRESSION(numero_de_l_expression) \
ADD2(sous_fichierA,ASD1(ITb1(liste_des_occurences,numero_de_l_expression),rm_so))
# define SUITE_EXPRESSION(numero_de_l_expression) \
ADD2(sous_fichierA,ASD1(ITb1(liste_des_occurences,numero_de_l_expression),rm_eo))
/* Pour acceder a une expression ou 'numero_de_l_expression' vaut 'OCCURENCE_COURANTE' pour */
/* l'occurence entiere, et un numero dans [0,9] pour les sous-expressions... */
# define DEBUT_DE_L_OCCURENCE_COURANTE \
DEBUT_EXPRESSION(OCCURENCE_COURANTE)
# define SUITE_DE_L_OCCURENCE_COURANTE \
SUITE_EXPRESSION(OCCURENCE_COURANTE)
/* Pour acceder a l'occurence courante... */
# define NOMBRE_DE_SOUS_EXPRESSIONS \
ASD1(expression_reguliere_compilee,re_nsub) \
/* Nombre de sous-expressions de type "\X" ou 'X' est un entier dans [0,9]. */
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#define NUMERO_DE_L_EVENTUELLE_PREMIERE_SOUS_EXPRESSION \
UN \
/* Numero de la premiere sous-expression... */
#define SOUS_EXPRESSION_COURANTE \
est_ce_alpha_numerique_____valeur_numerique \
/* Numero de la sous-expression courante referencee par un "\X" ou 'X' est dans [1,9]. */
#define LONGUEUR_MAXIMALE_DE_L_EXPRESSION_REGULIERE \
DEUX_CENT_CINQUANTE_SIX \
/* Longueur maximale de la chaine 'expression_reguliere' avant sa "compilation"... */ \
/* ATTENTION, cette limite semble venir (uniquement ?) de 'SYSTEME_SG...' lorsque l'on */ \
/* est en 'EXPRESSION_REGULIERE_VERSION_02' ; mais pour des raisons de portabilite des */ \
/* differents utilitaires utilisant '$xcp/substitue.01$X', il est imperatif d'imposer cette */ \
/* limite a tout le monde... */
#if ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
# define GET_ARGUMENT_I_CONFIGURATION_DYNAMIQUE_DU_COMPORTEMENT \
Bblock \
Eblock
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
DEFV(Local,DEFV(Positive,INIT(configuration_de_compilation_des_expressions_anterieure,UNDEF)));
DEFV(Local,DEFV(Positive,INIT(configuration_de_compilation_des_expressions,REG_BASIC)));
DEFV(Local,DEFV(Positive,INIT(configuration_d_appariement_des_expressions,ZERO)));
/* Afin de changer dynamiquement le comportement de '$xcp/substitue.01$K' (introduit le */
/* 20021204134841 et complete le 20021204155046). La version anterieure de la syntaxe */
/* 'configuration_de_compilation_des_expressions_anterieure' a ete introduite le */
/* 20021209122756 lors de l'introduction de la fonction 're_set_syntax(...)'... */
# define GET_ARGUMENT_I_CONFIGURATION_DYNAMIQUE_DU_COMPORTEMENT \
Bblock \
GET_ARGUMENT_X("compile=""compilation=",configuration_de_compilation_des_expressions); \
GET_ARGUMENT_X("matching=""appariement=",configuration_d_appariement_des_expressions); \
Eblock \
/* Parametrage dynamique de 'regcomp(...)' et de 'regexec(...)'. */
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#define GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(numero) \
DEFV(CHAR,INIC(POINTERc(chaine`numero`recherchee_dans_fichierA),C_VIDE)); \
DEFV(CHAR,INIC(POINTERc(chaine`numero`a_substituer_dans_fichierR),C_VIDE)); \
/* Allocation de la memoire utiles aux differentes chaines... */
#define GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(nom,numero) \
Bblock \
\
DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
/* Introduit le 20070130102637 car, en effet, il manquait... */ \
\
GET_ARGUMENT_C("chercher"nom"=""cherchee"nom"=""c"nom"=",chaine`numero`recherchee_dans_fichierA); \
GET_ARGUMENT_C("substituer"nom"=""substituee"nom"=""s"nom"=",chaine`numero`a_substituer_dans_fichierR); \
\
FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
/* Introduit le 20070130102637 car, en effet, il manquait... */ \
\
Eblock \
/* Entree d'une chaine a chercher et de celle a lui substituer... */ \
/* */ \
/* On notera le 20040630124810 que les chaines a rechercher et a substituer sont donc */ \
/* entrees via 'FconversionC(...)' qui fait ses lectures via le format 'FORMAT_CHAI' */ \
/* ('v $xig/fonct$vv$FON GENERE__FonctionC_FconversionC') or ce format contient "\t" */ \
/* et "\n" qui sont donc remplaces des cette lecture par leur valeurs "\011" et "\012" */ \
/* respectivement. Il est donc quasiment impossible de rentrer en tant que chaine a */ \
/* rechercher ou a substituer la chaine faite des deux caracteres "\n" (soit "\" et "n" */ \
/* concatenes) puisque "\n" est automatiquement remplace par "\012". Il en est de meme de */ \
/* "\t" evidemment... */
#define CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(numero) \
CAse_SEQUENTIEL \
Bblock \
MISE_EN_PLACE_DES_CHAINES(chaine`numero`recherchee_dans_fichierA,chaine`numero`a_substituer_dans_fichierR); \
/* Mise en place des differentes chaines... */ \
Eblock \
ECAs_SEQUENTIEL \
/* Prise en compte d'une chaine a chercher et de celle a lui substituer... */
#define MISE_EN_PLACE_DES_CHAINES(chaine_NM_recherchee_dans_fichierA,chaine_NM_a_substituer_dans_fichierR) \
Bblock \
DEFV(Int,INIT(EnTete_de_sauvegardM ## MOVE_CARACTERE_____mettre_un_K_ANTI_SLASH_devant_chaque_K_POINT \
,MOVE_CARACTERE_____mettre_un_K_ANTI_SLASH_devant_chaque_K_POINT \
) \
); \
\
Test(IFGT(chain_taille(chaine_NM_recherchee_dans_fichierA),LONGUEUR_MAXIMALE_DE_L_EXPRESSION_REGULIERE)) \
Bblock \
PRINT_ERREUR("une expression reguliere est trop longue"); \
CAL1(Prer1("expression reguliere = '%s'\n",chaine_NM_recherchee_dans_fichierA)); \
CAL1(Prer1("longueur............ = %d\n",chain_taille(chaine_NM_recherchee_dans_fichierA))); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
EGAL(MOVE_CARACTERE_____mettre_un_K_ANTI_SLASH_devant_chaque_K_POINT,backslasher_les_points); \
EGAL(chaine_recherchee_dans_fichierA,chain_Acopie(chaine_NM_recherchee_dans_fichierA)); \
EGAL(MOVE_CARACTERE_____mettre_un_K_ANTI_SLASH_devant_chaque_K_POINT \
,EnTete_de_sauvegardM ## MOVE_CARACTERE_____mettre_un_K_ANTI_SLASH_devant_chaque_K_POINT \
); \
/* Copie de la chaine Argument avec substitution eventuelle des "." par des "\.". */ \
EGAL(chaine_a_substituer_dans_fichierR,chain_Acopie(chaine_NM_a_substituer_dans_fichierR)); \
/* Copie de la chaine Resultat. */ \
\
EGAL(index_de_fin_de_la_chaine_a_substituer_dans_fichierR \
,LSTX(PREMIER_CARACTERE,chain_Xtaille(chaine_a_substituer_dans_fichierR)) \
); \
Eblock \
/* Procedure de mise en place de la chaine recherchee dans le fichier Argument et de la */ \
/* chaine a lui substituer. */
#define veritable_fichierA \
COND(EST_VRAI(fichierA_vers_fichierR),fichierA,fichierR)
#define veritable_fichierR \
COND(EST_VRAI(fichierA_vers_fichierR),fichierR,fichierA)
/* Pour acceder aux fichiers courants 'fichierA' et 'fichierR'. */
#define STORE_FICHIER(caractere_courant,index_du_caractere_courant,veritable_fichier,longueur_maximale_du_fichier) \
Bblock \
Test(IFLE(index_du_caractere_courant,LSTX(PREMIER_CARACTERE,longueur_maximale_du_fichier))) \
Bblock \
/* Cas ou il y a encore de la place dans le fichier... */ \
Eblock \
ATes \
Bblock \
/* Cas ou il n'y a plus de place dans le fichier... */ \
DEFV(Int,INIT(index_d_extension,UNDEF)); \
DEFV(Int,INIT(longueur_maximale_du_veritable_fichier_etendu,DOUB(longueur_maximale_du_fichier))); \
DEFV(CHAR,INIT(POINTERc(veritable_fichier_etendu),CHAINE_UNDEF)); \
EGAL(veritable_fichier_etendu,kMalo(longueur_maximale_du_veritable_fichier_etendu)); \
/* Extension du fichier par doublement de sa longueur... */ \
DoIn(index_d_extension,PREMIER_CARACTERE,LSTX(PREMIER_CARACTERE,longueur_maximale_du_fichier),I) \
Bblock \
EGAL(ITb0(veritable_fichier_etendu,INDX(index_d_extension,PREMIER_CARACTERE)) \
,ITb0(veritable_fichier,INDX(index_d_extension,PREMIER_CARACTERE)) \
); \
/* Extension du fichier par duplication des caracteres deja possedes. */ \
Eblock \
EDoI \
\
CALZ(FreFF(veritable_fichier)); \
/* Puis liberation de l'espace possede anterieurement par le fichier. */ \
/* */ \
/* ATTENTION, on ne peut ecrire ici : */ \
/* */ \
/* CALZ_FreFF(veritable_fichier); */ \
/* */ \
/* car, en effet, 'veritable_fichier' n'est pas un "simple pointeur". Il s'agit en fait */ \
/* de 'veritable_fichierA' ou de 'veritable_fichierR' qui sont eux-memes des 'COND(...)'s... */ \
/* Mais il ne faut surtout pas faire ensuite : */ \
/* */ \
/* Test(EST_VRAI(fichierA_vers_fichierR)) \ */ \
/* Bblock \ */ \
/* EGAL(fichierA,ADRESSE_PLUS_DEFINIE); \ */ \
/* Eblock \ */ \
/* ATes \ */ \
/* Bblock \ */ \
/* EGAL(fichierR,ADRESSE_PLUS_DEFINIE); \ */ \
/* Eblock \ */ \
/* ETes \ */ \
/* */ \
/* car, en effet, 'fichierA' et 'fichierR' sont encore utiles et il ne seront "liberes" */ \
/* que tout a la fin par : */ \
/* */ \
/* CALZ_FreFF(fichierR); */ \
/* CALZ_FreFF(fichierA); */ \
/* */ \
\
Test(IFEQ(IDENTITE(veritable_fichier),IDENTITE(fichierA))) \
Bblock \
EGAL(IDENTITE(fichierA),IDENTITE(veritable_fichier_etendu)); \
Eblock \
ATes \
Bblock \
Test(IFEQ(IDENTITE(veritable_fichier),IDENTITE(fichierR))) \
Bblock \
EGAL(IDENTITE(fichierR),IDENTITE(veritable_fichier_etendu)); \
/* Et enfin substitution du fichier etendu au fichier courant. On notera que l'on ne */ \
/* peut malheureusement pas ecrire : */ \
/* */ \
/* EGAL(IDENTITE(veritable_fichier),IDENTITE(veritable_fichier_etendu)); */ \
/* */ \
/* d'ou ces tests... */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("un fichier 'inconnu' est en cours d'extension -1-"); \
Eblock \
ETes \
Eblock \
ETes \
\
Test(IFEQ(IDENTITE(longueur_maximale_du_fichier),IDENTITE(longueur_maximale_du_fichier_Argument))) \
/* Cette serie de deux tests sur 'longueur_maximale_du_fichier' ont ete introduits le */ \
/* 20051125104737 car ils manquaient... */ \
/* */ \
/* Le 20051128091042 je crois avoir compris pourquoi cette grave anomalie n'avait jamais */ \
/* provoque d'incidents. En effet, a cette date, je testais 'v $xcc/cpp$Z 20051124091557'. */ \
/* Pour ce faire, j'avais un petit fichier de test 'F1' a transformer qui faisait 288 */ \
/* octets. Le fichier '$U' de transformation etait un sous-ensemble du fichier */ \
/* 'v $xccp/PASSE_4.NomF$sub' (uniquement les transformations {c25,c26}). Le resultat de */ \
/* cette transformation faisait 331 octets. Les deux facteurs {fA,fR} valaient (valeurs */ \
/* par defaut) respectivement 1.1 et 1.5, d'ou des tailles etendues pour les fichiers */ \
/* 'A' et 'R' : */ \
/* */ \
/* fichierA : 288x1.1 = 316 ------ */ \
/* fichierR : 288x1.5 = 432 | */ \
/* | */ \
/* Ainsi : | */ \
/* | */ \
/* 331 > 316 <------------------- */ \
/* */ \
/* et donc il y avait debordement immediat. Cela ne s'etait donc jamais vu anterieurement */ \
/* car certainement jaimais aucun fichier n'avait eu un taux d'expansion (331/288 = 1.149) */ \
/* aussi eleve... */ \
Bblock \
EGAL(longueur_maximale_du_fichier_Argument,longueur_maximale_du_veritable_fichier_etendu); \
/* La longueur est enfin double au cas ou il faudrait de nouveau etendre.... */ \
Eblock \
ATes \
Bblock \
Test(IFEQ(IDENTITE(longueur_maximale_du_fichier),IDENTITE(longueur_maximale_du_fichier_Resultat))) \
Bblock \
EGAL(longueur_maximale_du_fichier_Resultat,longueur_maximale_du_veritable_fichier_etendu); \
/* La longueur est enfin double au cas ou il faudrait de nouveau etendre.... */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("un fichier 'inconnu' est en cours d'extension -2-"); \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ETes \
\
EGAL(ITb0(veritable_fichier,INDX(index_du_caractere_courant,PREMIER_CARACTERE)),caractere_courant); \
/* Rangement du caractere courant du fichier. */ \
INCR(index_du_caractere_courant,I); \
/* Progression de l'index de rangement dans le fichier. */ \
Eblock
#define GENERE_FICHIER_RESULTAT(caractere) \
Bblock \
STORE_FICHIER(caractere \
,index_du_caractere_courant_de_fichierR \
,veritable_fichierR \
,longueur_maximale_du_fichier_Resultat \
); \
Eblock \
/* Procedure de mise a jour du fichier Resultat. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D E S ' K_LF ' S D E D E B U T E T D E F I N D E F I C H I E R */
/* I N T R O D U I T L E 20021213121628 : */
/* */
/*************************************************************************************************************************************/
#define AJOUTER_UN_K_LF_AU_DEBUT_DU_FICHIER_A_PRIORI \
FAUX
#define AJOUTER_UN_K_LF_AU_DEBUT_DU_FICHIER_S_IL_MANQUE \
FAUX
#define AJOUTER_UN_K_LF_A_LA_FIN_DU_FICHIER_A_PRIORI \
FAUX
#define AJOUTER_UN_K_LF_A_LA_FIN_DU_FICHIER_S_IL_MANQUE \
FAUX
DEFV(Local,DEFV(Logical,INIT(ajouter_un_K_LF_au_debut_du_fichier_a_priori,AJOUTER_UN_K_LF_AU_DEBUT_DU_FICHIER_A_PRIORI)));
DEFV(Local,DEFV(Logical,INIT(ajouter_un_K_LF_au_debut_du_fichier_s_il_manque,AJOUTER_UN_K_LF_AU_DEBUT_DU_FICHIER_S_IL_MANQUE)));
DEFV(Local,DEFV(Logical,INIT(ajouter_un_K_LF_a_la_fin_du_fichier_a_priori,AJOUTER_UN_K_LF_A_LA_FIN_DU_FICHIER_A_PRIORI)));
DEFV(Local,DEFV(Logical,INIT(ajouter_un_K_LF_a_la_fin_du_fichier_s_il_manque,AJOUTER_UN_K_LF_A_LA_FIN_DU_FICHIER_S_IL_MANQUE)));
/* Gestion des 'K_LF's au debut et a la fin du fichier... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T R A C E D E S S U B S T I T U T I O N S I N T R O D U I T L E 20021215084025 : */
/* */
/*************************************************************************************************************************************/
#define TRACER_LES_SUBSTITUTIONS \
FAUX
DEFV(Local,DEFV(Logical,INIT(tracer_les_substitutions,TRACER_LES_SUBSTITUTIONS)));
/* Afin de tracer les substitutions... */
#define EDITER_LES_OCCURENCES \
FAUX
DEFV(Local,DEFV(Logical,INIT(editer_les_occurences,EDITER_LES_OCCURENCES)));
/* Afin d'editer les occurences (introduit le 20040113142212) et permettre ainsi un */
/* fonctionnement de type '$EGRE' en conjonction avec l'utilisation du parametre */
/* 'IL_NE_FAUT_PAS(sortir_le_fichier_substitue)'. Pour ce faire, on utilisera la */
/* suite de parametres : */
/* */
/* sortir=FAUX */
/* tracer=VRAI */
/* EGRE=VRAI */
/* */
/* ou l'un de leurs synonymes... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N T R O L E D E L A S O R T I E I N T R O D U I T L E 20040113142212 : */
/* */
/*************************************************************************************************************************************/
#define SORTIR_LE_FICHIER_SUBSTITUE \
VRAI
DEFV(Local,DEFV(Logical,INIT(sortir_le_fichier_substitue,SORTIR_LE_FICHIER_SUBSTITUE)));
/* Doit-on sortir le fichier substitue ('VRAI') ou pas ('FAUX') ? Cela a ete introduit le */
/* 20040113142212 dans le but de permettre un usage du type '$EGRE'... */
#define SORTIE_D_UN_CARACTERE(caractere) \
Bblock \
Test(IL_FAUT(sortir_le_fichier_substitue)) \
Bblock \
CALS(Putchar(caractere)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Sortie eventuelle d'un caractere. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* S U B S T I T U T I O N D E C A R A C T E R E S D A N S U N F I C H I E R : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
#if ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
/* ATTENTION, la variable 'CODE_ERREUR' etant necessaire a 'ER ## ROR(code)' via la */
/* procedure 'CODE_ERROR(...)', le code de 'INIT_ERROR' doit etre defini avant ses */
/* references... */
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
INIT_ERROR;
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
DEFV(Positive,INIT(nombre_d_iterations_des_substitutions,NOMBRE_D_ITERATIONS_DES_SUBSTITUTIONS));
/* Nombre d'iterations des substitutions (introduit le 20101227105651). */
DEFV(Logical,INIT(le_premier_caractere_du_fichier_a_ete_traite,FAUX));
/* Afin d'aider a la gestion des 'K_LF's au debut du fichier... */
DEFV(Logical,INIT(backslasher_les_points,BACKSLASHER_LES_POINTS));
/* A priori, les "." ne devront pas etre remplaces par des "\." (fonctionnement de type */
/* '$SE') ; ceci a ete introduit le 20001227104156. Ce dispositif permet, en particulier, */
/* de manipuler des noms de fichiers, qui contiennent bien souvent des ".", sans ambiguite. */
DEFV(Logical,INIT(conserver_les_K_LF_contenus_dans_les_sous_chaines_definies
,CONSERVER_LES_K_LF_CONTENUS_DANS_LES_SOUS_CHAINES_DEFINIES
)
);
/* Ce dispositif a ete introduit le 20040514150215 afin de permettre d'eliminer les 'K_LF' */
/* qui sont contenus dans les sous-chaines defines par '\(...\)' et qui sont ensuite */
/* dupliquees par des ecritures du type '\1'. Cela permet, par exemple, de regrouper les */
/* arguments d'une fonction en utilisant cet indicateur a 'FAUX' et les arguments : */
/* */
/* conserver_les_K_LF=FAUX */
/* c01="\(Fonction([^)][^)]*)\)" s01="\1" */
/* */
/* Pour regrouper les arguments d'une fonction avec leurs definitions, on utilisera : */
/* */
/* conserver_les_K_LF=FAUX */
/* c01="\(Fonction([^{][^{]*\)\({\)" s01="\1\n\2" */
/* */
/* Evidemment, cela concerne des fichiers de type '$c'... */
DEFV(Logical,INIT(conserver_les_K_BLANC_contenus_dans_les_sous_chaines_definies
,CONSERVER_LES_K_BLANC_CONTENUS_DANS_LES_SOUS_CHAINES_DEFINIES
)
);
/* Ce dispositif a ete introduit le 20040526142735 afin de permettre d'eliminer les */
/* 'K_BLANC' dans les memes conditions que les 'K_LF' ci-dessus, mais cette fois en ce */
/* qui concerne des fichiers de type '$K' en utilisant cet indicateur a 'FAUX' (ainsi */
/* que celui relatif a 'K_LF') et les arguments : */
/* */
/* conserver_les_K_BLANC=FAUX */
/* conserver_les_K_LF=FAUX */
/* c01="^\(DEFV(Common,DEFV(Fonction[^;]*\)\n" s01="\1\n" */
/* */
/* Le 20040526161746, la commande 'v $xcg/LArgTypFo$vv$Z' a ete introduite pour automatiser */
/* ce type de modification... */
DEFV(Logical,INIT(permuter_les_minuscules_et_les_majuscules,FAUX));
/* Ce dispositif a ete introduit le 20090108094506 afin de permettre de permuter les */
/* minuscules et les majuscules dans les sous chaines "\(...\)". */
DEFV(Logical,INIT(remplacer_un_caractere_contenu_dans_les_sous_chaines_definies
,REMPLACER_UN_CARACTERE_CONTENU_DANS_LES_SOUS_CHAINES_DEFINIES
)
);
DEFV(Logical,INIT(le_caractere_a_remplacer_dans_les_sous_chaines_definies_est_quelconque
,LE_CARACTERE_A_REMPLACER_DANS_LES_SOUS_CHAINES_DEFINIES_EST_QUELCONQUE
)
);
DEFV(Char,INIT(caractere_a_remplacer_dans_les_sous_chaines_definies
,CARACTERE_A_REMPLACER_DANS_LES_SOUS_CHAINES_DEFINIES
)
);
DEFV(Char,INIT(caractere_de_remplacement_dans_les_sous_chaines_definies
,CARACTERE_DE_REMPLACEMENT_DANS_LES_SOUS_CHAINES_DEFINIES
)
);
/* Ce dispositif a ete introduit le 20090108094506 afin de permettre de permuter les */
/* minuscules et les majuscules dans les sous chaines "\(...\)". */
/* Ce dispositif a ete introduit le 20040601111701 afin de faciliter le passage de */
/* l'ecriture : */
/* */
/* type Fonction(arg1,arg2,...) */
/* type1 arg1; */
/* type2 arg2; */
/* (...) */
/* { */
/* */
/* a l'ecriture : */
/* */
/* type Fonction(type1 arg1,type2 arg2,...) */
/* { */
/* */
/* en utilisant specifiquement pour la fonction 'Fonction(...)' : */
/* */
/* conserver_les_K_BLANC=VRAI */
/* conserver_les_K_LF=FAUX */
/* remplacer_un_caractere=VRAI caractereA=";" caractereR="," */
/* c01="\([ \n]\)\(Fonction(\)[^)]*)\([^{][^{]*\)\({\)" s01="\1\2\3)\n\4" */
/* c02=", *\()\)" s02="\1" */
/* */
/* ou plus generalement (pour toutes les fonctions) ou 'DebutDeDefinitionDeFonction' est */
/* represente par 'Debut' (pour reduire la longueur des lignes ci-apres...) : */
/* */
/* conserver_les_K_BLANC=VRAI */
/* conserver_les_K_LF=FAUX */
/* remplacer_un_caractere=VRAI caractereA=";" caractereR="," */
/* c01="\n\(Debut [^(]*[^*](\)[^)]*)\([^{][^{]*\)\({\)" s01="\n\1\2)\n\3" */
/* c02="\n\(Debut [^(]*\*([^(]*(\)[^)]*))\([^{][^{]*\)\({\)" s02="\n\1\2))\n\3" */
/* c11=", *\()\)" s11="\1" */
/* */
/* Evidemment, cela concerne des fichiers de type '$c'... */
/* */
/* */
/* Le 20230414134056, fut donc introduite la bascule {\Q,\q} rendant quelconque le */
/* caractere a remplacer... */
DEFV(Int,INIT(longueur_maximale_du_fichier_Argument,LONGUEUR_MAXIMALE_DU_FICHIER_ARGUMENT));
/* Longueur maximale du fichier Argument. */
DEFV(CHAR,INIT(POINTERc(fichierA),CHAINE_UNDEF));
/* Afin de creer dynamiquement le fichier Argument. */
DEFV(CHAR,INIT(POINTERc(sous_fichierA),CHAINE_UNDEF));
/* Afin de manipuler un sous-ensemble du fichier Argument. */
/* */
/* ATTENTION, a cause de l'appel : */
/* */
/* step(Cara(sous_fichierA),...) */
/* */
/* il est difficile de se passer de 'sous_fichierA' en tant que 'POINTERc(...)' qui varie */
/* au cours du temps. Il aurait ete preferable que sa valeur ne change pas, et que ne soit */
/* utilise qu'un index 'index_du_caractere_courant_de_sous_fichierA'... */
DEFV(Int,INIT(index_du_caractere_courant_de_fichierA,PREMIER_CARACTERE));
/* Index du caractere courant du fichier Argument. */
DEFV(Int,INIT(index_du_dernier_caractere_de_fichierA,UNDEF));
/* Index du dernier caractere du fichier Argument. */
DEFV(Float,INIT(facteur_d_expansion_du_fichier_Argument,FACTEUR_D_EXPANSION_DU_FICHIER_ARGUMENT));
/* Facteur de passage de la taille du fichier Argument a la taille du fichier Argument */
/* reellement utilisee. */
DEFV(Float,INIT(facteur_d_expansion_du_fichier_Resultat,FACTEUR_D_EXPANSION_DU_FICHIER_RESULTAT));
/* Facteur de passage de la taille du fichier Argument a la taille du fichier Resultat. */
DEFV(Int,INIT(longueur_maximale_du_fichier_Resultat,UNDEF));
/* Longueur maximale du fichier Resultat. */
DEFV(CHAR,INIT(POINTERc(fichierR),CHAINE_UNDEF));
/* Afin de creer dynamiquement le fichier Resultat. */
DEFV(Int,INIT(index_du_caractere_courant_de_fichierR,UNDEF));
/* Index du caractere courant du fichier Resultat. */
DEFV(Int,INIT(index_du_dernier_caractere_de_fichierR,UNDEF));
/* Index du dernier caractere du fichier Resultat. */
DEFV(Logical,INIT(transferer_le_fichierA_tel_quel,LUNDEF));
/* Pour transferer le fichier Argument lorsque il n'y a pas de substitution a faire ou */
/* bien lorsqu'il y une faute dans la syntaxe de la substitution... */
DEFV(Char,INIT(caractere_courant,K_UNDEF));
/* Caractere courant. */
DEFV(Logical,INIT(proceder_aux_substitutions,VRAI));
/* Pour indiquer qu'il faut faire les substitutions... */
DEFV(Logical,INIT(fichierA_vers_fichierR,VRAI));
/* Pour permettre la definition de 'veritable_fichierA' et 'veritable_fichierR'. */
DEFV(Logical,INIT(iterer_la_substitution,LUNDEF));
/* Pour controler l'iteration de substitution... */
DEFV(Int,INIT(numero_de_la_substitution,ZERO));
/* Numero de la substitution courante. */
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(00);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(01);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(02);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(03);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(04);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(05);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(06);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(07);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(08);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(09);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(10);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(11);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(12);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(13);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(14);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(15);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(16);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(17);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(18);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(19);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(20);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(21);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(22);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(23);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(24);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(25);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(26);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(27);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(28);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(29);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(30);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(31);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(32);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(33);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(34);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(35);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(36);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(37);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(38);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(39);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(40);
GENERATION_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(41);
/* Generation des chaines recherchees dans le fichier Argument et des chaines a substituer. */
/* La chaine '41' a ete introduite le 20030303135638 pour 'v $xcc/cpp$Z c41='. */
DEFV(CHAR,INIC(POINTERc(chaine_recherchee_dans_fichierA),C_VIDE));
DEFV(CHAR,INIC(POINTERc(chaine_a_substituer_dans_fichierR),C_VIDE));
DEFV(Int,INIT(index_de_fin_de_la_chaine_a_substituer_dans_fichierR,UNDEF));
/* Chaine courante recherchee dans le fichier Argument et la chaine a lui substituer. */
#if ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
DEFV(Char,INIT(POINTERc(expression_reguliere),ADRESSE_NON_ENCORE_DEFINIE));
/* Chaine recherchee dans le fichier Argument. */
DEFV(ExpressionReguliere,expression_reguliere_compilee);
/* Chaine recherchee dans le fichier Argument apres sa "compilation"... */
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
DEFV(Int,INIT(longueur_maximale_de_l_expression_reguliere_compilee,LONGUEUR_MAXIMALE_DE_L_EXPRESSION_REGULIERE_COMPILEE));
/* Longueur maximale de la chaine 'expression_reguliere' apres sa "compilation". On notera */
/* que ceci n'a en fait de sens qu'avec 'EXPRESSION_REGULIERE_VERSION_01'... */
/*..............................................................................................................................*/
#if ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
EGAL(MOVE_CARACTERE_____substituer_K_LF_au_couple_K_ANTI_SLASH__K_n,VRAI);
/* Ceci a ete introduit le 19991209094947 afin de permettre la gestion correcte des */
/* codes "\n" dans les chaines Argument... */
#Aif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
#Eif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
EGAL(MOVE_CARACTERE_____substituer_K_TABULATION_au_couple_K_ANTI_SLASH__K_t,VRAI);
/* Ceci a ete introduit le 20010109111515 afin de permettre la gestion systematique des */
/* codes "\t" dans les chaines Argument... */
#define GET_ARGUMENT_L_CONSERVER_LES_K_LF_CONTENUS_DANS_LES_SOUS_CHAINES_DEFINIES \
"conserver_les_K_NL=""conserver_les_K_LF=""conserver_K_NL=""conserver_K_LF=""cons_K_NL=""cons_K_LF="
#define GET_ARGUMENT_N_CONSERVER_LES_K_LF_CONTENUS_DANS_LES_SOUS_CHAINES_DEFINIES \
"supprimer_les_K_NL=""supprimer_les_K_LF=""supprimer_K_NL=""supprimer_K_LF=""sup_K_NL=""sup_K_LF="
/* Afin de raccourcir les lignes qui suivent (introduit le 20070223103454). */
GET_ARGUMENTS_(nombre_d_arguments
,BLOC(GET_ARGUMENT_I("nombre_iterations_substitutions=""iterations=""iter=",nombre_d_iterations_des_substitutions);
/* Argument introduit le 20101227105651 pour 'v $xcc/cpp$Z nombre_iterations_substitutions'. */
GET_ARGUMENT_I("longueurA=""lA=""LA=",longueur_maximale_du_fichier_Argument);
GET_ARGUMENT_F("facteurA=""fA=",facteur_d_expansion_du_fichier_Argument);
GET_ARGUMENT_F("facteurR=""fR=""expansion=",facteur_d_expansion_du_fichier_Resultat);
GET_ARGUMENT_I("longueurC=""lC=""LC=",longueur_maximale_de_l_expression_reguliere_compilee);
GET_ARGUMENT_L("tracer=""trace=",tracer_les_substitutions);
GET_ARGUMENT_L("occurences=""egrep=""EGRE=",editer_les_occurences);
GET_ARGUMENT_N("substituer=""sub=""SUB=",editer_les_occurences);
/* Les 'GET_ARGUMENT_N(...)' ont ete introduits le 20070111085108... */
GET_ARGUMENT_L("NLdf=""LFdf=""K_LF_debut_a_priori=",ajouter_un_K_LF_au_debut_du_fichier_a_priori);
GET_ARGUMENT_L("NLd=""LFd=""K_LF_debut=",ajouter_un_K_LF_au_debut_du_fichier_s_il_manque);
GET_ARGUMENT_L("NLff=""LFff=""K_LF_fin_a_priori=",ajouter_un_K_LF_a_la_fin_du_fichier_a_priori);
GET_ARGUMENT_L("NLf=""LFf=""K_LF_fin=",ajouter_un_K_LF_a_la_fin_du_fichier_s_il_manque);
GET_ARGUMENT_L("points=""backslasher_les_points=""backslash=",backslasher_les_points);
GET_ARGUMENT_L(GET_ARGUMENT_L_CONSERVER_LES_K_LF_CONTENUS_DANS_LES_SOUS_CHAINES_DEFINIES
,conserver_les_K_LF_contenus_dans_les_sous_chaines_definies
);
GET_ARGUMENT_N(GET_ARGUMENT_N_CONSERVER_LES_K_LF_CONTENUS_DANS_LES_SOUS_CHAINES_DEFINIES
,conserver_les_K_LF_contenus_dans_les_sous_chaines_definies
);
GET_ARGUMENT_L("conserver_les_K_BLANC=""conserver_K_BLANC=""cons_K_BLANC="
,conserver_les_K_BLANC_contenus_dans_les_sous_chaines_definies
);
GET_ARGUMENT_N("supprimer_les_K_BLANC=""supprimer_K_BLANC=""sup_K_BLANC="
,conserver_les_K_BLANC_contenus_dans_les_sous_chaines_definies
);
/* Les 'GET_ARGUMENT_N(...)' ont ete introduits le 20070220122239... */
GET_ARGUMENT_L("remplacer_un_caractere=""remplacer="
,remplacer_un_caractere_contenu_dans_les_sous_chaines_definies
);
GET_ARGUMENT_L("caractere_quelconque=""cq="
,le_caractere_a_remplacer_dans_les_sous_chaines_definies_est_quelconque
);
/* Argument introduit le 20230414134056... */
GET_ARGUMENT_K("caractereA=""cA=""KA=",caractere_a_remplacer_dans_les_sous_chaines_definies);
GET_ARGUMENT_K("caractereR=""cR=""KR=",caractere_de_remplacement_dans_les_sous_chaines_definies);
GET_ARGUMENT_L("sortir=""out=",sortir_le_fichier_substitue);
GET_ARGUMENT_I_D_AIDE_AU_PARAMETRAGE;
GET_ARGUMENT_I_CONFIGURATION_DYNAMIQUE_DU_COMPORTEMENT;
GET_ARGUMENT_I("compteur_initial=""ci=",valeur_courante_du_compteur);
GET_ARGUMENT_I("increment_compteur=""ic=",increment_du_compteur);
GET_ARGUMENT_I("nombre_chiffres_compteur=""ncc=",nombre_de_chiffres_du_compteur);
/* Arguments introduits le 20160813080723... */
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("00",00);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("01",01);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("02",02);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("03",03);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("04",04);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("05",05);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("06",06);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("07",07);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("08",08);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("09",09);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("10",10);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("11",11);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("12",12);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("13",13);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("14",14);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("15",15);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("16",16);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("17",17);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("18",18);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("19",19);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("20",20);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("21",21);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("22",22);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("23",23);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("24",24);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("25",25);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("26",26);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("27",27);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("28",28);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("29",29);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("30",30);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("31",31);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("32",32);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("33",33);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("34",34);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("35",35);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("36",36);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("37",37);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("38",38);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("39",39);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("40",40);
GET_ARGUMENT_C_ENTREE_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER("41",41);
)
);
#undef GET_ARGUMENT_L_CONSERVER_LES_K_LF_CONTENUS_DANS_LES_SOUS_CHAINES_DEFINIES
#undef GET_ARGUMENT_N_CONSERVER_LES_K_LF_CONTENUS_DANS_LES_SOUS_CHAINES_DEFINIES
EGAL(longueur_maximale_du_fichier_Argument
,INTE(MUL2(facteur_d_expansion_du_fichier_Argument,FLOT(longueur_maximale_du_fichier_Argument)))
);
/* Determination de la veritable longueur maximale du fichier Argument a utiliser */
/* initialement (en effet, elle peut ensuite augmenter par re-allocation...). */
EGAL(fichierA,kMalo(longueur_maximale_du_fichier_Argument));
/* Allocation de la memoire necessaire au fichier Argument. */
EGAL(longueur_maximale_du_fichier_Resultat
,INTE(MUL2(facteur_d_expansion_du_fichier_Resultat,FLOT(longueur_maximale_du_fichier_Argument)))
);
EGAL(fichierR,kMalo(longueur_maximale_du_fichier_Resultat));
/* Allocation de la memoire necessaire au fichier Resultat en approximant grossierement ce */
/* dont il a besoin... */
Tant(GetcharT(caractere_courant))
Bblock
/* Le caractere courant de l'entree courante est recupere ; et on boucle */
/* sur cette recuperation tant que l'on n'est pas au bout du fichier. */
Test(EST_FAUX(le_premier_caractere_du_fichier_a_ete_traite))
Bblock
Test(IFOU(IL_FAUT(ajouter_un_K_LF_au_debut_du_fichier_a_priori)
,IFET(IL_FAUT(ajouter_un_K_LF_au_debut_du_fichier_s_il_manque)
,IFNE(caractere_courant,K_LF)
)
)
)
Bblock
STORE_FICHIER(K_LF
,index_du_caractere_courant_de_fichierA
,veritable_fichierA
,longueur_maximale_du_fichier_Argument
);
/* Mise d'un 'K_LF' au debut du fichier Argument... */
Eblock
ATes
Bblock
Eblock
ETes
EGAL(le_premier_caractere_du_fichier_a_ete_traite,VRAI);
Eblock
ATes
Bblock
Eblock
ETes
STORE_FICHIER(caractere_courant
,index_du_caractere_courant_de_fichierA
,veritable_fichierA
,longueur_maximale_du_fichier_Argument
);
/* Rangement dans le fichier Argument avec extension eventuelle... */
Eblock
ETan
STORE_FICHIER(K_NULL
,index_du_caractere_courant_de_fichierA
,veritable_fichierA
,longueur_maximale_du_fichier_Argument
);
/* Et enfin, "fermeture" du fichier Argument... */
EGAL(index_du_dernier_caractere_de_fichierA,PRED(index_du_caractere_courant_de_fichierA));
/* Afin de revenir sur le dernier caractere du fichier Argument. */
EGAL(index_du_dernier_caractere_de_fichierR,index_du_dernier_caractere_de_fichierA);
/* Et ce au cas ou aucune substitution ne serait faite... */
Repe(nombre_d_iterations_des_substitutions)
/* Possibilite introduite le 20101227105651... */
Bblock
EGAL(proceder_aux_substitutions,VRAI);
EGAL(numero_de_la_substitution,ZERO);
/* Quelques [re-]initialisations necessaires depuis le 20101227105651... */
Tant(IL_FAUT(proceder_aux_substitutions))
Bblock
INCR(numero_de_la_substitution,I);
/* Numero de la substitution courante. */
gCHoi(numero_de_la_substitution,UN,I)
/* Utilisation successive des differentes chaines declarees, de la premiere a la derniere, */
/* suivant le 'Tant(...)' et grace aux 'CAse_SEQUENTIEL' qui suivent.. */
Bblock
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(00)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(01)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(02)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(03)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(04)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(05)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(06)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(07)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(08)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(09)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(10)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(11)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(12)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(13)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(14)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(15)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(16)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(17)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(18)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(19)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(20)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(21)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(22)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(23)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(24)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(25)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(26)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(27)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(28)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(29)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(30)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(31)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(32)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(33)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(34)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(35)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(36)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(37)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(38)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(39)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(40)
CAse_SEQUENTIEL_D_UNE_CHAINE_A_CHERCHER_ET_A_SUBSTITUER(41)
DEfo
Bblock
EGAL(proceder_aux_substitutions,FAUX);
/* Pour arreter le processus de substitution... */
Eblock
EDEf
Eblock
EgCHo
Test(IL_FAUT(proceder_aux_substitutions))
Bblock
EGAL(transferer_le_fichierA_tel_quel,FAUX);
/* A priori, il va y avoir substitution... */
EGAL(index_du_caractere_courant_de_fichierR,PREMIER_CARACTERE);
/* Index du caractere courant du fichier Resultat. */
#if ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
Test(TOUJOURS_VRAI)
/* Le 20021213121628, je n'arrive pas a faire fonctionner les expressions regulieres du */
/* dtype '^...'. Je les interdit donc provisoirement (?). */
Bblock
Test(IFNE_chaine(chaine_recherchee_dans_fichierA,C_VIDE))
Bblock
Test(IFEQ(ITb0(chaine_recherchee_dans_fichierA
,PREMIER_CARACTERE
)
,MARQUEUR_DE_DEBUT_DE_LIGNE
)
)
Bblock
/* Cas de l'expression reguliere '^...' : */
PRINT_ERREUR("une expression reguliere commence par '^' (marqueur inoperant), elle est ignoree");
CAL1(Prer1("expression reguliere = '%s'\n\n",chaine_recherchee_dans_fichierA));
EGAL(chaine_recherchee_dans_fichierA,C_VIDE);
/* A la date du 20021213121628, je n'arrive pas a faire fonctionner les expressions */
/* regulieres du type '^...' ; je les interdit donc provisoirement... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(TOUJOURS_FAUX)
/* Le 20021210162748, je crois avoir trouve la raison du probleme dans le fichier */
/* d'include 'v /usr/include/regexp$h _____dollar_____' dans lequel ce n'etait pas 'K_LF' */
/* qui etait teste, mais 'K_NULL'. J'ai apporte les modifications utiles sur les MACHINEs */
/* {$LACT12,$LACT27,$LACT29}. */
Bblock
Test(IFNE_chaine(chaine_recherchee_dans_fichierA,C_VIDE))
Bblock
DEFV(Logical,INIT(la_chaine_recherchee_dans_fichierA_n_a_pas_de_probleme,VRAI));
/* A priori, il n'y a pas de probleme avec l'expression reguliere courante... */
DEFV(Positive,INIT(taille_de_la_chaine_recherchee_dans_fichierA
,chain_Xtaille(Cara(chaine_recherchee_dans_fichierA))
)
);
/* Taille de l'expression reguliere courante... */
Test(IFEQ(ITb0(chaine_recherchee_dans_fichierA
,LSTX(PREMIER_CARACTERE,NEUT(taille_de_la_chaine_recherchee_dans_fichierA))
)
,MARQUEUR_DE_FIN_DE_LIGNE
)
)
Bblock
/* Cas de l'expression reguliere '.*$' : */
Test(IFGT(taille_de_la_chaine_recherchee_dans_fichierA,UN))
Bblock
Test(IFEQ(ITb0(chaine_recherchee_dans_fichierA
,LSTX(PREMIER_CARACTERE,PRED(taille_de_la_chaine_recherchee_dans_fichierA))
)
,K_ANTI_SLASH
)
)
/* Cas de l'expression reguliere '...\$' : */
Bblock
Eblock
ATes
Bblock
EGAL(la_chaine_recherchee_dans_fichierA_n_a_pas_de_probleme,FAUX);
/* Cas de l'expression reguliere '...[^\]$'. */
Eblock
ETes
Eblock
ATes
Bblock
EGAL(la_chaine_recherchee_dans_fichierA_n_a_pas_de_probleme,FAUX);
/* Cas de l'expression reguliere '$'. */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(EST_FAUX(la_chaine_recherchee_dans_fichierA_n_a_pas_de_probleme))
Bblock
PRINT_ERREUR("une expression reguliere se termine par '$' (marqueur inoperant), elle est ignoree");
CAL1(Prer1("expression reguliere = '%s'\n\n",chaine_recherchee_dans_fichierA));
EGAL(chaine_recherchee_dans_fichierA,C_VIDE);
/* A la date du 20021210122742, je n'arrive pas a faire fonctionner les expressions */
/* regulieres du type '...$' ; je les interdit donc provisoirement... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
Test(IFNE_chaine(chaine_recherchee_dans_fichierA,C_VIDE))
Bblock
EGAL(expression_reguliere,Cara(chain_Acopie(chaine_recherchee_dans_fichierA)));
/* Mise en place de l'expression reguliere... */
#if ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
EGAL(expression_reguliere_compilee
,Cara(Malo(longueur_maximale_de_l_expression_reguliere_compilee))
);
/* Et preparation de sa compilation... */
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
Test(IFLE(SOUS(compile(expression_reguliere
,ADRESSE(ITb0(expression_reguliere_compilee
,INDX(PREMIER_CARACTERE,PREMIER_CARACTERE)
)
)
,ADRESSE(ITb0(expression_reguliere_compilee
,SUCC(LSTX(PREMIER_CARACTERE
,longueur_maximale_de_l_expression_reguliere_compilee
)
)
)
)
,END_OF_CHAIN
)
,expression_reguliere_compilee
)
,longueur_maximale_de_l_expression_reguliere_compilee
)
)
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
)
Test(PAS_D_ERREUR(regcomp(ADRESSE(expression_reguliere_compilee)
,ptCAST(cChar,expression_reguliere)
,configuration_de_compilation_des_expressions
)
)
)
/* Une difference entre 'REG_BASIC' et 'REG_EXTENDED' c'est que dans le premier cas les */
/* parentheses delimitant les sous-expressions doivent etre "backslashees" : */
/* */
/* ...\(...\)... */
/* */
/* alors que dans le second cas, elles ne le sont pas : */
/* */
/* ...(...)... */
/* */
/* Afin que 'EXPRESSION_REGULIERE_VERSION_01' et 'EXPRESSION_REGULIERE_VERSION_02' soient */
/* compatibles, il faut donc choisir 'REG_BASIC'. */
/* */
/* Les seules configurations possibles ('configuration_de_compilation_des_expressions') */
/* en 'EXPRESSION_REGULIERE_VERSION_02' sont : */
/* */
/* REG_EXTENDED */
/* REG_ICASE */
/* REG_NEWLINE */
/* REG_NOSUB */
/* */
/* On notera au passage que le programme 'v $xtc/regul_exp.51$c' permet de connaitre la */
/* valeur en hexa-decimale de tous les parametres possibles... */
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
EGAL(ASD1(expression_reguliere_compilee,buffer),ZERO);
EGAL(ASD1(expression_reguliere_compilee,allocated),ZERO);
/* Le 20051124133118, la valeur du champ 'buffer' est passe de 'ADRESSE_NON_ENCORE_DEFINIE' */
/* a 'ZERO' car, en effet, une valeur 'ZERO' pour les champs 'buffer' et 'allocated' */
/* provoque une allocation de memoire par 're_compile_pattern(...)' ci-apres. Or utiliser */
/* 'ADRESSE_NON_ENCORE_DEFINIE' fait l'hypothese implicite que ce symbole equivaut a 'ZERO' */
/* ce qui fait perdre de la generalite... */
EGAL(ASD1(expression_reguliere_compilee,fastmap),ADRESSE_NON_DEFINIE);
EGAL(ASD1(expression_reguliere_compilee,translate),ADRESSE_NON_DEFINIE);
EGAL(configuration_de_compilation_des_expressions_anterieure
,re_set_syntax(configuration_de_compilation_des_expressions)
);
/* Avant le 20021209122756, il y avait ici : */
/* */
/* EGAL(re_syntax_options,configuration_de_compilation_des_expressions); */
/* */
/* mais l'usage de 're_syntax_options(...)' est peut-etre plus prudent par rapport a des */
/* evolutions futures de 'regex.h'... */
Test(PAS_D_ERREUR(re_compile_pattern(ptCAST(cChar,expression_reguliere)
,chain_Xtaille(Cara(expression_reguliere))
,ADRESSE(expression_reguliere_compilee)
)
)
)
/* On notera au passage que le programme 'v $xtc/regul_exp.51$c' permet de connaitre la */
/* valeur en hexa-decimale de tous les parametres possibles... */
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
Bblock
Test(PAS_D_ERREUR(CODE_ERREUR))
Bblock
/* Cas ou 'compile(...)' a reussi a faire son travail... */
DEFV(Int,INIT(index_de_debut_de_substitution,PREMIER_CARACTERE));
DEFV(Int,INIT(index_de_fin_de_substitution,index_du_dernier_caractere_de_fichierA));
/* Index de debut et de fin de substitution. Ce dispositif a ete introduit le 20020206111439 */
/* afin de permettre (un jour...) de ne faire les substitutions, non pas sur la totalite du */
/* fichier Argument, mais uniquement sur un sous-ensemble de celui-ci... */
DEFV(CHAR,INIT(POINTERc(DEBUT_DE_L_OCCURENCE_COURANTE_precedente),ADRESSE_NON_ENCORE_DEFINIE));
DEFV(CHAR,INIT(POINTERc(SUITE_DE_L_OCCURENCE_COURANTE_precedente),ADRESSE_NON_ENCORE_DEFINIE));
/* Introduit le 20021214222435 afin de faire des verifications sur un eventuel bouclage... */
Test(IFGT(index_de_debut_de_substitution,PREMIER_CARACTERE))
/* A la date du 20020206111439, ce test est evidemment toujours FAUX... */
Bblock
DoIn(index_du_caractere_courant_de_fichierA
,PREMIER_CARACTERE
,PRED(index_de_debut_de_substitution)
,I
)
Bblock
GENERE_FICHIER_RESULTAT(ITb0(veritable_fichierA
,INDX(index_du_caractere_courant_de_fichierA
,PREMIER_CARACTERE
)
)
);
/* Transfert intact du debut du fichier Argument... */
Eblock
EDoI
Eblock
ATes
Bblock
Eblock
ETes
EGAL(IDENTITE(sous_fichierA),IDENTITE(veritable_fichierA));
EGAL(index_du_caractere_courant_de_fichierA,index_de_debut_de_substitution);
EGAL(iterer_la_substitution,VRAI);
/* Initialisation du processus... */
Tant(I3ET(IL_FAUT(iterer_la_substitution)
,IFLE(index_du_caractere_courant_de_fichierA,index_de_fin_de_substitution)
,IFLT(index_du_caractere_courant_de_fichierA,index_du_dernier_caractere_de_fichierA)
)
)
/* On peut dire (en simplifiant ?) que l'on fait autant d'iterations 'Tant(...)' que la */
/* chaine 'expression_reguliere' est rencontree ; pour chacune des occurences, il y aura */
/* un appel de type 'regexec(...)' ci-apres. */
/* */
/* Le test validant 'index_du_caractere_courant_de_fichierA' par rapport a */
/* 'index_du_dernier_caractere_de_fichierA' a ete introduit le 20021211171039 afin */
/* de prendre en compte le cas ou l'expression reguliere est un simple '^' et d'eviter */
/* ainsi qu'une ligne supplementaire soit ajoutee a la fin du fichier. On notera qu'il */
/* s'agit bien d'un 'IFLT(...)' et non d'un 'IFLE(...)', ce qui a ete decouvert de facon */
/* experimentale... */
Bblock
#if ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
Test(IZNE(step(Cara(sous_fichierA),expression_reguliere_compilee)))
/* On notera qu'une valeur nulle est renvoyee par 'step(...)' lorsqu'il n'y a plus de */
/* chaines satisfaisantes... */
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
DEFV(ListeOccurence,DTb1(liste_des_occurences,NOMBRE_D_OCCURENCES_RECHERCHEES));
/* Pour recuperer en retour de 'regexec(...)' l'eventuelle occurence courante... */
Test(PAS_D_ERREUR(regexec(ptCAST(KONC(_const,ExpressionReguliere)
,ADRESSE(expression_reguliere_compilee)
)
,ptCAST(cChar,sous_fichierA)
,NOMBRE_D_OCCURENCES_RECHERCHEES
,liste_des_occurences
,configuration_d_appariement_des_expressions
)
)
)
/* Les seules configurations possibles ('configuration_d_appariement_des_expressions') */
/* sont : */
/* */
/* REG_NOTBOL */
/* REG_NOTEOL */
/* */
/* On notera au passage que le programme 'v $xtc/regul_exp.51$c' permet de connaitre la */
/* valeur en hexa-decimale de tous les parametres possibles... */
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
Bblock
/* Cas ou l'on a trouve une occurence : celle-ci est definie par les deux variables */
/* 'DEBUT_DE_L_OCCURENCE_COURANTE' (debut) et 'SUITE_DE_L_OCCURENCE_COURANTE' (juste */
/* apres la fin). */
DEFV(Int,INIT(index_du_caractere_courant_de_substitution,PREMIER_CARACTERE));
/* Index du caractere courant de la chaine a substituer. */
DEFV(Logical,INIT(on_a_rencontre_un_K_ANTI_SLASH,FAUX));
/* Indicateur permettant de gerer les eventuels "\"... */
Test(IL_FAUT(tracer_les_substitutions))
Bblock
Test(IL_NE_FAUT_PAS(editer_les_occurences))
Bblock
CAL3(Prme2("CourantFichierA(%d)='%02x'"
,index_du_caractere_courant_de_fichierA
,ITb0(veritable_fichierA
,INDX(index_du_caractere_courant_de_fichierA
,PREMIER_CARACTERE
)
)
)
);
CAL3(Prme2(" FinFichierA(%d)='%02x'"
,index_du_dernier_caractere_de_fichierA
,ITb0(veritable_fichierA
,INDX(index_du_dernier_caractere_de_fichierA
,PREMIER_CARACTERE
)
)
)
);
CAL3(Prme1(" occurence('%s')",expression_reguliere));
CAL3(Prme2(" debut(%d)='%02x'"
,DEBUT_DE_L_OCCURENCE_COURANTE
,INDIRECT(DEBUT_DE_L_OCCURENCE_COURANTE)
)
);
CAL3(Prme2(" fin(%d)='%02x'"
,SUITE_DE_L_OCCURENCE_COURANTE
,INDIRECT(SUITE_DE_L_OCCURENCE_COURANTE)
)
);
Eblock
ATes
Bblock
DEFV(Positive,INIT(compteur_des_lignes,ZERO));
DEFV(CHAR,INIT(POINTERc(recherche_des_lignes),veritable_fichierA));
DEFV(CHAR,INIT(POINTERc(edition_du_numero_de_ligne),CHAINE_UNDEF));
/* Afin de simuler un numero de ligne (introduit le 20061130162235). On notera que cela */
/* n'est pas tres optimise (euphemisme...) puisqu'en effet, on repart systematiquement du */
/* debut du fichier, mais en fait, je ne vois pas quoi faire d'autre de simple... */
DEFV(CHAR,INIT(POINTERc(occurence),DEBUT_DE_L_OCCURENCE_COURANTE));
/* Pour editer l'occurence elle-meme... */
Tant(IFLT(recherche_des_lignes,DEBUT_DE_L_OCCURENCE_COURANTE))
Bblock
Test(IFEQ(INDIRECT(recherche_des_lignes),K_LF))
Bblock
INCR(compteur_des_lignes,I);
/* Ainsi, en coomptant les 'K_LF's, on compte les lignes... */
Eblock
ATes
Bblock
Eblock
ETes
INCR(recherche_des_lignes,I);
Eblock
ETan
INCR(compteur_des_lignes,I);
/* Afin de trouver ainsi le numero de la premiere ligne de l'occurence courante (au cas ou */
/* celle-ci serait "a cheval" sur plusieurs lignes -en incluant un ou plusieurs 'K_LF's-). */
EGAL(edition_du_numero_de_ligne
,chain_Aconcaten3("OCCURENCE AU VOISINAGE DE LA LIGNE "
,chain_numero_exact(compteur_des_lignes)
," :"
)
);
CAL3(Prme1("\n%s\n",edition_du_numero_de_ligne));
/* Edition d'un numero de ligne (introduit le 20061130162235). On notera que ce numero */
/* est en general approximatif et donne a epsilon pres (en particulier, pour bien faire */
/* il faudrait trouver le 'K_LF' qui suit l'occurence...). */
Repe(chain_Xtaille(edition_du_numero_de_ligne))
Bblock
CALS(FPrme0("-"));
/* Soulignage de "OCCURENCE AU VOISINAGE DE LA LIGNE nnnn :". */
Eblock
ERep
CALS(Fsauts_de_lignes(UN));
CALZ_FreCC(edition_du_numero_de_ligne);
Tant(IFLT(occurence,SUITE_DE_L_OCCURENCE_COURANTE))
Bblock
CAL3(Prme1("%c",INDIRECT(occurence)));
/* Edition des caracteres de l'occurence un a un... */
INCR(occurence,I);
Eblock
ETan
Eblock
ETes
CALS(Fsauts_de_lignes(UN));
Eblock
ATes
Bblock
Eblock
ETes
#if ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
Test(TOUJOURS_VRAI)
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
Test(IFET(MASQUE_NTEST_BIT(configuration_d_appariement_des_expressions,REG_NOTBOL)
,MASQUE_NTEST_BIT(configuration_d_appariement_des_expressions,REG_NOTEOL)
)
)
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
Bblock
Test(I3ET(IFEQ(PREMIER_CARACTERE_ITb0(expression_reguliere)
,MARQUEUR_DE_DEBUT_DE_LIGNE
)
,IFEQ(DERNIER_CARACTERE_ITb0(expression_reguliere)
,MARQUEUR_DE_FIN_DE_LIGNE
)
,IFEQ(chain_Xtaille(Cara(expression_reguliere)),DEUX)
)
)
/* Cas d'une expression reguliere du type '^$' : */
Bblock
Test(IFGT(index_du_caractere_courant_de_fichierA,PREMIER_CARACTERE))
/* Cas d'un fichier ayant plus d'un caractere : */
Bblock
Test(IFET(IFEQ(INDIRECT(NEUT(SUITE_DE_L_OCCURENCE_COURANTE)),K_NULL)
,IFEQ(INDIRECT(PRED(SUITE_DE_L_OCCURENCE_COURANTE)),K_LF)
)
)
/* Cas ou l'on est au bout du fichier et qu'il se termine par {K_LF,K_NULL}. */
Bblock
EGAL(iterer_la_substitution,FAUX);
/* On arrete d'iterer afin de ne pas creer une ligne supplementaire a la fin du fichier */
/* (ceci a ete introduit le 20021215084025). */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Test(IFOU(IL_NE_FAUT_PAS(iterer_la_substitution)
,IFOU(IFLT(IDENTITE(SUITE_DE_L_OCCURENCE_COURANTE)
,IDENTITE(DEBUT_DE_L_OCCURENCE_COURANTE)
)
,IFOU(IFEQ(DEBUT_DE_L_OCCURENCE_COURANTE
,DEBUT_DE_L_OCCURENCE_COURANTE_precedente
)
,IFEQ(SUITE_DE_L_OCCURENCE_COURANTE
,SUITE_DE_L_OCCURENCE_COURANTE_precedente
)
)
)
)
)
/* {DEBUT_DE_L_OCCURENCE_COURANTE_precedente,SUITE_DE_L_OCCURENCE_COURANTE_precedente} ont */
/* ete introduits le 20021214222435. */
Bblock
Test(IL_FAUT(iterer_la_substitution))
Bblock
PRINT_ERREUR("l'occurence trouvee est douteuse, la substitution est stoppee");
CAL1(Prer1("(pour l'occurence courante, le DEBUT est en %d "
,DEBUT_DE_L_OCCURENCE_COURANTE
)
);
CAL1(Prer1("et la SUITE en %d)\n"
,SUITE_DE_L_OCCURENCE_COURANTE
)
);
CAL1(Prer1("(pour l'occurence precedente, le DEBUT etait en %d "
,DEBUT_DE_L_OCCURENCE_COURANTE_precedente
)
);
CAL1(Prer1("et la SUITE en %d)\n"
,SUITE_DE_L_OCCURENCE_COURANTE_precedente
)
);
/* En 'EXPRESSION_REGULIERE_VERSION_02' et en 'EXPRESSION_REGULIERE_VERSION_03', ce */
/* message se rencontre, par exemple, avec : */
/* */
/* c01='$' s01="FinDe_ligne" */
/* */
/* cense ajouter "FinDe_ligne" au bout de chaque ligne. Pour faire, la meme chose, il */
/* suffira d'ecrire : */
/* */
/* c01='\(\n\)' s01="FinDe_ligne\1" */
/* */
/* A la date du 20021206165508, je ne sais pas corriger cette anomalie, d'autant plus */
/* que les valeurs 'SUITE_DE_L_OCCURENCE_COURANTE' et 'DEBUT_DE_L_OCCURENCE_COURANTE' */
/* sont renvoyees directement par 'regexec(...)' ; il n'y a donc aucun controle dessus. */
/* Au passage, j'ai essaye de remplacer le 'IFLE(...)' par un 'IFLT(...)' ; cela a eu pour */
/* effet de faire boucler le programme. Le 20021207105825, il me semble que le probleme */
/* est identique a celui du 20021205173903. Le probleme a ete finalement resolu le */
/* 20021207114526. */
EGAL(iterer_la_substitution,FAUX);
/* On arrete d'iterer, c'est plus prudent... */
Eblock
ATes
Bblock
/* Cas ou on a deja decide d'arreter d'iterer afin de ne pas creer une ligne supplementaire */
/* a la fin du fichier... */
Eblock
ETes
Eblock
ATes
Bblock
DEFV(Int,INIT(index_de_fin_de_la_chaine_a_deplacer_depuis_fichierA
,ADD2(PREMIER_CARACTERE
,TRMU(SOUS(IDENTITE(DEBUT_DE_L_OCCURENCE_COURANTE)
,IDENTITE(veritable_fichierA)
)
)
)
)
);
/* Afin de savoir jusqu'ou deplacer le fichier Argument... */
/* */
/* Le 'ADD2(PREMIER_CARACTERE,...)' a ete introduit le 20021205172017. */
EGAL(DEBUT_DE_L_OCCURENCE_COURANTE_precedente,DEBUT_DE_L_OCCURENCE_COURANTE);
EGAL(SUITE_DE_L_OCCURENCE_COURANTE_precedente,SUITE_DE_L_OCCURENCE_COURANTE);
/* Ceci a ete introduit le 20021214222435. */
Test(IFLE(index_de_fin_de_la_chaine_a_deplacer_depuis_fichierA
,index_de_fin_de_substitution
)
)
Bblock
DoIn(index_du_caractere_courant_de_fichierA
,index_du_caractere_courant_de_fichierA
,index_de_fin_de_la_chaine_a_deplacer_depuis_fichierA
,I
)
Bblock
GENERE_FICHIER_RESULTAT(ITb0(veritable_fichierA
,INDX(index_du_caractere_courant_de_fichierA
,PREMIER_CARACTERE
)
)
);
/* Transfert intact du fichier Argument jusqu'a la prochaine occurence de la chaine */
/* recherchee... */
Eblock
EDoI
Eblock
ATes
Bblock
PRINT_ERREUR("il y a debordement de l'index courant du fichier Argument");
Eblock
ETes
DoIn(index_du_caractere_courant_de_substitution
,PREMIER_CARACTERE
,index_de_fin_de_la_chaine_a_substituer_dans_fichierR
,I
)
Bblock
DEFV(CHAR,INIT(char_a_substituer_dans_fichierR
,ITb0(chaine_a_substituer_dans_fichierR
,INDX(index_du_caractere_courant_de_substitution
,PREMIER_CARACTERE
)
)
)
);
/* Caractere courant a substituer... */
DEFV(CHAR,INIT(char_substitue_dans_fichierR,K_UNDEF));
/* Caractere courant a substituer reellement... */
EGAL(char_substitue_dans_fichierR
,char_a_substituer_dans_fichierR
);
/* Caractere courant a substituer a priori... */
Test(EST_VRAI(on_a_rencontre_un_K_ANTI_SLASH))
Bblock
/* Cas ou l'on a rencontre un "\" juste avant : */
#define alpha_numerique(caractere) \
est_ce_alpha_numerique(caractere)
Test(IFOU(EST_VRAI(alpha_numerique(char_a_substituer_dans_fichierR))
,IMEQ(char_a_substituer_dans_fichierR,K_PLUS,K_MOINS)
)
)
/* Le 'IMEQ(...)' a ete introduit le 20160815081125... */
Bblock
/* Cas ou un "\" est suivi par un numero : */
DEFV(Int,INIT(sous_expression_c,SOUS_EXPRESSION_COURANTE));
/* Numero de la sous-expression courante referencee par un "\X" ou 'X' est dans [1,9]. */
/* Cette variable fut introduite le 20090108102933 a cause de l'introduction de la fonction */
/* 'est_ce_alpha_numerique(...)' le 20090108094506 afin de faire l'eventuelle permutation */
/* "minuscule <--> majuscule" ci-apres. Alors 'SOUS_EXPRESSION_COURANTE' est modifiee a */
/* chacun des appels de 'est_ce_alpha_numerique(...)' ce qui empeche le bon fonctionnement */
/* du 'DoIn(...)' qui suit... */
/* */
/* On rappelle le 20090112172243 que si 'char_a_substituer_dans_fichierR' est un */
/* chiffre (dans [0,9]) alors 'SOUS_EXPRESSION_COURANTE' vaut ici sa valeur numerique (soit */
/* 'est_ce_alpha_numerique_____valeur_numerique') et que lorsque le caractere n'est pas */
/* numerique ceci vaut 'v $xig/fonct$vv$DEF VALEUR_NUMERIQUE_D_UN_CARACTERE_NON_HEXADECIMAL' */
/* c'est-a-dire moins l'infini qui ne peut etre un nombre valable de sous-epressions... */
Test(IFINff(sous_expression_c
,NUMERO_DE_L_EVENTUELLE_PREMIERE_SOUS_EXPRESSION
,NOMBRE_DE_SOUS_EXPRESSIONS
)
)
Bblock
/* Cas ou un "\" est suivi d'un numero dans [1,n], 'n' etant le nombre de sous-expressions : */
DEFV(Int,INIT(index_de_sous_expression,UNDEF));
/* Index de transfert de la sous-expression... */
DoIn(index_de_sous_expression
,ADD2(PREMIER_CARACTERE
,SOUS(IDENTITE(DEBUT_EXPRESSION(sous_expression_c))
,IDENTITE(veritable_fichierA)
)
)
,ADD2(PREMIER_CARACTERE
,TRMU(SOUS(IDENTITE(SUITE_EXPRESSION(sous_expression_c))
,IDENTITE(veritable_fichierA)
)
)
)
,I
)
/* Les 'ADD2(PREMIER_CARACTERE,...)' ont ete introduits le 20021205172017. */
Bblock
EGAL(char_substitue_dans_fichierR
,ITb0(veritable_fichierA
,INDX(index_de_sous_expression
,PREMIER_CARACTERE
)
)
);
#define caractere_permute_minuscule_majuscule \
est_ce_alpha_numerique_____caractere_permute_minuscules_et_majuscules
/* Pour raccourcir quelques unes des lignes suivantes... */
Test(IL_FAUT(permuter_les_minuscules_et_les_majuscules))
Bblock
CALS(alpha_numerique(char_substitue_dans_fichierR));
EGAL(char_substitue_dans_fichierR
,caractere_permute_minuscule_majuscule
);
/* Cette permutation "minuscule <--> majuscule" a ete introduite le 20090108094506... */
Eblock
ATes
Bblock
Eblock
ETes
#undef caractere_permute_minuscule_majuscule
#undef alpha_numerique
#define remplacer_un_caractere \
remplacer_un_caractere_contenu_dans_les_sous_chaines_definies
#define caractere_quelconque \
le_caractere_a_remplacer_dans_les_sous_chaines_definies_est_quelconque
#define caractere_a_remplacer \
caractere_a_remplacer_dans_les_sous_chaines_definies
#define caractere_de_remplacement \
caractere_de_remplacement_dans_les_sous_chaines_definies
/* Pour raccourcir quelques unes des lignes suivantes... */
Test(IFET(IL_FAUT(remplacer_un_caractere)
,IFOU(IFET(EST_FAUX(caractere_quelconque)
,IFEQ(char_substitue_dans_fichierR
,caractere_a_remplacer
)
)
,IFET(EST_VRAI(caractere_quelconque)
,IFNE(char_substitue_dans_fichierR
,K_LF
)
)
)
)
)
Bblock
EGAL(char_substitue_dans_fichierR
,caractere_de_remplacement
);
/* Ce remplacement a ete introduit le 20040601111701... */
Eblock
ATes
Bblock
Eblock
ETes
#undef caractere_de_remplacement
#undef caractere_a_remplacer
#undef caractere_quelconque
#undef remplacer_un_caractere
#define conserver_K_LF_des_sous_chaines \
conserver_les_K_LF_contenus_dans_les_sous_chaines_definies
#define conserver_K_BLANC_des_sous_chaines \
conserver_les_K_BLANC_contenus_dans_les_sous_chaines_definies
/* Pour raccourcir quelques unes des lignes suivantes... */
Test(I3OU(IFET(IFNE(char_substitue_dans_fichierR
,K_LF
)
,IFNE(char_substitue_dans_fichierR
,K_BLANC
)
)
,IFET(IFEQ(char_substitue_dans_fichierR
,K_LF
)
,IL_FAUT(conserver_K_LF_des_sous_chaines)
)
,IFET(IFEQ(char_substitue_dans_fichierR
,K_BLANC
)
,IL_FAUT(conserver_K_BLANC_des_sous_chaines)
)
)
)
Bblock
GENERE_FICHIER_RESULTAT(char_substitue_dans_fichierR);
/* Caractere courant a substituer reellement... */
Eblock
ATes
Bblock
/* L'elimination eventuelle des 'K_LF' a ete introduite le 20040514150215... */
/* */
/* L'elimination eventuelle des 'K_BLANC' a ete introduite le 20040526142735... */
Eblock
ETes
#undef conserver_K_BLANC_des_sous_chaines
#undef conserver_K_LF_des_sous_chaines
Eblock
EDoI
Eblock
ATes
Bblock
/* Cas ou un "\" est suivi d'un caractere qui n'est pas un numero de sous-expressions (soit */
/* ce n'est pas un chiffre, soit une sous-expression avec ce numero n'existe pas -par */
/* exemple "\9" alors qu'il n'y a que deux sous-expressions, auquel cas "\9" sera genere */
/* dans le 'fichierR' via le Defo(...)' ci-apres-) : */
Choi(char_a_substituer_dans_fichierR)
/* Generation de quelques caracteres speciaux : */
Bblock
Ca1e(K_b)
Bblock
GENERE_FICHIER_RESULTAT(K_BACKSPACE);
Eblock
ECa1
Ca1e(K_k)
/* Le compteur a ete introduit le 20160813080723... */
Bblock
DEFV(Int,INIT(index_du_compteur
,PREMIER_CARACTERE
)
);
DEFV(Char,INIT(POINTERc(compteur)
,ADRESSE_NON_ENCORE_DEFINIE
)
);
EGAL(compteur
,chain_numero(valeur_courante_du_compteur
,nombre_de_chiffres_du_compteur
)
);
/* Conversion alpha-numerique du compteur. */
Repe(nombre_de_chiffres_du_compteur)
Bblock
GENERE_FICHIER_RESULTAT(ITb0(compteur
,index_du_compteur
)
);
/* Remplacement de "\k" par le compteur... */
INCR(index_du_compteur,I);
Eblock
ERep
CALZ_FreCC(compteur);
INCR(valeur_courante_du_compteur
,increment_du_compteur
);
/* Incrementation automatique du compteur... */
Eblock
ECa1
Ca1e(K_PLUS)
/* Possibilite introduite le 20160815080520... */
Bblock
INCR(valeur_courante_du_compteur
,increment_du_compteur
);
/* Incrementation explicite du compteur... */
Eblock
ECa1
Ca1e(K_MOINS)
/* Possibilite introduite le 20160815080520... */
Bblock
DECR(valeur_courante_du_compteur
,increment_du_compteur
);
/* Decrementation explicite du compteur... */
Eblock
ECa1
Ca1e(K_n)
Bblock
GENERE_FICHIER_RESULTAT(K_LF);
Eblock
ECa1
Ca1e(K_t)
Bblock
GENERE_FICHIER_RESULTAT(K_TABULATION);
Eblock
ECa1
Ca1e(K_r)
Bblock
GENERE_FICHIER_RESULTAT(K_RC);
Eblock
ECa1
Ca1e(K_N)
Bblock
GENERE_FICHIER_RESULTAT(K_ANTI_SLASH);
GENERE_FICHIER_RESULTAT(K_n);
/* Pour resoudre le probleme evoque en '$xcp/substitue.01$K 20040630124810' il a ete */
/* introduit le 20040630131550 le code "\N" qui est un substitut de "\n" a utiliser a */
/* la place de ce dernier lorsque la chaine de deux caracteres "\n" doit etre utilisee */
/* en tant que telle... */
Eblock
ECa1
Ca1e(K_M)
Bblock
EGAL(permuter_les_minuscules_et_les_majuscules,VRAI);
/* Introduit le 20090108210327 : "\M" permet la substitution "majuscule <--> minuscule"... */
Eblock
ECa1
Ca1e(K_m)
Bblock
EGAL(permuter_les_minuscules_et_les_majuscules,FAUX);
/* Introduit le 20090108210327 : "\m" inhibe la substitution "majuscule <--> minuscule"... */
Eblock
ECa1
Defo
/* Cas standards : */
Bblock
GENERE_FICHIER_RESULTAT(K_ANTI_SLASH);
GENERE_FICHIER_RESULTAT(char_substitue_dans_fichierR);
/* Dans les autres cas, on retransmets donc "\" suivi du caractere courant... */
Eblock
EDef
Eblock
ECho
Eblock
ETes
Eblock
ATes
Bblock
/* Cas ou un "\" est suivi par un caractere non alpha-numerique : */
Choi(char_a_substituer_dans_fichierR)
/* Generation de quelques caracteres speciaux : */
Bblock
Ca1e(K_ANTI_SLASH)
Bblock
GENERE_FICHIER_RESULTAT(K_ANTI_SLASH);
Eblock
ECa1
Defo
/* Cas standards : */
Bblock
GENERE_FICHIER_RESULTAT(K_ANTI_SLASH);
GENERE_FICHIER_RESULTAT(char_substitue_dans_fichierR);
/* Substitution de la chaine recherchee dans le cas ou l'on a rencontre un "\" juste avant */
/* le caractere courant, alors que celui-ci doit etre reellement "backslashe"... */
Eblock
EDef
Eblock
ECho
Eblock
ETes
EGAL(on_a_rencontre_un_K_ANTI_SLASH,FAUX);
Eblock
ATes
Bblock
Test(IFET(IFEQ(char_a_substituer_dans_fichierR,K_ANTI_SLASH)
,IFLT(index_du_caractere_courant_de_substitution
,index_de_fin_de_la_chaine_a_substituer_dans_fichierR
)
)
)
Bblock
EGAL(on_a_rencontre_un_K_ANTI_SLASH,VRAI);
/* On differe le traitement et l'emission eventuelle de 'K_ANTI_SLASH' sauf s'il apparait */
/* en derniere position... */
Eblock
ATes
Bblock
/* Cas "standards" : */
GENERE_FICHIER_RESULTAT(char_substitue_dans_fichierR);
/* Substitution de la chaine recherchee pour les cas "standards"... */
Eblock
ETes
Eblock
ETes
Eblock
EDoI
EGAL(IDENTITE(sous_fichierA),IDENTITE(SUITE_DE_L_OCCURENCE_COURANTE));
/* ATTENTION, le 20021205173903, j'ai decouvert une anomalie liee a cette facon de proceder. */
/* En effet, ainsi, lorsque l'on execute 'regexec(...)' on est toujours positionne au debut */
/* de 'sous_fichierA'. Si maintenant, il contient la ligne suivante : */
/* */
/* ABABABAB */
/* */
/* si l'expression reguliere courante est : */
/* */
/* ^AB */
/* */
/* et si enfin, on demande la substitution par "-+", alors la ligne precedente ("ABABABAB") */
/* deviendra : */
/* */
/* -+-+-+-+ */
/* */
/* et non pas : */
/* */
/* -+ABABAB */
/* */
/* comme il se doit car, en effet, etant toujours au debut du 'sous_fichierA', a chaque */
/* appel de regexec(...)' on voit successivement : */
/* */
/* ABABABAB */
/* | */
/* */
/* -+ABABAB */
/* | */
/* */
/* -+-+ABAB */
/* | */
/* */
/* -+-+-+AB */
/* | */
/* */
/* -+-+-+-+ */
/* */
/* ou "|" materialise le debut du 'sous_fichierA' courant... */
/* */
/* Que faire donc ? Ce probleme a ete finalement resolu le 20021207114526. */
EGAL(index_du_caractere_courant_de_fichierA
,ADD2(PREMIER_CARACTERE
,SOUS(IDENTITE(sous_fichierA),IDENTITE(veritable_fichierA))
)
);
/* Le 'ADD2(PREMIER_CARACTERE,...)' a ete introduit le 20021205172017. */
#if ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
Test(IFOU(IFEQ(PREMIER_CARACTERE_ITb0(expression_reguliere)
,MARQUEUR_DE_DEBUT_DE_LIGNE
)
,IFEQ(DERNIER_CARACTERE_ITb0(expression_reguliere)
,MARQUEUR_DE_FIN_DE_LIGNE
)
)
)
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
Test(IFOU(IFET(IFEQ(PREMIER_CARACTERE_ITb0(expression_reguliere)
,MARQUEUR_DE_DEBUT_DE_LIGNE
)
,MASQUE_NTEST_BIT(configuration_d_appariement_des_expressions
,REG_NOTBOL
)
)
,IFET(IFEQ(DERNIER_CARACTERE_ITb0(expression_reguliere)
,MARQUEUR_DE_FIN_DE_LIGNE
)
,MASQUE_NTEST_BIT(configuration_d_appariement_des_expressions
,REG_NOTEOL
)
)
)
)
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
Bblock
/* Cas ou l'expression reguliere courante est du type "^...", il faut copier, sans tester */
/* cette expression reguliere, jusqu'au prochain 'K_LF' (ceci a ete introduit le */
/* 20021206090948 afin de corriger le probleme mis en evidence le 20021205173903 et */
/* decrit ci-apres). En ce qui concerne le cas du type '...$', il a ete etudie a compter */
/* du 20021207105825 et resolu le 20021207114526. */
DEFV(Logical,INIT(transferer_fichierA,VRAI));
/* Afin de se deplacer jusqu'au prochain 'K_LF'... */
DEFV(Logical,INIT(s_arreter_derriere_le_K_LF,FAUX));
/* Afin de traiter le cas de '...$' en fin de fichier. En effet, sans ce dispositif, */
/* une ligne vide fictive etait ajoutee a la fin du fichier et celle-ci subissait l'effet */
/* de l'expression reguliere courante... */
Tant(IL_FAUT(transferer_fichierA))
Bblock
DEFV(CHAR,INIT(caractere_courant_de_fichierA
,ITb0(veritable_fichierA
,INDX(index_du_caractere_courant_de_fichierA
,PREMIER_CARACTERE
)
)
)
);
GENERE_FICHIER_RESULTAT(caractere_courant_de_fichierA);
/* Transfert du 'fichierA' jusqu'a trouver un changement de ligne ('K_LF'). */
INCR(index_du_caractere_courant_de_fichierA,I);
Test(IFET(IFET(IFNE(caractere_courant_de_fichierA,K_LF)
,IFNE(caractere_courant_de_fichierA,END_OF_CHAIN)
)
,IFLE(index_du_caractere_courant_de_fichierA
,index_du_dernier_caractere_de_fichierA
)
)
)
Bblock
/* Le transfert va continuer tant que l'on n'est pas au bout de la chaine a copier dans le */
/* cas ou il ne s'agit pas d'une expression reguliere du type "^...". Dans le cas contraire */
/* (expression reguliere du type "^..."), on transfere jusqu'a ce l'on rencontre un */
/* changement de ligne ('K_LF') afin de corriger le probleme du 20021205173903 decrit */
/* ci-apres... */
Eblock
ATes
Bblock
Test(I3ET(IFEQ(DERNIER_CARACTERE_ITb0(expression_reguliere)
,MARQUEUR_DE_FIN_DE_LIGNE
)
,IFGE(index_du_caractere_courant_de_fichierA
,NEUT(index_du_dernier_caractere_de_fichierA)
)
,EST_FAUX(s_arreter_derriere_le_K_LF)
)
)
/* Dans le cas d'une expression reguliere du type '...$', il faut s'arreter non pas sur */
/* le 'K_LF', mais juste derriere... */
Bblock
EGAL(s_arreter_derriere_le_K_LF,VRAI);
/* On fait donc, grace a cet indicateur, un tour de plus... */
Eblock
ATes
Bblock
EGAL(transferer_fichierA,FAUX);
/* Il faut arreter le transfert... */
Eblock
ETes
Eblock
ETes
Eblock
ETan
EGAL(IDENTITE(sous_fichierA)
,IDENTITE(ADD2(veritable_fichierA
,SOUS(index_du_caractere_courant_de_fichierA
,PREMIER_CARACTERE
)
)
)
);
/* Et on deplace ainsi l'origine de 'sous_fichierA'... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
Eblock
ATes
Bblock
/* Cas ou l'on n'a pas (ou plus) trouve d'occurence : */
EGAL(iterer_la_substitution,FAUX);
/* On arrete d'iterer... */
Eblock
ETes
Eblock
ETan
DoIn(index_du_caractere_courant_de_fichierA
,index_du_caractere_courant_de_fichierA
,index_du_dernier_caractere_de_fichierA
,I
)
Bblock
GENERE_FICHIER_RESULTAT(ITb0(veritable_fichierA
,INDX(index_du_caractere_courant_de_fichierA,PREMIER_CARACTERE)
)
);
/* Transfert intact de la fin du fichier Argument... */
Eblock
EDoI
EGAL(index_du_dernier_caractere_de_fichierR,PRED(index_du_caractere_courant_de_fichierR));
/* Afin de revenir sur le dernier caractere du fichier Resultat. */
Eblock
ATes
Bblock
/* Cas ou 'compile(...)' n'a pas reussi a faire son travail... */
PRINT_ERREUR("l'expression reguliere est incorrecte");
EGAL(transferer_le_fichierA_tel_quel,VRAI);
/* Dans le cas ou il y a erreur, il y a transfert tel quel... */
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("l'expression reguliere est syntaxiquement incorrecte");
CAL1(Prer1("elle vaut '%s'\n"
,expression_reguliere
)
);
PRINT_ERREUR("ou plus rarement, l'expression reguliere est trop volumineuse");
CAL1(Prer1("la longueur maximale courante est de %d octets\n"
,longueur_maximale_de_l_expression_reguliere_compilee
)
);
EGAL(transferer_le_fichierA_tel_quel,VRAI);
/* Dans le cas ou il y a erreur, il y a transfert tel quel... */
Eblock
ETes
#if ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
CALZ_FreDD(expression_reguliere_compilee);
/* Liberation de l'espace memoire utile a 'expression_reguliere_compilee'... */
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_01)) \
)
#if ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
CALS(regfree(ADRESSE(expression_reguliere_compilee)));
/* Liberation de l'espace memoire utile a 'expression_reguliere_compilee'... */
#Aif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
#Eif ( (defined(EXPRESSION_REGULIERE_VERSION_02)) \
|| (defined(EXPRESSION_REGULIERE_VERSION_03)) \
)
Eblock
ATes
Bblock
EGAL(transferer_le_fichierA_tel_quel,VRAI);
/* Dans le cas ou il n'y a pas de substitution, il y a transfert tel quel... */
Eblock
ETes
CALZ_FreDD(chaine_a_substituer_dans_fichierR);
CALZ_FreDD(chaine_recherchee_dans_fichierA);
/* Liberation de l'espace memoire utile aux chaines... */
Test(IL_FAUT(transferer_le_fichierA_tel_quel))
Bblock
/* En fait, il n'y rien a faire, si ce n'est de ne pas faire la bascule... */
Eblock
ATes
Bblock
/* Sion, il faut basculer les fichiers 'fichierA' et 'fichierR' : */
EGAL(index_du_dernier_caractere_de_fichierA,index_du_dernier_caractere_de_fichierR);
/* Afin de preparer la bascule entre 'fichierA' et 'fichierR'... */
EGAL(fichierA_vers_fichierR,NOTL(fichierA_vers_fichierR));
iSWAP(longueur_maximale_du_fichier_Argument,longueur_maximale_du_fichier_Resultat);
/* Bascule entre 'fichierA' et 'fichierR'... */
/* */
/* Le 'iSWAP(...)' a ete introduit le 20051125104737 car il manquait... */
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETan
Eblock
ERep
EGAL(fichierA_vers_fichierR,NOTL(fichierA_vers_fichierR));
iSWAP(longueur_maximale_du_fichier_Argument,longueur_maximale_du_fichier_Resultat);
/* Re-bascule entre 'fichierA' et 'fichierR'... */
/* */
/* Le 'iSWAP(...)' a ete introduit le 20051125104737 car il manquait... */
DoIn(index_du_caractere_courant_de_fichierR
,PREMIER_CARACTERE
,PRED(index_du_dernier_caractere_de_fichierR)
,I
)
Bblock
EGAL(caractere_courant
,ITb0(veritable_fichierR
,INDX(index_du_caractere_courant_de_fichierR,PREMIER_CARACTERE)
)
);
SORTIE_D_UN_CARACTERE(caractere_courant);
/* Transfert du fichier Resultat. Le 'PRED(index_du_dernier_caractere_de_fichierR)' est */
/* destine a eliminer le caractere 'K_NULL' qui avait ete mis a la fin du fichier Argument */
/* afin de pouvoir le manipuler comme une "vulgaire" chaine de caractere... */
Eblock
EDoI
Test(IFOU(IL_FAUT(ajouter_un_K_LF_a_la_fin_du_fichier_a_priori)
,IFET(IL_FAUT(ajouter_un_K_LF_a_la_fin_du_fichier_s_il_manque)
,IFNE(caractere_courant,K_LF)
)
)
)
Bblock
SORTIE_D_UN_CARACTERE(K_LF);
/* Mise d'un 'K_LF' a la fin du fichier Resultat... */
Eblock
ATes
Bblock
Eblock
ETes
CALZ_FreFF(fichierR);
CALZ_FreFF(fichierA);
/* Liberation de l'espace memoire utile aux fichiers... */
RETU_Commande;
Eblock
ECommande