/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D E S F O N C T I O N S D ' I N T E R E T G E N E R A L : */
/* */
/* */
/* Definition : */
/* */
/* Dans ce fichier, se trouvent toutes */
/* les definitions de macros relatives */
/* aux fonctions d'interet general, et */
/* en particulier celles de manipulation */
/* des chaines de caracteres et celles */
/* de gestion de fichiers. */
/* */
/* */
/* Author of '$xig/fonct$vv$DEF' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 19870000000000). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T R A I T E M E N T D E S F O R M A T S D E S O R T I E ( D E B U T ) : */
/* */
/*************************************************************************************************************************************/
#define NOM_DE_LA_COMMANDE_COURANTE \
COND(IFEQ_chaine(nom_de_la_commande_courante,ADRESSE_NON_ENCORE_DEFINIE) \
,nom_de_la_commande_courante_non_encore_definie \
,nom_de_la_commande_courante \
) \
/* Introduit le 20120201110309 et mis ici le 20170405153655 (apres transfert depuis */ \
/* 'v $xig/fonct$vv$FON'... */
#define NOM_DE_LA_COMMANDE_COURANTE_NON_ENCORE_DEFINIE \
"CommandeCouranteNonEncoreDefinie" \
/* Introduit le 20170405154858... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A L L O C A T I O N M E M O I R E A V E C V A L I D A T I O N : */
/* */
/*************************************************************************************************************************************/
/* 'VALEUR_PAR_DEFAUT_DE_MemorySizeMB' et 'VALEUR_PAR_DEFAUT_DE_PCMemorySizeMB' ont ete */
/* mises dans 'v $xil/defi_K2$vv$DEF MemorySizeMB' le 20170418102447... */
#define AMARGE_DE_SECURITE_POUR_ALLOCATION_MEMOIRE_AVEC_VALIDATION \
UN
#define BMARGE_DE_SECURITE_POUR_ALLOCATION_MEMOIRE_AVEC_VALIDATION \
ZERO
/* Introduit le 20051026160119 pour etre utilise dans 'v $xig/fonct$vv$DEF MargeMalo'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T E S T S D I V E R S D E N O M B R E S F L O T T A N T S : */
/* */
/* */
/* Nota important : */
/* */
/* Ceci a ete introduit le 20040303135217 dans le */
/* but de lutter efficacement, s'il existe, contre */
/* 'BUG_SYSTEME_APC_GCC_ExcessPrecisionProblem_01' */
/* le passage par la pile (et donc la mise systematique */
/* en 64 bits des nombres) permettant seul de garantir */
/* les tests des nombres 'Float'. Ainsi, si l'on veut */
/* etre vraiment sur que 'a < b', on utilisera non pas : */
/* */
/* IFLT(a,b) */
/* */
/* mais : */
/* */
/* FfIFLT(a,b) */
/* */
/* dans les situations delicates. De plus, dans la */
/* mesure ou ces fonctions peuvent avoir leur utilite */
/* ailleurs, leur definition n'est pas conditionnelle */
/* (via 'BUG_SYSTEME_APC_GCC_ExcessPrecisionProblem_01')... */
/* */
/* Le 20040308095027, j'ai decide d'etendre cela aux */
/* operations arithmetiques en plus des tests... */
/* */
/*************************************************************************************************************************************/
#define sfIZLE(x1) \
FfIZLE(FLOT(x1))
#define sfIZLT(x1) \
FfIZLT(FLOT(x1))
#define sfIZEQ(x1) \
FfIZEQ(FLOT(x1))
#define sfIZGE(x1) \
FfIZGE(FLOT(x1))
#define sfIZGT(x1) \
FfIZGT(FLOT(x1))
/* Tests de 'x1' par rapport a zero, le 's' etant la pour "Sur"... */
#define sfIFLE(x1,x2) \
FfIFLE(FLOT(x1),FLOT(x2))
#define sfIFLT(x1,x2) \
FfIFLT(FLOT(x1),FLOT(x2))
#define sfIFEQ(x1,x2) \
FfIFEQ(FLOT(x1),FLOT(x2))
#define sfIFNE(x1,x2) \
FfIFNE(FLOT(x1),FLOT(x2))
#define sfIFGE(x1,x2) \
FfIFGE(FLOT(x1),FLOT(x2))
#define sfIFGT(x1,x2) \
FfIFGT(FLOT(x1),FLOT(x2))
/* Tests de 'x1' par rapport a 'x2', le 's' etant la pour "Sur"... */
#define sfIFLc(x1,x2,le_test_est_strict) \
COND(EST_VRAI(le_test_est_strict),sfIFLT(x1,x2),sfIFLE(x1,x2))
#define sfIFGc(x1,x2,le_test_est_strict) \
COND(EST_VRAI(le_test_est_strict),sfIFGT(x1,x2),sfIFGE(x1,x2))
/* Tests conditionnels de 'x1' par rapport a 'x2', le 's' etant la pour "Sur". Ceci a ete */
/* introduit le 20040407163856 pour etre utilise dans 'v $ximd/operator.1$FON IFGc' si */
/* besoin est... */
#define sfDIVZ(x1,x2) \
FfDIVZ(FLOT(x1),FLOT(x2)) \
/* Operations arithmetiques a deux operandes, le 's' etant la pour "Sur". ATTENTION : on */ \
/* ne peut definir : */ \
/* */ \
/* #define sfREST(x1,x2) \ */ \
/* FfREST(FLOT(x1),FLOT(x2)) */ \
/* */ \
/* car, en effet, la procedure 'REST(...)' ne connait que des arguments entiers... */ \
/* */ \
/* Les quatre fonctions {sfADD2(...),sfSOUS(...),sfMUL2(...),sfDIVI(...)} ont ete mises */ \
/* dans 'v $xil/defi_c3$vv$DEF 20040423150108' le 20040423150454 afin que tout fonctionne */ \
/* correctement avec les operateurs derivables... */
#define sfADD3(x1,x2,x3) \
FfADD3(FLOT(x1),FLOT(x2),FLOT(x3))
#define sfMUL3(x1,x2,x3) \
FfMUL3(FLOT(x1),FLOT(x2),FLOT(x3))
/* Operations arithmetiques a trois operandes, le 's' etant la pour "Sur"... */
#define sfADD4(x1,x2,x3,x4) \
FfADD4(FLOT(x1),FLOT(x2),FLOT(x3),FLOT(x4))
#define sfMUL4(x1,x2,x3,x4) \
FfMUL4(FLOT(x1),FLOT(x2),FLOT(x3),FLOT(x4))
/* Operations arithmetiques a quatre operandes, le 's' etant la pour "Sur"... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S R E R E C H E R C H E D ' E X T R E M A D E D E U X , T R O I S O U Q U A T R E */
/* V A L E U R S T Y P E E S E T D E S T I N E E S A L I M I T E R L A C O M P L E X I T E D E */
/* C E R T A I N E S E X P R E S S I O N S O U E N C O R E A E V I T E R D E S P R O B L E M E S : */
/* */
/* */
/* Nota important : */
/* */
/* Il convient de bien noter que les */
/* procedures definies dans '$xil/definit$DEF' et dans */
/* les quatre fichiers equivalents '$xil/definit_*$DEF' */
/* du type 'MAX2(...)' presentent des effets */
/* de bord puisque l'un des arguments est */
/* evalue deux fois (il s'agit dans cet exemple */
/* du plus grand des arguments), alors que dans */
/* les fonctions definies dans '$xig/fonct$vv$FON' */
/* il n'y a plus d'effet de bord, chaque argument */
/* n'etant evalue qu'une seule fois. Ainsi, les */
/* couples de procedures du type 'MAX2(...)' et */
/* 'iMAX2(...)' ne sont pas strictement equivalents */
/* (ce ne sera le cas que si les arguments ne varient */
/* pas d'une evaluation a l'autre). De tels effets de */
/* bord peuvent se rencontrer, par exemple, avec des */
/* generateurs de nombres aleatoires... */
/* */
/*************************************************************************************************************************************/
#define iCOND(condition,n1,n2) \
FiCOND(LOGI(condition),INTE(n1),INTE(n2)) \
/* Selection d'un nombre entier parmi deux, suivant une condition logique. */ \
/* */ \
/* ATTENTION : on notera la difference entre : */ \
/* */ \
/* iCOND(condition_logique,argument1,argument2) */ \
/* */ \
/* et : */ \
/* */ \
/* COND(condition_logique,argument1,argument2) */ \
/* */ \
/* en effet, avec 'iCOND(...)' 'argument1' et 'argument2' sont evalues tous les deux */ \
/* avant l'appel de 'FiCOND(...)', alors qu'avec 'COND(...)', seul l'argument qui est */ \
/* utile ('argument1' ou 'argument2') est evalue... */
#define fCOND(condition,x1,x2) \
FfCOND(LOGI(condition),FLOT(x1),FLOT(x2)) \
/* Selection d'un nombre flottant parmi deux, suivant une condition logique. */ \
/* */ \
/* NOTA : cette fonction est utilisee en particulier dans les programmes */ \
/* 'v $xrq/nucleon.L0$K' et 'v $xrq/nucleon.LX$I' pour eliminer le bug defini dans le */ \
/* fichier 'v $xiii/montagnes$DEF' et baptise 'BUG_SYSTEME_C_complexite_02'. */ \
/* et baptise 'BUG_SYSTEME_C_complexite_02'. */ \
/* */ \
/* ATTENTION : on notera la difference entre : */ \
/* */ \
/* fCOND(condition_logique,argument1,argument2) */ \
/* */ \
/* et : */ \
/* */ \
/* COND(condition_logique,argument1,argument2) */ \
/* */ \
/* en effet, avec 'fCOND(...)' 'argument1' et 'argument2' sont evalues tous les deux */ \
/* avant l'appel de 'FfCOND(...)', alors qu'avec 'COND(...)', seul l'argument qui est */ \
/* utile ('argument1' ou 'argument2') est evalue... */
#define iMAX2(n1,n2) \
FiMAX2(INTE(n1),INTE(n2)) \
/* Recherche du maximum entier de deux nombres entiers. */
#define fMAX2(x1,x2) \
FfMAX2(FLOT(x1),FLOT(x2)) \
/* Recherche du maximum flottant de deux nombres flottants. */ \
/* NOTA : cette fonction est utilisee en particulier dans le fichier 'v $xiii/montagnes$DEF' */ \
/* pour eliminer le bug baptise 'BUG_SYSTEME_C_complexite_02'. */
#define iMAX3(n1,n2,n3) \
FiMAX3(INTE(n1),INTE(n2),INTE(n3)) \
/* Recherche du maximum entier de trois nombres entiers. */
#define fMAX3(x1,x2,x3) \
FfMAX3(FLOT(x1),FLOT(x2),FLOT(x3)) \
/* Recherche du maximum flottant de trois nombres flottants. */
#define iMAX4(n1,n2,n3,n4) \
FiMAX4(INTE(n1),INTE(n2),INTE(n3),INTE(n4)) \
/* Recherche du maximum entier de quatre nombres entiers. */
#define fMAX4(x1,x2,x3,x4) \
FfMAX4(FLOT(x1),FLOT(x2),FLOT(x3),FLOT(x4)) \
/* Recherche du maximum flottant de quatre nombres flottants. */
#define iMIN2(n1,n2) \
FiMIN2(INTE(n1),INTE(n2)) \
/* Recherche du minimum entier de deux nombres entiers. */
#define fMIN2(x1,x2) \
FfMIN2(FLOT(x1),FLOT(x2)) \
/* Recherche du minimum flottant de deux nombres flottants. */
#define iMIN3(n1,n2,n3) \
FiMIN3(INTE(n1),INTE(n2),INTE(n3)) \
/* Recherche du minimum entier de trois nombres entiers. */
#define fMIN3(x1,x2,x3) \
FfMIN3(FLOT(x1),FLOT(x2),FLOT(x3)) \
/* Recherche du minimum flottant de trois nombres flottants. */
#define iMIN4(n1,n2,n3,n4) \
FiMIN4(INTE(n1),INTE(n2),INTE(n3),INTE(n4)) \
/* Recherche du minimum entier de quatre nombres entiers. */
#define fMIN4(x1,x2,x3,x4) \
FfMIN4(FLOT(x1),FLOT(x2),FLOT(x3),FLOT(x4)) \
/* Recherche du minimum flottant de quatre nombres flottants. */
#define iDIVZ(dividende,diviseur) \
FiDIVZ(INTE(dividende),INTE(diviseur)) \
/* Division de deux nombres entiers avec test du diviseur. */
#define ffDIVZ(dividende,diviseur) \
FffDIVZ(FLOT(dividende),FLOT(diviseur)) \
/* Division de deux nombres flottants avec test du diviseur. */
#define ffDIVZ_a_peu_pres(dividende,diviseur) \
FffDIVZ_a_peu_pres(FLOT(dividende),FLOT(diviseur)) \
/* Division de deux nombres flottants avec test du diviseur a "epsilon pres". */
#define iMODU(n,origine,extremite) \
FiMODU(INTE(n),INTE(origine),INTE(extremite)) \
/* Calcul "modulo" d'un entier. */
#define fMODU(x,origine,extremite) \
FfMODU(FLOT(x),FLOT(origine),FLOT(extremite)) \
/* Calcul "modulo" d'un flottant. */
#define iMODS(n,origine,extremite) \
FiMODS(INTE(n),INTE(origine),INTE(extremite)) \
/* Calcul "modulo" d'un entier. */
#define fMODF(x,origine,extremite) \
FfMODF(FLOT(x),FLOT(origine),FLOT(extremite)) \
/* Calcul "modulo" d'un flottant. */
#define ffREST(x,y) \
FffREST(FLOT(x),FLOT(y)) \
/* Reste de la division de deux nombres flottants. */
#define iMULD(n,base) \
FiMULD(INTE(n),INTE(base)) \
/* Calcul d'un multiple proche par defaut d'un entier. */
#define ffMULD(x,base) \
FffMULD(FLOT(x),FLOT(base)) \
/* Calcul d'un multiple proche par defaut d'un flottant. */
#define iMULE(n,base) \
FiMULE(INTE(n),INTE(base)) \
/* Calcul d'un multiple proche par exces d'un entier. */
#define ffMULE(x,base) \
FffMULE(FLOT(x),FLOT(base)) \
/* Calcul d'un multiple proche par exces d'un flottant. */
#define ffARRI(x,epsilon) \
FffARRI(FLOT(x),FLOT(epsilon)) \
/* Calcul de l'arrondi generalise d'un nombre flottant. */
#define iSCAL(n,ancien_intervalle,nouvel_intervalle) \
FiSCAL(INTE(n),INTE(ancien_intervalle),INTE(nouvel_intervalle)) \
/* Calcul de la "regle de trois". */
#define fSCAL(x,ancien_intervalle,nouvel_intervalle) \
FfSCAL(FLOT(x),FLOT(ancien_intervalle),FLOT(nouvel_intervalle)) \
/* Calcul de la "regle de trois". */
#define iHOMO(n,origine1,extremite1,origine2,extremite2) \
FiHOMO(INTE(n),INTE(origine1),INTE(extremite1),INTE(origine2),INTE(extremite2)) \
/* Calcul de passage d'un intervalle a un autre. */
#define fHOMO(x,origine1,extremite1,origine2,extremite2) \
FfHOMO(FLOT(x),FLOT(origine1),FLOT(extremite1),FLOT(origine2),FLOT(extremite2)) \
/* Calcul de passage d'un intervalle a un autre. */
#define iHOMZ(n,origine1,extremite1,origine2,extremite2) \
FiHOMZ(INTE(n),INTE(origine1),INTE(extremite1),INTE(origine2),INTE(extremite2)) \
/* Calcul de passage d'un intervalle a un autre. */
#define fHOMZ(x,origine1,extremite1,origine2,extremite2) \
FfHOMZ(FLOT(x),FLOT(origine1),FLOT(extremite1),FLOT(origine2),FLOT(extremite2)) \
/* Calcul de passage d'un intervalle a un autre. */
#define iNORM(n,ancien_intervalle,nouvel_intervalle) \
FiNORM(INTE(n),INTE(ancien_intervalle),INTE(nouvel_intervalle)) \
/* Calcul de la normalisation. */
#define fNORM(x,ancien_intervalle,nouvel_intervalle) \
FfNORM(FLOT(x),FLOT(ancien_intervalle),FLOT(nouvel_intervalle)) \
/* Calcul de la normalisation. */
#define iNORZ(n,ancien_intervalle,nouvel_intervalle,exception) \
FiNORZ(INTE(n),INTE(ancien_intervalle),INTE(nouvel_intervalle),INTE(exception)) \
/* Calcul de la normalisation. */
#define fNORZ(x,ancien_intervalle,nouvel_intervalle,exception) \
FfNORZ(FLOT(x),FLOT(ancien_intervalle),FLOT(nouvel_intervalle),FLOT(exception)) \
/* Calcul de la normalisation. */
#define iTRON(n,origine,extremite) \
FiTRON(INTE(n),INTE(origine),INTE(extremite)) \
/* Calcul de troncation. */
#define fTRON(x,origine,extremite) \
FfTRON(FLOT(x),FLOT(origine),FLOT(extremite)) \
/* Calcul de troncation. */
#define iSPIRALE_X(index,saut) \
FiSPIRALE_X(INTE(index),INTE(saut))
#define iSPIRALE_Y(index,saut) \
FiSPIRALE_Y(INTE(index),INTE(saut))
/* Coordonnees entieres sur une spirale. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D O N N E S U T I L E S A U X G E N E R A T E U R S D E S F O N C T I O N S C O R R E S P O N D A N T A U X */
/* O P E R A T I O N S A R I T H M E T I Q U E S E T E N D U E S E N T R E N O M B R E S F L O T T A N T S : */
/* */
/*************************************************************************************************************************************/
#define _FZERO \
FZERO
#define __FZERO \
FZERO
#define ___FZERO \
FZERO
#define _FU \
FU
#define __FU \
FU
#define ___FU \
FU
/* Introduits le 20061025090128 afin d'ameliorer la presentation des definitions des */
/* ponderations correspondantes. Le 20101111094138 ceci fut installe ici a partir de */
/* 'v $xig/fonct$vv$FON 20101111094153'... */
#define RAISON_DES_CALCULS_ENTIERS_BRUTAUX_MODULO_AVEC_L_ARITHMETIQUE_ETENDUE \
DEUX \
/* Raison par defaut des congruences lorsque celles-ci sont demandees (introduite le */ \
/* 20111003113313). */
#define GENERATEUR__GENERE__FonctionF_UNI2_02(nom_et_arguments_de_la_fonction,nom_de_la_fonction,expression) \
DEFV(FonctionF,nom_et_arguments_de_la_fonction) \
DEFV(Argument,DEFV(Float,argument1)); \
DEFV(Argument,DEFV(Float,argument2)); \
/*-----------------------------------------------------------------------------------------------------------------------------------*/ \
Bblock \
DEFV(Float,INIT(resultat,FLOT__UNDEF)); \
/* Valeur intermediaire introduite le 20090330112301 dans l'idee d'offrir la possibilite */ \
/* d'effectuer les calculs evidemment en 'Float' mais aussi en 'vrai_Float_de_base'... */ \
/*..............................................................................................................................*/ \
RESTAURATION_DE_LA_VALEUR_PAR_DEFAUT_DES_ARGUMENTS_IMPLICITES(forcer_la_reinitialisation_des_fonctions_d_arithmetique_etendue); \
/* Introduit le 20080107090628 pour le plaisir. Cette restauration se fera grace au code */ \
/* suivant : */ \
/* */ \
/* EGAL(forcer_la_reinitialisation_des_fonctions_d_arithmetique_etendue,VRAI); */ \
/* CALS(FONCTION(FLOT__ARGUMENT_INUTILE,FLOT__ARGUMENT_INUTILE)); */ \
/* EGAL(forcer_la_reinitialisation_des_fonctions_d_arithmetique_etendue,FAUX); */ \
/* */ \
/* implante la ou 'FONCTION(...)' (de nom 'nom_de_la_fonction') est utile... */ \
\
Test(IFET(IL_FAUT(utiliser_evidemment_la_precision_Float_avec_l_arithmetique_etendue) \
,IL_FAUT(nom_de_la_fonction ## utiliser_evidemment_la_precision_Float) \
) \
) \
/* Possibilite introduite le 20090330113257 et completee le 20090331084223 avec un */ \
/* indicateur de controle global... */ \
Bblock \
EGAL(resultat,expression(nom_de_la_fonction,NEUT,NEUT)); \
Eblock \
ATes \
Bblock \
EGAL(resultat,expression(nom_de_la_fonction,FLOT,vbFLOT)); \
/* Dispositif de calcul en 'vrai_Float_de_base' introduit le 20090330113257. */ \
/* */ \
/* Une application de ceci est, par exemple, de calculer l'ensemble de Mandelbrot en 64, */ \
/* puis en 32 bits avec respectivement : */ \
/* */ \
/* $xrc/mandel.01$X arithmetique_de_base_C=VRAI \ */ \
/* (...) */ \
/* */ \
/* puis : */ \
/* */ \
/* $xrc/mandel.01$X arithmetique_etendue_C=VRAI \ */ \
/* xFloat=FAUX \ */ \
/* (...) */ \
/* */ \
/* et le tour est joue... */ \
Eblock \
ETes \
\
Test(IL_FAUT(faire_des_calculs_entiers_brutaux_modulo_avec_l_arithmetique_etendue)) \
Bblock \
EGAL(resultat,FLOT(REST(INTE(resultat),raison_des_calculs_entiers_brutaux_modulo_avec_l_arithmetique_etendue))); \
/* Possibilite "brutale" (car on passe en 'Int' sans verifier que cela est possible...) */ \
/* introduite le 20111003104139. Elle permet donc de faire des calculs modulo... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
INCK(nom_de_la_fonction ## compteur_de_reference); \
/* Introduit le 20130514122726 afin de permettre de compter (si besoin est) le nombre */ \
/* d'operations elementaires executees dans un programme... */ \
\
RETU(resultat); \
Eblock \
/* Cas des procedures 'Float' a deux arguments 'Float' (introduit le 20061024103437)... */ \
/* */ \
/* On notera que 'Xnom_de_la_procedure_de_base_a_etendre' ne peut etre ni de la forme */ \
/* 'FfxADD2' ni de la forme 'ADD2' (en prenant l'exemple de la definition de la fonction */ \
/* 'FfxADD2(...)') car dans un cas comme dans l'autre 'FfxADD2' et 'ADD2' sont des noms */ \
/* de procedures avec arguments et donc avec '(...)' ce qui pose evidemment un probleme */ \
/* apres la concatenation. On doit donc utiliser, dans cet exemple, le nom 'dans_FfxADD2' */ \
/* qui n'existe pas en tant que '#define' ('v $xig/fonct$vv$FON dans_FfxADD2'). */ \
/* */ \
/* Cette procedure a ete transferee depuis 'v $xig/fonct$vv$FON' le 20061024121646 afin */ \
/* de pouvoir etre utilisee dans 'v $xrv/UNI2.11$K GENERE__FonctionF_UNI2_02'... */ \
/* */ \
/* Le 20061024121646, de plus la procedure 'UNI2(...)' a ete supprimee car, en effet, sa */ \
/* mise a jour etait difficile : il convenait, si une nouvelle ponderation et une nouvelle */ \
/* procedures etaient ajoutees, de ne pas de tromper en l'inserant partout ou necessaire et */ \
/* exactement au bon endroit... */ \
/* */ \
/* Le 20061025132344 furent introduites 'MOYZSI(...)' et 'MOYQSI(...)'. */ \
/* */ \
/* Le 20080102133640 furent introduites 'IMINMAX(...)' et 'IMAXMIN(...)'. */ \
/* */ \
/* Le 20080104154112 fut introduite 'SPUIX(...)' ; cela a conduit a la modification */ \
/* 'v $xil/defi_K2$vv$DEF 20080104162535' car, sans elle, meme lorsque la ponderation */ \
/* de 'SPUIX(...)' etait nulle, le cas 'SPUIX(0,ValeurNegative)' donnait l'infini et a */ \
/* ce produit une valeur non nulle... */ \
/* */ \
/* Le 20080106103831 j'ai tente de remplacer 'LIN16(...)' par 'FfLIO16(...)' pour optimiser */ \
/* mais, malheureusement, la compilation de cette derniere fonction est trop "lourde" et */ \
/* j'ai donc du y renoncer... */ \
/* */ \
/* Le 20080106113404, j'ai du mettre en place une optimisation "locale" relative a */ \
/* 'SPUIX(...)' car, en effet, le risque est grand de generer des infinis comme on le */ \
/* voit avec l'exemple : */ \
/* */ \
/* $xcg/ADD3.01$X a=10 b=200 c=3000 */ \
/* */ \
/* qui donne "+nan", la fonction 'SPUIX(...)' etant evaluee meme si sa ponderation est nulle */ \
/* (ce qui est le cas par defaut...). */ \
/* */ \
/* Le 20080111092552, une optimisation "locale" relative a tous les operateurs a ete mise */ \
/* en place, mais cette fois-ci pour des raisons de performance... */ \
/* */ \
/* Le 20080111143534, toutes les optimisations locales ont pu etre supprimees grace a */ \
/* l'introduction de 'LIO16(...)' (suite a 'v $xil/defi_K2$vv$DEF 20080111142631' qui a */ \
/* enfin permis l'utilisation "raisonnable" 'LIO16(...)'...). */ \
/* */ \
/* ATTENTION : on notera le 20080117101020 que 'GENERE__FonctionF_UNI2_02(...)', lorsqu'elle */ \
/* est utilisee sur '$CMAP28', interdit l'optimisation. Voir a ce propos : */ \
/* */ \
/* v $xbg/fonction$K PRAGMA_CL_____MODULE_NON_OPTIMISABLE_CMAP28 */ \
/* v $xrv/UNI2.11$K PRAGMA_CL_____MODULE_NON_OPTIMISABLE_CMAP28 */ \
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T E U R S D E S F O N C T I O N S C O R R E S P O N D A N T A U X */
/* O P E R A T I O N S A R I T H M E T I Q U E S E T E N D U E S E N T R E N O M B R E S F L O T T A N T S : */
/* */
/*************************************************************************************************************************************/
#define EXPRESSION_GENERE__FonctionF_UNI2_02(nom_de_la_fonction,FConvR,FConvA) \
/* Procedure introduite le 20090330175547 pour simplifier 'GENERE__FonctionF_UNI2_02(...)'. */ \
FConvR(LIO25(FConvA(nom_de_la_fonction ## ponderation_de_ADD2) ,ADD2(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* x+y */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_SOUS) ,SOUS(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* x-y */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_SOUSnc) ,SOUS(FConvA(argument2),FConvA(argument1)) \
/* */ \
/* y-x */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MUL2) ,MUL2(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* x.y */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_DIVZ) ,DIVZ(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* x/y */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_DIVZnc) ,DIVZ(FConvA(argument2),FConvA(argument1)) \
/* */ \
/* y/x */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MIN2) ,MIN2(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* min(x,y) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MAX2) ,MAX2(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* max(x,y) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MINMAX) ,MINMAX(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* max(min(x,1-y),min(1-x,y)) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MAXMIN) ,MAXMIN(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* min(max(x,1-y),max(1-x,y)) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_IMINMAX) ,IMINMAX(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* max(min(x,1/y),min(1/x,y)) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_IMAXMIN) ,IMAXMIN(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* min(max(x,1/y),max(1/x,y)) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MOYE) ,MOYE(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* (x+y)/2 */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MOYZ) ,MOYZ(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* sqrt(|x|.|y|) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MOYZSI) ,MOYZSI(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* signe(x.y).sqrt(|x|.|y|) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MOYQ) ,MOYQ(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* sqrt(((x.x)+(y.y))/2) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MOYQSI) ,MOYQSI(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* signe(x.y).sqrt(((x.x)+(y.y))/2) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MOYH) ,MOYH(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* (2.x.y)/(x+y) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_SPUIX) ,SPUIX(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* signe(x.y).pow(|x|,y) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_SPUIXnc) ,SPUIX(FConvA(argument2),FConvA(argument1)) \
/* */ \
/* signe(y.x).pow(|y|,x) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_SE12) ,SE12(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* x */ \
/* */ \
/* On notera que : */ \
/* */ \
/* SE12nc = SE22 */ \
/* */ \
/* 'SE12nc' ("nc"="Non Commutatifs") n'existant pas pour cette raison... */ \
,FConvA(nom_de_la_fonction ## ponderation_de_SE22) ,SE22(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* y */ \
/* */ \
/* On notera que : */ \
/* */ \
/* SE22nc = SE12 */ \
/* */ \
/* 'SE22nc' ("nc"="Non Commutatifs") n'existant pas pour cette raison... */ \
,FConvA(nom_de_la_fonction ## ponderation_de_ATAN) ,ATAN(FConvA(argument2),FConvA(argument1)) \
/* */ \
/* atan(y,x) */ \
/* */ \
/* Au passage, faut-il utiliser 'atan(y,x)' (similaire a la definition de 'ATAN(...)' et */ \
/* ou donc les arguments 'argument1' et 'argument2' sont permutes), ou bien 'atan(x,y)' ? */ \
,FConvA(nom_de_la_fonction ## ponderation_de_ATANnc) ,ATAN(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* atan(x,y) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MULH24) ,MULH24(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* MULH24(x,y) */ \
/* */ \
,FZERO \
) \
) \
/* Avec les notations evidentes suivantes : */ \
/* */ \
/* x = argument1 */ \
/* y = argument2 */ \
/* */ \
/* ATTENTION : jusqu'au 20070201092408, par erreur, la fonction 'MOYZSI(...)' etait */ \
/* utilisee a la place de 'MOYQSI(...)'... */ \
/* */ \
/* Le 20180821094203 ont ete introduits les operateurs 'SE12(...)' et 'SE22(...)' pour */ \
/* le plaisir... */ \
/* */ \
/* Le 20181009170109 a ete introduit l'operateur 'ATAN(...)' pour le plaisir... */ \
/* */ \
/* On notera le 20181010152837, qu'au lieu d'ecrire, par exemple : */ \
/* */ \
/* FConvA(nom_de_la_fonction ## ponderation_de_ADD2) */ \
/* */ \
/* on pourrait peut-etre parametrer un peu plus de la facon suivante : */ \
/* */ \
/* #define PONDERATION \ */ \
/* ponderation_de_ */ \
/* */ \
/* puis remplacer le 'FConvA(...)' ci-dessus par : */ \
/* */ \
/* FConvA(nom_de_la_fonction ## PONDERATION __@@QD "ADD2") */ \
/* */ \
/* (on remarquera l'encadrement de 'ADD2' par des '$K_QD's afin que l'operateur 'ADD2(...)' */ \
/* ne soit pas interprete). Mais tout ceci a-t-il une utilite ? La seule que je vois pour le */ \
/* moment est d'avoir trouve, lors de ces tests, le moyen de bloquer l'interpretation d'un */ \
/* operateur avec '__@@QD'... */ \
/* */ \
/* Le 20181203161212 fut introduit 'MULH24(...)'... */ \
/* */ \
/* C'est cette procedure qui la cause de 'v $xbii/tri_image$K 20181204173010' ainsi que je */ \
/* le note le 20181204174855... */ \
/* */ \
/* Le 20201004103629 furent introduits les versions "commutees" des operateurs dits */ \
/* "Non Commutatifs"... */
#define GENERE__FonctionF_UNI2_02(nom_et_arguments_de_la_fonction,nom_de_la_fonction) \
GENERATEUR__GENERE__FonctionF_UNI2_02(nom_et_arguments_de_la_fonction \
,nom_de_la_fonction \
,EXPRESSION_GENERE__FonctionF_UNI2_02 \
) \
/* Introduit sous cette forme le 20201005123347... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T E U R S D E S F O N C T I O N S A L L E G E E S C O R R E S P O N D A N T A U X */
/* O P E R A T I O N S A R I T H M E T I Q U E S E T E N D U E S E N T R E N O M B R E S F L O T T A N T S : */
/* */
/*************************************************************************************************************************************/
#define EXPRESSION_GENERE__FonctionF_UNI2_02_ALLEGEE(nom_de_la_fonction,FConvR,FConvA) \
FConvR(LIO17(FConvA(nom_de_la_fonction ## ponderation_de_ADD2) ,ADD2(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* x+y */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_SOUS) ,SOUS(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* x-y */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MUL2) ,MUL2(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* x.y */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_DIVZ) ,DIVZ(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* x/y */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MIN2) ,MIN2(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* min(x,y) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MAX2) ,MAX2(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* max(x,y) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MINMAX) ,MINMAX(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* max(min(x,1-y),min(1-x,y)) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MAXMIN) ,MAXMIN(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* min(max(x,1-y),max(1-x,y)) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MOYE) ,MOYE(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* (x+y)/2 */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MOYZ) ,MOYZ(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* sqrt(|x|.|y|) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MOYZSI) ,MOYZSI(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* signe(x.y).sqrt(|x|.|y|) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MOYQ) ,MOYQ(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* sqrt(((x.x)+(y.y))/2) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MOYQSI) ,MOYQSI(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* signe(x.y).sqrt(((x.x)+(y.y))/2) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MOYH) ,MOYH(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* (2.x.y)/(x+y) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_SPUIX) ,SPUIX(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* signe(x.y).pow(|x|,y) */ \
/* */ \
,FConvA(nom_de_la_fonction ## ponderation_de_ATAN) ,ATAN(FConvA(argument2),FConvA(argument1)) \
/* */ \
/* atan(y,x) */ \
/* */ \
/* Au passage, faut-il utiliser 'atan(y,x)' (similaire a la definition de 'ATAN(...)' et */ \
/* ou donc les arguments 'argument1' et 'argument2' sont permutes), ou bien 'atan(x,y)' ? */ \
,FConvA(nom_de_la_fonction ## ponderation_de_MULH24) ,MULH24(FConvA(argument1),FConvA(argument2)) \
/* */ \
/* MULH24(x,y) */ \
/* */ \
,FZERO \
) \
) \
/* Avec les notations evidentes suivantes : */ \
/* */ \
/* x = argument1 */ \
/* y = argument2 */ \
/* */
#define GENERE__FonctionF_UNI2_02_ALLEGEE(nom_et_arguments_de_la_fonction,nom_de_la_fonction) \
GENERATEUR__GENERE__FonctionF_UNI2_02(nom_et_arguments_de_la_fonction \
,nom_de_la_fonction \
,EXPRESSION_GENERE__FonctionF_UNI2_02_ALLEGEE \
) \
/* Introduit sous cette forme le 20201005123347. On notera que cette version dite "ALLEGEE" */ \
/* a ete introduite a cause de 'v $xbii/tri_image$K PRAGMA_CPP_____AUTORISER_LE_GooF' pour */ \
/* lequel le pre-processing depassait une heure... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D O N N E S U T I L E S A U X G E N E R A T E U R S D E S F O N C T I O N S C O R R E S P O N D A N T A U X */
/* T R A N S F O R M A T I O N S " U N I V E R S E L L E S " D E S N O M B R E S F L O T T A N T S : */
/* */
/*************************************************************************************************************************************/
#define GENERATEUR__GENERE__FonctionF_UNI1_01(nom_et_arguments_fonction,nom_fonction,expression) \
/* Procedure introduite le 20220116120735... */ \
DEFV(FonctionF,nom_et_arguments_fonction) \
DEFV(Argument,DEFV(Float,argument)); \
/*-----------------------------------------------------------------------------------------------------------------------------------*/ \
Bblock \
DEFV(Float,INIT(resultat,FLOT__UNDEF)); \
/*..............................................................................................................................*/ \
RESTAURATION_DE_LA_VALEUR_PAR_DEFAUT_DES_ARGUMENTS_IMPLICITES(forcer_la_reinitialisation_des_fonctions_d_arithmetique_etendue); \
/* Introduit le 20080107090628 pour le plaisir. Cette restauration se fera grace au code */ \
/* suivant : */ \
/* */ \
/* EGAL(forcer_la_reinitialisation_des_fonctions_d_arithmetique_etendue,VRAI); */ \
/* CALS(FONCTION(FLOT__ARGUMENT_INUTILE,FLOT__ARGUMENT_INUTILE)); */ \
/* EGAL(forcer_la_reinitialisation_des_fonctions_d_arithmetique_etendue,FAUX); */ \
/* */ \
/* implante la ou 'FONCTION(...)' (de nom 'nom_fonction') est utile... */ \
\
EGAL(resultat,expression(nom_fonction,NEUT,NEUT)); \
\
INCK(nom_fonction ## compteur_de_reference); \
\
RETU(resultat); \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T E U R S D E S F O N C T I O N S C O R R E S P O N D A N T A U X */
/* T R A N S F O R M A T I O N S " U N I V E R S E L L E S " D E S N O M B R E S F L O T T A N T S : */
/* */
/*************************************************************************************************************************************/
#define EXPRESSION_GENERE__FonctionF_UNI1_01(nom_fonction,FCoR,FCoA) \
FCoR(LIO14(FCoA(nom_fonction ## ponderation_de_NEUT) ,NEUT(FCoA(argument)) \
/* */ \
/* y */ \
/* */ \
,FCoA(nom_fonction ## ponderation_de_COSX) ,COSX(FCoA(argument)) \
/* */ \
/* cos(y) */ \
/* */ \
,FCoA(nom_fonction ## ponderation_de_SINX) ,SINX(FCoA(argument)) \
/* */ \
/* sin(y) */ \
/* */ \
,FCoA(nom_fonction ## ponderation_de_TANX) ,TANX(FCoA(argument)) \
/* */ \
/* tan(y) */ \
/* */ \
,FCoA(nom_fonction ## ponderation_de_ATAN) ,ATAN(FCoA(argument),FCoA(nom_fonction ## arg_x_ATAN)) \
/* */ \
/* atan(y,x) */ \
/* */ \
,FCoA(nom_fonction ## ponderation_de_COHX) ,COHX(FCoA(argument)) \
/* */ \
/* ch(y) */ \
/* */ \
,FCoA(nom_fonction ## ponderation_de_SIHX) ,SIHX(FCoA(argument)) \
/* */ \
/* sh(y) */ \
/* */ \
,FCoA(nom_fonction ## ponderation_de_TAHX) ,TAHX(FCoA(argument)) \
/* */ \
/* th(y) */ \
/* */ \
,FCoA(nom_fonction ## ponderation_de_CSHX) ,CSHX(FCoA(argument)) \
/* */ \
/* sec(y) */ \
/* */ \
,FCoA(nom_fonction ## ponderation_de_SSHX) ,SSHX(FCoA(argument)) \
/* */ \
/* cosec(y) */ \
/* */ \
,FCoA(nom_fonction ## ponderation_de_CTHX) ,CTHX(FCoA(argument)) \
/* */ \
/* coth(y) */ \
/* */ \
,FCoA(nom_fonction ## ponderation_de_ATAH) ,ATAH(FCoA(argument)) \
/* */ \
/* ath(y) */ \
/* */ \
,FCoA(nom_fonction ## ponderation_de_SLOGX) ,SLOGX(FCoA(argument)) \
/* */ \
/* signe(y).log(|y|+1) */ \
/* */ \
,FCoA(nom_fonction ## ponderation_de_EXPX) ,EXPX(FCoA(argument)) \
/* */ \
/* exp(y) */ \
/* */ \
,FZERO \
) \
) \
/* Avec les notations evidentes suivantes : */ \
/* */ \
/* y = argument */ \
/* */
#define GENERE__FonctionF_UNI1_01(nom_et_arguments_fonction,nom_fonction) \
GENERATEUR__GENERE__FonctionF_UNI1_01(nom_et_arguments_fonction \
,nom_fonction \
,EXPRESSION_GENERE__FonctionF_UNI1_01 \
) \
/* Procedure introduite le 20220116120735... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N I T I A L I S A T I O N D ' U N E C O N S T A N T E " C H A I N E D E C A R A C T E R E S " : */
/* */
/*************************************************************************************************************************************/
/* ATTENTION, il est imperatif que 'GENERE__FonctionC_INIC(...)' soit definie dans */
/* 'v $xig/fonct$vv$DEF' et non pas dans 'v $xig/fonct$vv$FON' car, en effet, l'existence */
/* de ce symbole est teste dans 'v $xig/fonct$vv$ARG GENERE__FonctionC_INIC' ainsi que */
/* dans 'v $xig/fonct$vv$EXT GENERE__FonctionC_INIC'. Le transfert de '$xig/fonct$vv$FON' */
/* vers $xig/fonct$vv$DEF' a ete effectue le 19990303155346 ; il avait ete visiblement */
/* oublie il y a bien longtemps... */
#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)) \
|| (defined(SYSTEME_DECALPHA340_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA350_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA464_OSF1_CC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_FXC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_PCC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_SCC)) \
|| (defined(SYSTEME_FX40_CONCENTRIX_CC)) \
|| (defined(SYSTEME_FX40_CONCENTRIX_FXC)) \
|| (defined(SYSTEME_NWS3000_NEWSOS_CC)) \
|| (defined(SYSTEME_NWS3000_NEWSOS_2CC)) \
|| (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)) \
|| (defined(SYSTEME_SUN3_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4NCUBE2S_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4NCUBE2S_SUNOS_NCC)) \
|| (defined(SYSTEME_VAX9000_ULTRIX_GCC)) \
)
# pragma xcg__gen_ext_Z__gen_Fonction_SE__GENERE__Fonction GENERE__FonctionC_INIC POINTERc
/* Introduit le 20040520120747. */
# define GENERE__FonctionC_INIC(nom_et_arguments_de_la_fonction) \
/* ATTENTION : le nom de la fonction est suivi de ses arguments pour des raisons liees */ \
/* a la recuperation automatique des fichiers d'arguments. */ \
DEFV(FonctionC,POINTERc(nom_et_arguments_de_la_fonction)) \
/* ATTENTION : la valeur renvoyee par la fonction elle-meme */ \
/* est un pointeur vers la chaine resultante, d'ou le type 'FonctionC'. */ \
/* Le resultat pourra donc etre placee dans une variable POINTERc... */ \
/* */ \
/* Jusqu'au 20071114142111, il y a eu ici en tete un 'DEFV(Common,'... */ \
DEFV(Argument,DEFV(CHAR,POINTERc(chaineA))); \
/* Argument. */ \
/*-----------------------------------------------------------------------------------------------------------------------------------*/ \
Bblock \
/*..............................................................................................................................*/ \
RETU(chaineA); \
/* Renvoi d'un pointeur sur la chaine Argument. */ \
Eblock
#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)) \
|| (defined(SYSTEME_DECALPHA340_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA350_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA464_OSF1_CC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_FXC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_PCC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_SCC)) \
|| (defined(SYSTEME_FX40_CONCENTRIX_CC)) \
|| (defined(SYSTEME_FX40_CONCENTRIX_FXC)) \
|| (defined(SYSTEME_NWS3000_NEWSOS_CC)) \
|| (defined(SYSTEME_NWS3000_NEWSOS_2CC)) \
|| (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)) \
|| (defined(SYSTEME_SUN3_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4NCUBE2S_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4NCUBE2S_SUNOS_NCC)) \
|| (defined(SYSTEME_VAX9000_ULTRIX_GCC)) \
)
#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)) \
|| (defined(SYSTEME_DECALPHA340_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA350_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA464_OSF1_CC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_FXC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_PCC)) \
|| (defined(SYSTEME_FX2800_CONCENTRIX_SCC)) \
|| (defined(SYSTEME_FX40_CONCENTRIX_CC)) \
|| (defined(SYSTEME_FX40_CONCENTRIX_FXC)) \
|| (defined(SYSTEME_NWS3000_NEWSOS_CC)) \
|| (defined(SYSTEME_NWS3000_NEWSOS_2CC)) \
|| (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)) \
|| (defined(SYSTEME_SUN3_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4NCUBE2S_SUNOS_CC)) \
|| (defined(SYSTEME_SUN4NCUBE2S_SUNOS_NCC)) \
|| (defined(SYSTEME_VAX9000_ULTRIX_GCC)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T E S T D ' U N C A R A C T E R E ( E S T - C E A L P H A - N U M E R I Q U E ? ) : */
/* */
/*************************************************************************************************************************************/
#define VALEUR_NUMERIQUE_D_UN_CARACTERE_NON_HEXADECIMAL \
MOINS_L_INFINI \
/* Afin de savoir si 'est_ce_alpha_numerique(...)' a detecte un chiffre hexa-decimal ou pas. */ \
/* */ \
/* Le 20081216112507, cette valeur est passee de 'UNDEF' a 'MOINS_L_INFINI' afin d'etre */ \
/* sur d'avoir ainsi une valeur impossible a rencontrer, en particulier parce qu'elle est */ \
/* negative. Au passage, avec 'UNDEF' le risque qu'un jour sa valeur devienne, par exemple, */ \
/* 'ZERO'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R A G E D E S F O R M A T S D E S E D I T I O N S F L O T T A N T E S : */
/* */
/*************************************************************************************************************************************/
#define k___NOMBRE_DE_CHIFFRES_DES_EDITIONS_FLOTTANTES \
SUCC(SUCC(SEIZE))
#TestADef NOMBRE_DE_CHIFFRES_DES_EDITIONS_FLOTTANTES \
k___NOMBRE_DE_CHIFFRES_DES_EDITIONS_FLOTTANTES
/* A cause de 'v $xrv/histogram.01$K nombre_de_chiffres_des_editions_flottantes', cela fut */
/* introduit le 20180606154421... */
/* */
/* Le 20240122152020, 'k___NOMBRE_DE_CHIFFRES_DES_EDITIONS_FLOTTANTES' a ete introduit */
/* a cause de 'v $xtKg/Exec_X_CSH.01$K NOMBRE_DE_CHIFFRES_DES_EDITIONS_FLOTTANTES'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S C H A I N E S D E C A R A C T E R E S : */
/* */
/*************************************************************************************************************************************/
#define PREMIER_CARACTERE \
INDEX0 \
/* Premier caractere d'une chaine de caracteres. */
#define PREMIER_CARACTERE_ITb0(chaine) \
ITb0(chaine,INDX(PREMIER_CARACTERE,PREMIER_CARACTERE)) \
/* Recuperation du premier caractere d'une chaine de caracteres de type 'ITb0'. */
#define DERNIER_CARACTERE_ITb0(chaine) \
ITb0(chaine,INDX(LSTX(PREMIER_CARACTERE,chain_Xtaille(chaine)),PREMIER_CARACTERE)) \
/* Recuperation du dernier caractere d'une chaine de caracteres de type 'ITb0' (introduit */ \
/* le 20021207110134). */
#define PREMIER_CARACTERE_ITb1(chaine) \
ITb1(chaine,INDX(PREMIER_CARACTERE,PREMIER_CARACTERE)) \
/* Recuperation du premier caractere d'une chaine de caracteres de type 'ITb1'. */
#define DERNIER_CARACTERE_ITb1(chaine) \
ITb1(chaine,INDX(LSTX(PREMIER_CARACTERE,chain_Xtaille(chaine)),PREMIER_CARACTERE)) \
/* Recuperation du dernier caractere d'une chaine de caracteres de type 'ITb1' (introduit */ \
/* le 20021207110134). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S D E P L A C E M E N T S D E S C H A I N E S D E C A R A C T E R E S : */
/* */
/*************************************************************************************************************************************/
#define MOVE_CARACTERE_DEPLACE_TOUS_LES_CARACTERES \
Bblock \
EGAL(MOVE_CARACTERE_____ne_deplacer_que_les_caracteres_alpha_numeriques,FAUX); \
Eblock \
/* 'MOVE_CARACTERE(...)' deplace tous les caracteres (introduit le 19980420092917). */
#define MOVE_CARACTERE_NE_DEPLACE_QUE_LES_CARACTERES_ALPHA_NUMERIQUES \
Bblock \
EGAL(MOVE_CARACTERE_____ne_deplacer_que_les_caracteres_alpha_numeriques,VRAI); \
Eblock \
/* 'MOVE_CARACTERE(...)' ne deplace que les caracteres alpha-numeriques (introduit le */ \
/* 19980420092917). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N T R O L E D E S M E S S A G E S D A N S D ' E V E N T U E L L E S */
/* B R A N C H E S P A R A L L E L E S : */
/* */
/*************************************************************************************************************************************/
#define UNE_EDITION_PARALLELE_EST_POSSIBLE \
IFOU(IFEQ_chaine(identifiant_de_branches_paralleles,C_VIDE) \
,IFEQ_chaine(identifiant_de_branches_paralleles,CHOY(c_ROUGE,c_VERTE,c_BLEUE)) \
) \
/* Introduit le 20210425075357... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* E D I T I O N D E S M E S S A G E S D ' E R R E U R D E G E S T I O N D E F I C H I E R : */
/* */
/*************************************************************************************************************************************/
#define MESSAGES_DES_FICHIERS(fonction_d_impression,editer_les_messages_d_erreur) \
Bblock \
Test(IL_NE_FAUT_PAS(bloquer_tous_les_messages_d_erreur_des_fichiers)) \
Bblock \
Test(IL_FAUT(editer_les_messages_d_erreur)) \
Bblock \
PRINT_ATTENTION("probleme de gestion de fichiers"); \
CAL1(Prer0("Symptome(s) et/ou action(s) entreprise(s) : ")); \
CAL1(fonction_d_impression); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Procedure d'edition conditionnelle des messages d'erreur de la gestion de fichier. */ \
/* */ \
/* Cette procedure fut deplacee depuis 'v $xig/fonct$vv$FON 20080916144658' jusqu'ici */ \
/* le 20080916144600 pour 'v $xiii/files$FON MESSAGES_DES_FICHIERS'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S N O M S D E F I C H I E R S : */
/* */
/*************************************************************************************************************************************/
#define LONGUEUR_MAXIMALE_D_UN_NOM_ABSOLU_DE_FICHIER \
GvalDefaut("LONGUEUR_PATH",CENT_VINGT_HUIT) \
/* Longueur maximale d'un nom de fichier absolu (y compris le "path" d'acces). */ \
/* */ \
/* ATTENTION : la variable 'LONGUEUR_MAXIMALE_D_UN_NOM_ABSOLU_DE_FICHIER' n'est pas */ \
/* soumise a un '#ifdef SYSTEME_...', car en effet, si l'on souhaite */ \
/* que les logiciels soient portables, il faut que les noms de fichiers */ \
/* le soit aussi ; pour 'LONGUEUR_MAXIMALE_D_UN_NOM_ABSOLU_DE_FICHIER', il */ \
/* faut donc utiliser la valeur minimale sur l'ensemble des 'SYSTEME's... */ \
/* */ \
/* L'option 'GvalDefaut(...)' a ete introduite le 19990204085559 a cause des commandes du */ \
/* type 'v $xiim_LACT29/../...' qui peuvent engendrer des "paths" tres longs... */
#define LONGUEUR_MAXIMALE_D_UN_NOM_RELATIF_DE_FICHIER \
GvalDefaut("LONGUEUR_NOMS",14) \
/* Longueur maximale d'un nom de fichier relatif (non compris le "path" d'acces). */ \
/* */ \
/* ATTENTION : la variable 'LONGUEUR_MAXIMALE_D_UN_NOM_RELATIF_DE_FICHIER' n'est pas */ \
/* soumise a un '#ifdef SYSTEME_...', car en effet, si l'on souhaite */ \
/* que les logiciels soient portables, il faut que les noms de fichiers */ \
/* le soit aussi ; pour 'LONGUEUR_MAXIMALE_D_UN_NOM_RELATIF_DE_FICHIER', il */ \
/* faut donc utiliser la valeur minimale sur l'ensemble des 'SYSTEME's... */ \
/* */ \
/* A cause de 'v $xcg/remote.01$K shell' l'option 'GvalDefaut(...)' a ete introduite */ \
/* le 19971021162819. */
#define SEPARATEUR_DES_DIRECTORIES_D_UN_NOM_DE_FICHIER \
K_SLASH
#define cSEPARATEUR_DES_DIRECTORIES_D_UN_NOM_DE_FICHIER \
C_SLASH
/* Caractere separant les differents noms de directories qui composent un nom. La chaine */
/* correspondante a ete introduite le 20160511100943... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R I S E E N C O M P T E D E S N O M S D E F I C H I E R S */
/* Q U I S O N T E N F A I T D E S V A L E U R S N U M E R I Q U E S : */
/* */
/*************************************************************************************************************************************/
#define gLOAD_FICHIER_AVEC_CONVERSION(No,Co,type,fonction_de_conversion,sequence_initialisation,le_nom_du_fichier_a_ete_converti) \
Bblock \
Test(EST_VRAI(Co)) \
/* Cas ou l'on s'autorise a essayer de convertir le nom 'No' du fichier argument en une */ \
/* valeur numerique... */ \
Bblock \
DEFV(type,INIT(valeur_du_nom,gUNDEF)); \
/* Valeur que l'on donnera aux elements du fichier si le nom correspond strictement a une */ \
/* valeur numerique du type 'type_fichier' sans rien derriere. ATTENTION, on notera que */ \
/* l'on ne peut pas faire mieux qu'utiliser 'UNDEF' pour initialiser 'valeur_du_nom'... */ \
/* ATTENTION, le 19971118091526, je suis passe de 'UNDEF' a 'gUNDEF' afin d'eviter */ \
/* les messages : */ \
/* */ \
/* warning(1069): integer conversion resulted in truncation */ \
/* char valeur_du_nom=57072; */ \
/* */ \
/* sur 'SYSTEME_SGO200A1_IRIX_CC'... */ \
DEFV(Logical,INIT(la_valeur_brute_du_nom_deborde,FAUX)); \
DEFV(Float,INIT(valeur_brute_du_nom,FLOT__UNDEF)); \
/* Valeur "brute", c'est-a-dire avant une eventuelle conversion de type comme c'est le cas */ \
/* dans 'v $xiii/Images$DEF Conversion_generale_genp' (introduit le 20051122085934)... */ \
/* */ \
/* On notera (le 20070710091808) que l'on utilise le type 'Float' avoir de disposer de */ \
/* l'amplitude numerique maximale lors de cette recuperation... */ \
DEFV(Char,INIT(POINTERc(chaine_residuelle),CHAINE_UNDEF)); \
/* Afin de pouvoir regarder ce qui traine derriere la valeur numerique que definit le nom */ \
/* du fichier ; bien entendu, si tout s'est bien passe, 'chaine_residuelle' doit etre vide. */ \
/* */ \
/* Le 20071121134543 a cause de 'SYSTEME_APC_LinuxUbuntu_GCC' sur '$LACT18' et pour eviter */ \
/* le message : */ \
/* */ \
/* warning: passing argument 2 of 'strtod' from incompatible pointer type */ \
/* */ \
/* le 'CHAR' ci-dessus est devenu un 'Char'... */ \
\
EGAL(valeur_du_nom,Conversion_generale`fonction_de_conversion(No,chaine_residuelle)); \
/* On tente de convertir le nom 'No' du fichier argument en une valeur numerique... */ \
EGAL(valeur_brute_du_nom,Conversion_generale_flot(No,chaine_residuelle)); \
/* Et de meme sans aucune conversion de type avec la precision et l'amplitude maximales... */ \
\
Test(EST_UN_BON_Float_FINI(valeur_brute_du_nom)) \
/* Ce test a ete introduit le 20130221082814... */ \
Bblock \
\
&define TestType`type(ArgumentObligatoireParDefinitionDesTypes)&&& \
\
&ifdef TestType`genere_p(ArgumentObligatoireParDefinitionDesTypes)&&& \
Test(IFEXff(valeur_brute_du_nom,FLOT__NOIR,FLOT__BLANC)) \
/* Ce test a ete introduit le 20051122085934... */ \
Bblock \
PRINT_ERREUR("un nom de fichier converti en valeur numerique 'caractere' deborde"); \
CAL1(Prer5("(le nom est '%s' -nom residuel='%s'- et sa valeur %f n'est pas dans [%d,%d])\n" \
,No \
,chaine_residuelle \
,valeur_brute_du_nom \
,NOIR,BLANC \
) \
); \
/* On notera (le 20070710091808) que l'on utilise le type 'Float' pour 'valeur_brute_du_nom' */ \
/* afin de disposer de l'amplitude numerique maximale lors de la recuperation de la "valeur" */ \
/* du nom... */ \
/* */ \
/* Le 20130221081327 l'edition de 'No' et de 'chaine_residuelle' a ete introduite... */ \
\
EGAL(la_valeur_brute_du_nom_deborde,VRAI); \
/* La conversion est alors refusee... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
&Aifdef TestType`genere_p(ArgumentObligatoireParDefinitionDesTypes)&&& \
&Eifdef TestType`genere_p(ArgumentObligatoireParDefinitionDesTypes)&&& \
\
&ifdef TestType`genere_Int(ArgumentObligatoireParDefinitionDesTypes)&&& \
Test(IFEXff(valeur_brute_du_nom,FLOT(MOINS_L_INFINI),FLOT(INFINI))) \
/* Ce test a ete introduit le 20051122132506... */ \
Bblock \
PRINT_ERREUR("un nom de fichier converti en valeur numerique 'entiere' deborde"); \
CAL1(Prer5("(le nom est '%s' -nom residuel='%s'- et sa valeur %f n'est pas dans [%d,%d])\n" \
,No \
,chaine_residuelle \
,valeur_brute_du_nom \
,MOINS_L_INFINI,INFINI \
) \
); \
/* On notera (le 20070710091808) que l'on utilise le type 'Float' pour 'valeur_brute_du_nom' */ \
/* afin de disposer de l'amplitude numerique maximale lors de la recuperation de la "valeur" */ \
/* du nom... */ \
/* */ \
/* Le 20130221081327 l'edition de 'No' et de 'chaine_residuelle' a ete introduite... */ \
\
EGAL(la_valeur_brute_du_nom_deborde,VRAI); \
/* La conversion est alors refusee... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
&Aifdef TestType`genere_Int(ArgumentObligatoireParDefinitionDesTypes)&&& \
&Eifdef TestType`genere_Int(ArgumentObligatoireParDefinitionDesTypes)&&& \
\
&undef TestType`type(ArgumentObligatoireParDefinitionDesTypes)&&& \
\
Test(IFET(IFEQ_chaine(chaine_residuelle,C_VIDE),EST_FAUX(la_valeur_brute_du_nom_deborde))) \
/* Cas ou le nom 'No' du fichier argument est une bonne valeur numerique, c'est-a-dire */ \
/* ou rien ne traine derriere... */ \
Bblock \
BLOC(sequence_initialisation); \
/* Initialisation du fichier sans lecture... */ \
EGAL(le_nom_du_fichier_a_ete_converti,VRAI); \
/* Et ainsi, on sait qu'il n'y a pas de fichier a lire... */ \
Eblock \
ATes \
/* Cas ou le nom 'No' du fichier argument n'est pas une bonne valeur numerique, */ \
/* c'est-a-dire ou il traine quelque chose derriere, ou bien ou il s'agit tout simplement */ \
/* d'un "bon nom" : 'le_nom_du_fichier_a_ete_converti' est 'FAUX'. */ \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
/* Ce cas s'est rencontre le 20130221082814 en voulant visualiser (via 'v') l'image */ \
/* 'v $xiirs/INFL.11' en ne mettant pas le directory '$xiirs' : le nom commence par 'INF' */ \
/* interprete comme etant 'inf' soit 'infinity'... */ \
Eblock \
ETes \
Eblock \
ATes \
/* Cas ou l'on n'a pas le droit de convertir le nom 'No' du fichier argument en une */ \
/* valeur numerique : 'le_nom_du_fichier_a_ete_converti' est 'FAUX'. */ \
Bblock \
Eblock \
ETes \
Eblock \
/* Procedure generale utilisee dans 'v $xiii/files$FON ILOAD_FICHIER_AVEC_CONVERSION' et */ \
/* dans 'v $xig/fonct$vv$FON GENERE__FonctionI_Fload'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* T A I L L E D ' U N F I C H I E R : */
/* */
/*************************************************************************************************************************************/
#define TAILLE_EN_NOMBRE_DE_CARACTERES_D_UN_FICHIER_INEXISTANT \
NEGA(UN)
#define TAILLE_EN_NOMBRE_DE_LIGNES_D_UN_FICHIER_INEXISTANT \
TAILLE_EN_NOMBRE_DE_CARACTERES_D_UN_FICHIER_INEXISTANT
/* Taille d'un fichier inexistant (introduit le 20061122182508). On notera que cette */
/* valeur est negative et donc ne peut correspondre a la taille d'un fichier en faisant */
/* bien attention d'utiliser 'Int' et non pas 'Positive'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D E S M E S S A G E S D ' E R R E U R : */
/* */
/*************************************************************************************************************************************/
#define BLOQUER_TOUS_LES_MESSAGES_D_ERREUR_DES_FICHIERS \
VRAI \
/* Indicateur a utiliser pour bloquer TOUS les messages d'erreur. */
#define NE_PAS_BLOQUER_TOUS_LES_MESSAGES_D_ERREUR_DES_FICHIERS \
NOTL(BLOQUER_TOUS_LES_MESSAGES_D_ERREUR_DES_FICHIERS) \
/* Indicateur a utiliser pour ne pas bloquer TOUS les messages d'erreur. */
#define VALIDER_LA_LONGUEUR_DES_NOMS_ABSOLUS_DE_FICHIERS \
VRAI \
/* Indicateur a utiliser pour bloquer la validation de la longueur des noms absolus */ \
/* des fichiers. */
#define NE_PAS_VALIDER_LA_LONGUEUR_DES_NOMS_ABSOLUS_DE_FICHIERS \
NOTL(VALIDER_LA_LONGUEUR_DES_NOMS_ABSOLUS_DE_FICHIERS) \
/* Indicateur a utiliser pour ne pas bloquer la validation de la longueur des noms absolus */ \
/* des fichiers. */
#define VALIDER_LA_LONGUEUR_DES_NOMS_RELATIFS_DE_FICHIERS \
VRAI \
/* Indicateur a utiliser pour bloquer la validation de la longueur des noms relatifs */ \
/* des fichiers. */
#define NE_PAS_VALIDER_LA_LONGUEUR_DES_NOMS_RELATIFS_DE_FICHIERS \
NOTL(VALIDER_LA_LONGUEUR_DES_NOMS_RELATIFS_DE_FICHIERS) \
/* Indicateur a utiliser pour ne pas bloquer la validation de la longueur des noms relatifs */ \
/* des fichiers. */
#define EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS \
VRAI \
/* Indicateur a utiliser pour editer certains messages d'erreur. */
#define NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS \
NOTL(EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS) \
/* Indicateur a utiliser pour ne pas editer certains messages d'erreur. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* Q U E L Q U E S M O D E S D ' U N F I C H I E R */
/* D A N S T E S T D E L ' E X I S T E N C E D ' U N F I C H I E R : */
/* */
/*************************************************************************************************************************************/
#define Ftest_fichier_____MODE_r__ \
0x00008100
#define Ftest_fichier_____MODE_r_x \
0x00008140
#define Ftest_fichier_____MODE_rw_ \
0x00008180
/* Quelques modes possibles introduits le 20070420153739... */
/* */
/* On notera que l'on retrouve ces modes dans 'v $Falias_catalf_1 0x00008100'... */
/* */
/* On notera le 20150119145603 l'introduction de 'v $xcg/List_mode$vv$Z' destine a faire */
/* un inventaire de tous les cas possibles... */
#define Ftest_fichier_____MODE_rwx \
0x000081c0
/* Et completes le 20070424085111... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C L E F D ' U N F I C H I E R D A N S T E S T D E L ' E X I S T E N C E D ' U N F I C H I E R : */
/* */
/*************************************************************************************************************************************/
#define Ftest_fichier_____CLEF_NON_DEFINIE \
UNDEF \
/* Valeur a donner a la clef d'un fichier lorsque celle-ci n'est pas calculee, par exemple, */ \
/* lorsque le fichier est trop gros. On notera que la valeur 'ZERO' serait peut-etre plus */ \
/* logique (cette constante a ete introduite le 20030808133508). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D E L ' A T T E N T E S U R L E S F I C H I E R S I N E X I S T A N T S : */
/* */
/*************************************************************************************************************************************/
#define ATTENDRE_UN_FICHIER_INEXISTANT_OU_NON_CONFORME \
VRAI \
/* Indicateur a utiliser pour attendre un fichier inexistant ou dont les caracteristiques */ \
/* ne sont pas conformes a ce que l'on attend... */
#define NE_PAS_ATTENDRE_UN_FICHIER_INEXISTANT_OU_NON_CONFORME \
NOTL(ATTENDRE_UN_FICHIER_INEXISTANT_OU_NON_CONFORME) \
/* Indicateur a utiliser pour ne pas attendre un fichier inexistant ou dont les */ \
/* caracteristiques ne sont pas conformes a ce que l'on attend. Il y a alors sortie */ \
/* en erreur... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M P T A G E D E S L I G N E S D ' U N F I C H I E R : */
/* */
/*************************************************************************************************************************************/
#define COMPTER_LES_LIGNES_DANS_Fsize_fichier \
VRAI \
/* Indicateur a utiliser pour compter les lignes dans 'Fsize_fichier(...)'. */
#define NE_PAS_COMPTER_LES_LIGNES_DANS_Fsize_fichier \
NOTL(COMPTER_LES_LIGNES_DANS_Fsize_fichier) \
/* Indicateur a utiliser pour ne pas compter les lignes dans 'Fsize_fichier(...)'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E S A U N F I C H I E R F O R M A T T E : */
/* */
/*************************************************************************************************************************************/
#define LE_NOM_DU_FICHIER_EST_CONVERTISSABLE_EN_UNE_VALEUR_NUMERIQUE \
VRAI \
/* Valeur de l'argument 'Co' des fonctions 'Fload_fichier_formatte_int(...)' et */ \
/* 'Fload_fichier_formatte_flot(...)' lorsque le nom du fichier peut etre considere */ \
/* comme une valeur numerique... */
#define LE_NOM_DU_FICHIER_N_EST_PAS_CONVERTISSABLE_EN_UNE_VALEUR_NUMERIQUE \
NOTL(LE_NOM_DU_FICHIER_EST_CONVERTISSABLE_EN_UNE_VALEUR_NUMERIQUE) \
/* Valeur de l'argument 'Co' des fonctions 'Fload_fichier_formatte_int(...)' et */ \
/* 'Fload_fichier_formatte_flot(...)' lorsque le nom du fichier ne peut pas etre considere */ \
/* comme une valeur numerique... */
#define PREMIER_ELEMENT_D_UN_FICHIER \
INDEX0 \
/* Index du premier element d'un fichier. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D E S L I S T E S : */
/* */
/* */
/* Definition : */
/* */
/* les fonctions suivantes vont */
/* permettre de gerer une liste, */
/* en la creant, la mettant a jour... */
/* */
/* */
/* Utilisation : */
/* */
/* On definira une liste d'abord */
/* par sa tete via un pointeur : */
/* */
/* DEFV(l_element,INIT(POINTERs(tete_de_liste),LISTE_UNDEF)); */
/* */
/* on definira eventuellement des */
/* elements de nom 'elementXX' */
/* via un pointeur par : */
/* */
/* DEFV(l_element,INIT(POINTERs(elementXX),ELEMENT_UNDEF)); */
/* */
/* puis, on la creera par : */
/* */
/* EGAL(tete_de_liste,Flist_creation()); */
/* */
/* et, 'elementXX' designant un element */
/* a generer dans la liste, on inserera */
/* en tete par : */
/* */
/* EGAL(elementXX,Flist_GTelement(tete_de_liste,"CHAINE DE CARACTERES")); */
/* */
/* ou en queue par : */
/* */
/* EGAL(elementXX,Flist_GQelement(tete_de_liste,"CHAINE DE CARACTERES")); */
/* */
/* Enfin, 'informations' designant un */
/* pointeur du type : */
/* */
/* DEFV(CHAR,INIT(POINTERc(informations),CHAINE_UNDEF)); */
/* */
/* Cette valeur 'CHAINE_UNDEF' est */
/* utilisable pour un test en retour */
/* de la validite des informations et */
/* des conditions d'execution d'une */
/* fonction (par exemple 'Flist_Selement', */
/* 'Flist_STelement' et 'Flist_SQelement'). */
/* */
/* On recuperera l'information contenue */
/* dans un l'element 'elementXX' que l'on */
/* detruit simultanement, par : */
/* */
/* EGAL(informations,Flist_Selement(elementXX)); */
/* */
/* sachant que le pointeur 'informations' */
/* est indefini en cas d'erreur... */
/* */
/*************************************************************************************************************************************/
#define ELEMENT_UNDEF \
ADRESSE(liste_indefinie) \
/* Permet de mettre a l'etat "UNDEF" un element d'une liste. */
#define LISTE_UNDEF \
ELEMENT_UNDEF \
/* Permet de mettre a l'etat "UNDEF" la tete d'une liste. */
#define ELEMENT_VIDE \
C_VIDE \
/* Un element vide contiendra la chaine vide... */
#define CLEF_VALIDATION_LISTE \
PARE(0x31415926) \
/* Clef de validation d'un element quelconque d'une liste. */
#define VALIDATION_LISTE(courant_element,action_si_valide,action_si_invalide) \
Bblock \
Test(IFNE(courant_element,ELEMENT_UNDEF)) \
Bblock \
Test(IFEQ(CLEF_VALIDATION_LISTE,UNDEF)) \
Bblock \
PRINT_ATTENTION("la validation d'un element de liste ne peut se faire correctement"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFEQ(ASI2(courant_element,header,clef_validation),CLEF_VALIDATION_LISTE)) \
Bblock \
BLOC(action_si_valide); \
Eblock \
ATes \
Bblock \
BLOC(action_si_invalide); \
PRINT_ERREUR("la clef de validation de l'element courant de liste est invalide"); \
CAL1(Prer2(" l'adresse de l'element est %08X et sa clef %08X\n" \
,courant_element \
,ASI2(courant_element,header,clef_validation) \
) \
); \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
BLOC(action_si_invalide); \
PRINT_ERREUR("l'adresse de l'element courant de liste est indefinie"); \
Eblock \
ETes \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S P I L E S : */
/* */
/* */
/* Definition : */
/* */
/* Une pile est une liste geree */
/* "LIFO", c'est-a-dire telle que */
/* le dernier element insere (on dira */
/* en queue) est le premier qui */
/* sortira. */
/* */
/* */
/* Utilisation : */
/* */
/* Le descripteur de pile devra */
/* avoir ete defini par : */
/* */
/* DEFV(l_element,INIT(POINTERs(descripteur_de_pile),PILE_UNDEF)); */
/* */
/* et les elements (qui sont en fait */
/* toujours de type "CHAR") a empiler */
/* et depiler par : */
/* */
/* DEFV(CHAR,INIT(POINTERc(informations),CHAINE_UNDEF)); */
/* */
/* puis, on la creera ou la detruira par : */
/* */
/* CREATION_PILE(descripteur_de_pile); */
/* DESTRUCTION_PILE(descripteur_de_pile); */
/* */
/* Enfin, on empilera et depilera les chaines */
/* de caracteres par les primitives : */
/* */
/* PUSH(descripteur_de_pile,informations); */
/* PULL(descripteur_de_pile,informations); */
/* */
/* ou : */
/* */
/* CALS(Fpush(descripteur_de_pile,informations)); */
/* EGAL(informations,Fpull(descripteur_de_pile)); */
/* */
/*************************************************************************************************************************************/
#define PILE_UNDEF \
ADRESSE(pile_indefinie) \
/* Permet de mettre a l'etat "UNDEF" le descripteur d'une pile. */
#define CREATION_PILE(descripteur_de_pile) \
Bblock \
EGAL(descripteur_de_pile,Flist_creation()); \
Eblock
#define VALIDATION_PILE(descripteur_de_pile,action_si_pile_valide,action_si_pile_invalide) \
Bblock \
Test(IFNE(descripteur_de_pile,PILE_UNDEF)) \
Bblock \
BLOC(action_si_pile_valide); \
Eblock \
ATes \
Bblock \
BLOC(action_si_pile_invalide); \
Eblock \
ETes \
Eblock \
/* Primitive de validation d'une pile et d'execution de l'une des */ \
/* deux alternatives. */
#define PUSH(descripteur_de_pile,informations) \
Bblock \
VALIDATION_PILE(descripteur_de_pile \
,BLOC(Flist_GQelement(descripteur_de_pile,informations); \
) \
,BLOC(PRINT_ERREUR("lors d'un 'PUSH' l'adresse du descripteur_de_pile est invalide"); \
CAL1(Prer1(" Son adresse est %08X\n",descripteur_de_pile)); \
) \
); \
Eblock
#define PULL(descripteur_de_pile,informations) \
/* ATTENTION : 'Flist_SQelement()' alloue de la memoire pour 'informations' ; cet espace */ \
/* doit imperativement etre rendu quelque part !!! */ \
Bblock \
VALIDATION_PILE(descripteur_de_pile \
,BLOC(EGAL(informations,Flist_SQelement(descripteur_de_pile)); \
Test(IFEQ_chaine(informations,ELEMENT_VIDE)) \
Bblock \
PRINT_ERREUR("la pile est vide"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
,BLOC(PRINT_ERREUR("lors d'un 'PULL' l'adresse du descripteur_de_pile est invalide"); \
CAL1(Prer1(" Son adresse est %08X\n",descripteur_de_pile)); \
EGAL(informations,CHAINE_UNDEF); \
/* Et on invalide l'information... */ \
) \
); \
Eblock
#define DESTRUCTION_PILE(descripteur_de_pile) \
Bblock \
Test(IL_Y_A_ERREUR(Flist_Delement(descripteur_de_pile))) \
Bblock \
PRINT_ERREUR("'DESTRUCTION_PILE' : 'Flist_Delement' s'est mal passe (pile non vide ou inexistante)"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N V E R S I O N D E S C H A I N E S N U M E R I Q U E S : */
/* */
/*************************************************************************************************************************************/
#define chain_numero(numero,nombre_de_chiffres) \
_chain_numero(numero,POSI(nombre_de_chiffres)) \
/* Conversion d'une nombre entier en une chaine numerique. Cette fonction intermediaire */ \
/* a ete ajoute en particulier pour permettre une generation "propre" des fichiers */ \
/* "bootstrappables" (en particulier le '$c' issu de 'v $xbg/fonction$K'). Ceci fut */ \
/* introduit le 1995072500 a la suite d'un rechargement du SYSTEME sur '$LACT28'... */
#define ChaineNumero(numero,nombre_de_chiffres) \
chain_numero(numero,MIN2(nombre_de_chiffres,ChaineNumero_____nombre_maximal_de_chiffres)) \
/* Introduit le 20080602111607 afin de parametrer facilement le nombre de chiffres generes */ \
/* par la fonction '_chain_numero(...)' sans avoir a proceder a des modifications complexes */ \
/* des '$K' (voir par exemple 'v $xrk/lyapunov.01$K ChaineNumero'), en notant au passage */ \
/* que les deux procedures 'ChaineNumero(...)' et 'chain_numero(...)' ont des noms de meme */ \
/* longueur ce qui laisse inchangees les tabulations... */
#define chain_numero_exact(numero) \
chain_numero(numero,NOMBRE_DE_CHIFFRES_DECIMAUX(numero)) \
/* Conversion d'une nombre entier en une chaine numerique comportant EXACTement le nombre */ \
/* de chiffres decimaux utiles (introduite le 20120214103507). */
#define chain_numero_avec_separateur(numero,nombre_de_chiffres) \
chain_Aconcaten2(cSEPARATEUR_DES_COMPOSANTES_D_UN_NOM \
,EGAs(chain_numero(numero,nombre_de_chiffres)) \
) \
/* Conversion d'une nombre entier en une chaine numerique precede d'un separateur */ \
/* (introduite le 20151021182143). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F O R M A T D E C O N V E R S I O N D E S C H A I N E S N U M E R I Q U E S : */
/* */
/*************************************************************************************************************************************/
#define INTRODUCTION_FORMAT \
C_POUR_CENT \
/* Introduit le 20180320140359... */
#define TAILLE_MOT_ALPHA_NUMERIQUE \
bMUL(bDIV(NBITOC,NBITHX),NOCMO) \
/* Nombre d'octets occupes par un mot converti en alpha-numerique */ \
/* de type hexa-decimal. */
#define NOMBRE_CHIFFRES_MOT_ALPHA_NUMERIQUE \
NOMBRE_DE_CHIFFRES_DECIMAUX(TAILLE_MOT_ALPHA_NUMERIQUE) \
/* Nombre de chiffres necessaires pour exprimer la longueur de la chaine resultant de la */ \
/* conversion d'un mot... */ \
/* */ \
/* La procedure 'NOMBRE_DE_CHIFFRES_DECIMAUX(...)' fut introduite le 20051210181752... */
#define LONGUEUR_CHAINE_DOUBLE_MOT \
bADD(DOUB(TAILLE_MOT_ALPHA_NUMERIQUE),SIZC(C_VIDE)) \
/* Nombre d'octets necessaires pour une chaine representant un double-mot. */
#define TYPE_FORMAT_INTE \
C_I
#define TYPE_FORMAT_JNTE \
COND(IL_FAUT(FconversionJ__FconversionX__FconversionY_____confondre_les_types__J_X_Y__avec__le_type_I) \
,ccCHAR(TYPE_FORMAT_INTE) \
,ccCHAR(C_J) \
)
#define TYPE_FORMAT_XNTE \
COND(IL_FAUT(FconversionJ__FconversionX__FconversionY_____confondre_les_types__J_X_Y__avec__le_type_I) \
,ccCHAR(TYPE_FORMAT_INTE) \
,ccCHAR(C_X) \
)
#define TYPE_FORMAT_YNTE \
COND(IL_FAUT(FconversionJ__FconversionX__FconversionY_____confondre_les_types__J_X_Y__avec__le_type_I) \
,ccCHAR(TYPE_FORMAT_INTE) \
,ccCHAR(C_Y) \
)
/* Les formats 'TYPE_FORMAT_JNTE' et 'TYPE_FORMAT_XNTE' furent introduits le 20070421181919. */
/* Le format 'TYPE_FORMAT_YNTE' fut lui introduit le 20070421183016. Je note au passage */
/* que pour revenir a la situation anterieure, il suffirait de definir : */
/* */
/* #define TYPE_FORMAT_JNTE \ */
/* TYPE_FORMAT_INTE */
/* #define TYPE_FORMAT_XNTE \ */
/* TYPE_FORMAT_INTE */
/* #define TYPE_FORMAT_YNTE \ */
/* TYPE_FORMAT_INTE */
/* */
/* et c'est tout. Cette remarque a entraine l'introduction d'un nouvel indicateur controlant */
/* cela ('FconversionJ__FconversionX__FconversionY_____confondre_les_types__J_X_Y__...'). */
#if (PRECISION_DU_Int==SIMPLE_PRECISION)
# define __FORMAT_INTE \
"d"
# define __FORMAT_HEXA_DECIMAL \
GvarDefaut("FORMAT_x_X","x")
/* Introduits le 20100321185224... */
/* */
/* ATTENTION : le 20241106141709, j'ai essaye de permettre le remplacement de "x" par */
/* "X" via une variable de controle : */
/* */
/* COND(EST_VRAI(utiliser_x_plutot_que_X),"x",C_HEXA_DECIMAL) */
/* */
/* Mais cela ne marche pas car, AVANT l'execution de l'intruction "associee" : */
/* */
/* GET_ARGUMENT_L("x_plutot_que_X=""xX=",utiliser_x_plutot_que_X); */
/* */
/* l'allocation memoire ('v $xil/defi_c1$vv$DEF allocation_memoire_et_generation_des_for.') */
/* s'execute or c'est elle qui genere les formats hexa-decimaux avec "x" qui ne sont donc */
/* ensuite plus modifiable... */
/* */
/* Le 20241106170654 fut introduite la variable d'environnement '$FORMAT_x_X' pour permettre */
/* malgre tout de remplacer "x" par "X"... */
# define C_HEXA_DECIMAL \
"X" \
/* Pour generer les formats de conversion hexa-decimaux. */
#Aif (PRECISION_DU_Int==SIMPLE_PRECISION)
#Eif (PRECISION_DU_Int==SIMPLE_PRECISION)
#if (PRECISION_DU_Int==DOUBLE_PRECISION)
# define __FORMAT_INTE \
"ld"
# define __FORMAT_HEXA_DECIMAL \
GvarDefaut("FORMAT_x_X","lx")
/* Introduits le 20100321185224... */
/* */
/* ATTENTION : le 20241106141709, j'ai essaye de permettre le remplacement de "x" par */
/* "X" via une variable de controle : */
/* */
/* COND(EST_VRAI(utiliser_x_plutot_que_X),"x",C_HEXA_DECIMAL) */
/* */
/* Mais cela ne marche pas car, AVANT l'execution de l'intruction "associee" : */
/* */
/* GET_ARGUMENT_L("x_plutot_que_X=""xX=",utiliser_x_plutot_que_X); */
/* */
/* l'allocation memoire ('v $xil/defi_c1$vv$DEF allocation_memoire_et_generation_des_for.') */
/* s'execute or c'est elle qui genere les formats hexa-decimaux avec "x" qui ne sont donc */
/* ensuite plus modifiable... */
/* */
/* Le 20241106170654 fut introduite la variable d'environnement '$FORMAT_x_X' pour permettre */
/* malgre tout de remplacer "x" par "X"... */
# define C_HEXA_DECIMAL \
"lX" \
/* Pour generer les formats de conversion hexa-decimaux (introduit le 20110418122921). */
#Aif (PRECISION_DU_Int==DOUBLE_PRECISION)
#Eif (PRECISION_DU_Int==DOUBLE_PRECISION)
#define _FORMAT_INTE_EDITION \
COND(IFEQ_chaine(ccCHAR(signe_de_FORMAT_INTE_EDITION),ccCHAR(C_VIDE)) \
,FORMAT_INTE \
,chain_Aconcaten3(INTRODUCTION_FORMAT,ccCHAR(signe_de_FORMAT_INTE_EDITION),__FORMAT_INTE) \
)
#define _FORMAT_INTE_EDITION__NON_SIGNE \
FORMAT_INTE
#define cFORMAT_INTE \
chain_Aconcaten2(INTRODUCTION_FORMAT,__FORMAT_INTE)
#define cFORMAT_INTE_EDITION \
format_INTE_EDITION()
#define cFORMAT_INTE_EDITION__NON_SIGNE \
format_INTE_EDITION__NON_SIGNE()
/* Format de conversion "Int", en entree et en sortie. */
#define SOUS_TITRE_D_UNE_VALEUR_HEXA_DECIMALE \
"0x" \
/* "Sous-titre" a utiliser pour detecter les valeurs hexadecimales (cette definition a ete */ \
/* deplacee de 'v $xig/fonct$vv$FON' a 'v $xig/fonct$vv$DEF' le 20021204174322). */ \
/* */ \
/* Nota : on ne peut utiliser ici (note le 20241107113653) : */ \
/* */ \
/* GvarDefaut("FORMAT_0x","0x") */ \
/* */ \
/* car, en effet, si la variable '$FORMAT_0x' prend une autre valeur, cela a des */ \
/* consequences eventuellement sur l'entree des constantes decimales qui peuvent alors */ \
/* etre interpretees comme etant hexa-decimales... */
#define POUR_CENT_0_D_UNE_VALEUR_HEXA_DECIMALE \
"%0" \
/* Le 20241106172005, la variable d'environnement '$FORMAT_pc0' a ete introduite... */ \
/* */ \
/* Je note le 20241108094532 que la variable '$FORMAT_pc0' n'a aucun interet et est meme */ \
/* dangereuse (avec "%", elle introduit des espaces entre "0x" et la valeur). Donc : */ \
/* */ \
/* GvarDefaut("FORMAT_pc0","%0") */ \
/* */ \
/* est supprime a cette date... */
#define cFORMAT_HEXA_DECIMAL \
chain_Aconcaten2(INTRODUCTION_FORMAT,__FORMAT_HEXA_DECIMAL)
#define cFORMAT_HEXA_DECIMAL_SANS_0_EDITION \
chain_Aconcaten2(SOUS_TITRE_D_UNE_VALEUR_HEXA_DECIMALE \
,cFORMAT_HEXA_DECIMAL \
)
#define cFORMAT_HEXA_DECIMAL_EDITION_1 \
chain_numero(NCHXMO,NOMBRE_DE_CHIFFRES_DECIMAUX(NCHXMO))
#define cFORMAT_HEXA_DECIMAL_EDITION \
chain_Aconcaten4(SOUS_TITRE_D_UNE_VALEUR_HEXA_DECIMALE \
,POUR_CENT_0_D_UNE_VALEUR_HEXA_DECIMALE \
,cFORMAT_HEXA_DECIMAL_EDITION_1 \
,__FORMAT_HEXA_DECIMAL \
)
#define cFORMAT_CHAR_HEXA_DECIMAL_EDITION_1 \
chain_numero(NCHXOC,NOMBRE_DE_CHIFFRES_DECIMAUX(NCHXOC))
#define cFORMAT_CHAR_HEXA_DECIMAL_EDITION \
chain_Aconcaten4(SOUS_TITRE_D_UNE_VALEUR_HEXA_DECIMALE \
,POUR_CENT_0_D_UNE_VALEUR_HEXA_DECIMALE \
,cFORMAT_CHAR_HEXA_DECIMAL_EDITION_1 \
,__FORMAT_HEXA_DECIMAL \
)
/* Format de conversion "Int" mais utilisant la notation hexadecimale "0x...", en entree */
/* et en sortie. La sortie sur 'NCHXMO' chiffres fut introduite le 20051210180444... */
/* */
/* La procedure 'NOMBRE_DE_CHIFFRES_DECIMAUX(...)' fut introduite le 20051210181752... */
/* */
/* La definition 'FORMAT_HEXA_DECIMAL_CARACTERE_EDITION' a ete introduite le 20120329135755. */
/* */
/* Le 20190905135010, 'nombre_de_chiffres_des_editions_hexa_decimales' a remplace 'NCHXMO' */
/* provisoirement, mais cela ne marche pas ('v $xig/fonct$vv$FON 20190905134645'...). */
/* */
/* Le 20190906114010 fut introduit 'cFORMAT_HEXA_DECIMAL_SANS_0_EDITION'... */
#define TYPE_FORMAT_FLOT \
C_F
#if (PRECISION_DU_Float==SIMPLE_PRECISION)
# define _FORMAT_FLOT_EDITION \
COND(IFEQ_chaine(ccCHAR(signe_de_FORMAT_FLOT_EDITION),ccCHAR(C_VIDE)) \
,chain_Aconcaten3(INTRODUCTION_FORMAT,".^^",ccCHAR(mode_fg_de_FORMAT_FLOT_EDITION)) \
,chain_Aconcaten4(INTRODUCTION_FORMAT \
,ccCHAR(signe_de_FORMAT_FLOT_EDITION) \
,".^^" \
,ccCHAR(mode_fg_de_FORMAT_FLOT_EDITION) \
) \
)
# define _FORMAT_FLOT_EDITION__NON_SIGNE \
chain_Aconcaten3(INTRODUCTION_FORMAT,".^^",ccCHAR(mode_fg_de_FORMAT_FLOT_EDITION))
# define FORMAT_FLOT_PRECISION \
C_VIDE
# define cFORMAT_FLOT \
chain_Aconcaten3(INTRODUCTION_FORMAT,FORMAT_FLOT_PRECISION,ccCHAR(mode_fg_de_FORMAT_FLOT_EDITION))
/* Format de conversion "flottant" (simple precision), en entree et en sortie. */
/* */
/* A cause de 'v $xig/edite$vv$FON FORMAT_FLOT_EDITION__NON_SIGNE', le 20190929104420 */
/* fut introduit explicitement 'FORMAT_FLOT_EDITION__NON_SIGNE'... On notera simultanement */
/* qu'il ne faut surtout pas introduire ".^^" dans la definition de 'cFORMAT_FLOT' et ce */
/* a cause de l'usage qui est en fait dans 'v $xig/fonct$vv$FON 20040301095143'... */
/* */
/* Pour 'v $xig/allocation$vv$FON FORMAT_FLOT_PRECISION', 'FORMAT_FLOT_PRECISION' a ete */
/* introduit le 20210925142522... */
#Aif (PRECISION_DU_Float==SIMPLE_PRECISION)
#Eif (PRECISION_DU_Float==SIMPLE_PRECISION)
#if (PRECISION_DU_Float==DOUBLE_PRECISION)
# define _FORMAT_FLOT_EDITION \
COND(IFEQ_chaine(ccCHAR(signe_de_FORMAT_FLOT_EDITION),ccCHAR(C_VIDE)) \
,chain_Aconcaten3(INTRODUCTION_FORMAT,".^^l",ccCHAR(mode_fg_de_FORMAT_FLOT_EDITION)) \
,chain_Aconcaten4(INTRODUCTION_FORMAT \
,ccCHAR(signe_de_FORMAT_FLOT_EDITION) \
,".^^l" \
,ccCHAR(mode_fg_de_FORMAT_FLOT_EDITION) \
) \
)
# define _FORMAT_FLOT_EDITION__NON_SIGNE \
chain_Aconcaten3(INTRODUCTION_FORMAT,".^^l",ccCHAR(mode_fg_de_FORMAT_FLOT_EDITION))
# define FORMAT_FLOT_PRECISION \
C_l
# define cFORMAT_FLOT \
chain_Aconcaten3(INTRODUCTION_FORMAT,FORMAT_FLOT_PRECISION,ccCHAR(mode_fg_de_FORMAT_FLOT_EDITION))
/* Format de conversion "flottant" (double precision), en entree et en sortie. */
/* */
/* A cause de 'v $xig/edite$vv$FON FORMAT_FLOT_EDITION__NON_SIGNE', le 20190929104420 */
/* fut introduit explicitement 'FORMAT_FLOT_EDITION__NON_SIGNE'... On notera simultanement */
/* qu'il ne faut surtout pas introduire ".^^" dans la definition de 'cFORMAT_FLOT' et ce */
/* a cause de l'usage qui est en fait dans 'v $xig/fonct$vv$FON 20040301095143'... */
/* */
/* Pour 'v $xig/allocation$vv$FON FORMAT_FLOT_PRECISION', 'FORMAT_FLOT_PRECISION' a ete */
/* introduit le 20210925142522... */
#Aif (PRECISION_DU_Float==DOUBLE_PRECISION)
#Eif (PRECISION_DU_Float==DOUBLE_PRECISION)
#define cFORMAT_FLOT_EDITION \
format_FLOT_EDITION() \
/* Format de conversion "flottant" en sortie. */
#define cFORMAT_FLOT_EDITION__NON_SIGNE \
format_FLOT_EDITION__NON_SIGNE() \
/* Format de conversion "flottant" en sortie non signe (introduit le 20190929105235). */ \
/* Voir 'v $xig/edite$vv$FON 20190929095039' qui justifie son introduction... */
#define TYPE_FORMAT_CHAI \
C_C
#define TYPE_FORMAT_GENERAL_CHAI \
C_s
/* Introduit le 20210925124252 pour 'v $xig/allocation$vv$FON TYPE_FORMAT_GENERAL_CHAI'... */
#define TYPE_FORMAT_LOGI \
C_L
#define TYPE_FORMAT_NOGI \
C_N
#define FORMAT_CHAI_1 \
INTRODUCTION_FORMAT
#define cFORMAT_CHAI_2 \
chain_Aconcaten11("[][" \
,Gvar("K_BLANC") \
,",.;:+=><{}()*?!/\\|" \
,C_VERITABLE_ANTI_QUOTE \
,"#@" \
,"^$%&" \
,"_0-9A-Za-z" \
,"\n\t" \
,C_VERITABLE_APOSTROPHE \
,C_VERITABLE_QUOTE \
,"-]" \
)
#define cFORMAT_CHAI \
chain_Aconcaten2(FORMAT_CHAI_1 \
,FORMAT_CHAI_2 \
)
/* Format de recuperation de chaines de caracteres ; on notera que l'on n'utilise */
/* pas "%s", car alors le caractere 'ESPACE' ne serait pas reconnu comme faisant */
/* partie des chaines de caracteres, meme entre quotes. ATTENTION, il y avait autrefois : */
/* */
/* "%[ ,.;:+-=<>()/#$%&_0-9A-Za-z]" */
/* */
/* mais alors "+-=" s'interpretait comme le segment [+=] ; il est imperatif que "-" soit en */
/* tete de la liste pour perdre ce sens de definition de segment. Il y a donc eu ensuite : */
/* */
/* "%[- ,.;:+=<>()/#$%&_0-9A-Za-z]" */
/* */
/* mais malheureusement, par exemple, dans 'v $xci/genere$K' cela posait des problemes, car */
/* en effet, ce programme recoit comme argument 'C=...' une commande type a generer pour le */
/* 'C-Shell' ; or celle-ci peut contenir un "pipe". Enfin, la chaine "<>" correspondant a */
/* '$PASSE_A', elle ne doit pas apparaitre dans cet ordre (d'ou "><"...). */
/* */
/* En ce qui concerne le caractere "\", il faudra le doubler dans la chaine Argument, si on */
/* veut le voir apparaitre dans la chaine Resultat... */
/* */
/* Le 1995031300, j'ai du rajouter les quotes simples et doubles, et ce afin de generer */
/* avec '$xci/genere$X' des appels a '$xci/disk_video_P$Z' qui contiennent donc la chaine */
/* de formatage des images : */
/* */
/* "$formatI" */
/* */
/* explicitement. On notera que l'on ecrit : */
/* */
/* "%[- ,.;:+=><()* /\\|#$%&_0-9A-Za-z]""K_QS""K_QD" */
/* . */
/* /|\ */
/* | ATTENTION a l'espace entre "*" et "/" */
/* et non pas : ============ destine a eviter dans ce commentaire une */
/* | confusion avec une fin de commentaire... */
/* \|/ */
/* ` */
/* "%[- ,.;:+=><()* /\\|#$%&_0-9A-Za-z]\'\"" */
/* */
/* ou : */
/* */
/* "%[- \'\",.;:+=><()* /\\|#$%&_0-9A-Za-z]" */
/* */
/* . */
/* /|\ */
/* | */
/* */
/* a cause du caractere ";" qui suit les quotes simples et doubles, et qui etant donnee la */
/* programmation de '$xcp/decoupage$K' pourrait provoquer un decoupage des occurences des */
/* chaines 'FORMAT_CHAI' derriere ce caractere ";". On notera enfin que, malheureusement, */
/* on fait ainsi de l'allocation memoire jamais releasee... */
/* */
/* Le 1995041900, j'ai introduit le caractere '!' a cause de la commande '$xci/genere$K' */
/* qui peut generer des redirections qui l'utilisent. Au passage, je l'ai place entre '*' */
/* et '/' pour regler le probleme des faux commentaires. On notera un point important ; a */
/* cause du role particulier du caractere '!' au niveau interactif, lors de son utilisation */
/* avec '$xci/genere$K', il devra etre "backslashe" : */
/* */
/* $xci/genere$X ... commande='... >>\! ...' */
/* */
/* sinon, il sera interprete par le 'C-Shell'... */
/* */
/* Le 1995100600, j'ai introduit le caractere '?' a cause de la commande '$xci/genere$K' */
/* qui peut avoir a l'utiliser... */
/* */
/* Le 1995111600, j'ai introduit le caractere '@' a cause de la necessite de pouvoir des */
/* calculs arithmetiques sur les variables du 'C-Shell' (qui sont introduits par "@"). */
/* */
/* Le 1996012200, j'ai introduit les caracteres '[' et ']' ce qui m'a contraint a placer */
/* '-' en dernier (alors qu'il etait autrefois le premier de la liste, afin que ']' puisse */
/* etre mis en premier. Il y avait donc avant : */
/* */
/* chain_Aconcaten5("%[" */
/* ,"- ,.;:+=><()*?!/\\|`#@$%&_0-9A-Za-z" */
/* ,Gvar("K_QS") */
/* ,Gvar("K_QD") */
/* ,"]" */
/* ) */
/* */
/* on ne sait jamais... */
/* */
/* Le 19961017091611, j'ai introduit les caracteres '{}' car la commande '$xci/genere$K' */
/* qui peut avoir a l'utiliser ('v $xiirv/$Fnota AW'). */
/* */
/* Le 19961128095347, j'ai introduit le caractere "\n" ("new-line") afin de pouvoir */
/* l'utiliser comme argument du programme '$xcp/substitue.01$K'. On notera le 20040630125510 */
/* que cela presente alors un gros inconvenient : celui de ne pas pouvoir entrer en tant */
/* que chaine a rechercher ou a substituer (dans '$xcp/substitue.01$X') 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... */
/* */
/* Le 19961220090446, j'ai introduit le caractere "^" afin de pouvoir l'utiliser comme */
/* argument du programme '$xcp/substitue.01$K'. */
/* */
/* Le 19970313155741, la variable '$K_BLANC' a ete introduite a la place de " " afin de */
/* garantir la presence de " " dans 'FORMAT_CHAI'... */
/* */
/* Le 20010725092518, j'ai introduit "\t" qui depuis l'introduction de la fonction */
/* 'v $xig/fonct$vv$FON chain_Acopie_avec_conversions_possibles_majuscules_minuscules' */
/* dans l'appel des fonctions 'v $xig/fonct$vv$DEF FCon.argument_courant' */
/* (introduit le 20010621143912) est devenu indispensable. */
/* */
/* Le 20020112101614, le "@" a ete mis a part a cause d'une modification introduite le */
/* 20020111100021 dans 'v $xcc/cpp$Z 20020111100021', "@" servant de marqueur '$MaRqUeUr'. */
/* */
/* Le 20051117175706, pour 'v $xig/fonct$vv$FON 20051117174126' a ete introduit le */
/* decoupage {FORMAT_CHAI_1,FORMAT_CHAI_2}. */
/* */
/* Le 20061225141132 a ete introduit 'C_VERITABLE_ANTI_QUOTE' car, en effet, le "`" etait */
/* avant cette date mal interprete a cause de 'v $xcc/cpp$Z S_UNDERSCORE'... */
/* */
/* Le 20241120130837 je note que '~' manque et je l'ai alors introduit dans la chaine : */
/* */
/* "^$%&~" */
/* */
/* mais en fait cela ne sert a rien. Le 20241120151612 je supprime donc '~' car, on ne sait */
/* jamais... */
#define cFORMAT_CHAI_EDITION \
chain_Aconcaten3(FORMAT_CHAI_EDITION_____caractere_d_encadrement \
,"%s" \
,FORMAT_CHAI_EDITION_____caractere_d_encadrement \
)
/* Format d'edition de chaines de caracteres ; en effet, contrairement aux valeurs */
/* numeriques (entieres, flottantes,...) pour lesquelles le meme format sert aussi bien */
/* a la recherche qu'a l'edition, pour les chaines de caracteres, le format 'FORMAT_CHAI' */
/* ne peut etre utilise pour la sortie... */
/* */
/* Le 20070227185323, fut introduit 'FORMAT_CHAI_EDITION_____caractere_d_encadrement'... */
#define FORMAT_LOGI_EDITION \
"%s"
#define FORMAT_NOGI_EDITION \
FORMAT_LOGI_EDITION
/* Format d'edition des variables logiques (introduit le 20000203120732 en ce qui concerne */
/* 'FORMAT_NOGI_EDITION' et le 20030213162851 pour 'FORMAT_NOGI_EDITION'). */
#define TYPE_FORMAT_CHAR \
C_K
#define FORMAT_CHAR \
"%c"
#define cFORMAT_CHAR_EDITION \
chain_Aconcaten3(FORMAT_CHAR_EDITION_____caractere_d_encadrement \
,"%c" \
,FORMAT_CHAR_EDITION_____caractere_d_encadrement \
)
#define cFORMAT_CHAR_EDITION_BACKSLASHEE \
chain_Aconcaten3(FORMAT_CHAR_EDITION_____caractere_d_encadrement \
,"\\%c" \
,FORMAT_CHAR_EDITION_____caractere_d_encadrement \
)
/* Format de recuperation d'un caractere, en entree et en sortie. */
/* */
/* Le 20070227185323, fut introduit 'FORMAT_CHAR_EDITION_____caractere_d_encadrement'... */
/* */
/* Le 20070228115321, fut introduit 'FORMAT_CHAR_EDITION_BACKSLASHE' pour permettre une */
/* edition correcte du caractere 'K_APOSTROPHE'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M I S E A U P L U R I E L D ' U N N O M : */
/* */
/*************************************************************************************************************************************/
#define PLURIEL_S(nom_au_singulier,nombre_de) \
COND(IFGT(ABSO(nombre_de),UN) \
,EGAs(chain_Aconcaten2(ccCHAR(nom_au_singulier),ccCHAR("s"))) \
,ccCHAR(nom_au_singulier) \
)
#define PLURIEL_EXCEPTION(nom_au_singulier,nom_au_pluriel,nombre_de) \
COND(IFGT(ABSO(nombre_de),UN) \
,nom_au_pluriel \
,nom_au_singulier \
)
/* Mise au pluriel d'un nom au singulier sous la forme la plus courante (ajouter un "s") */
/* et sous la forme d'exception ("un cheval", "des chevaux"). Ceci a ete introduit le */
/* 20030709091919. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* Z O N E S D E M U L T I P L E X A G E D ' I N F O R M A T I O N S */
/* D E F O R M A T V A R I E ( E N T I E R E T F L O T T A N T ) : */
/* */
/*************************************************************************************************************************************/
Dunion_05(NUM_MULTIPLEX
,Dstruct01(NOM_VIDE
,DEFV(Logical,valeur)
/* Stockage d'une valeur logique. */
,logique
)
,Dstruct01(NOM_VIDE
,DEFV(Int,valeur)
/* Stockage d'une valeur entiere. */
,entier
)
,Dstruct01(NOM_VIDE
,DEFV(Float,valeur)
/* Stockage d'une valeur flottante simple-precision. */
,simple_precision
)
,Dstruct01(NOM_VIDE
,DEFV(Double,valeur)
/* Stockage d'une valeur flottante double-precision. */
,double_precision
)
,Dstruct03(NOM_VIDE
,DEFV(Positive,premiere_partie)
,DEFV(Positive,deuxieme_partie)
/* Zone virtuelle de transfert sous forme de deux mots non signes. */
,DEFV(CHAR,DTb1(chaine_alpha_numerique,LONGUEUR_CHAINE_DOUBLE_MOT))
/* Zone destinee a recevoir la version codees en alpha-numerique des */
/* deux zones precedentes ; le 'DOUB' est la a cause des flottants en */
/* double-precision. */
,binaire_equivalent
)
,NOM_VIDE
);
Typedef(num_multiplex,UNIO(NUM_MULTIPLEX))
TypedefS(A___num_multiplex,num_multiplex)
TypedefS(E___num_multiplex,num_multiplex)
/* Definition d'une zone de multiplexage "Int"/"Float"/"Double". */
#define FORMAT_DOUBLE \
Bblock \
Test(IFEQ(format_double,CHAINE_UNDEF)) \
/* La premiere fois, on initialise le format de conversion... */ \
Bblock \
DEFV(CHAR,INIT(POINTERc(format_double_numero) \
,chain_numero(TAILLE_MOT_ALPHA_NUMERIQUE \
,bADD(NOMBRE_CHIFFRES_MOT_ALPHA_NUMERIQUE \
,SIZC(C_VIDE) \
) \
) \
) \
); \
\
EGAp(format_double \
,chain_Aconcaten8(C_POUR_CENT \
,C_0 \
,format_double_numero \
,C_HEXA_DECIMAL \
,C_POUR_CENT \
,C_0 \
,format_double_numero \
,C_HEXA_DECIMAL \
) \
); \
\
CALZ_FreCC(format_double_numero); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Definition du format necessaire pour convertir deux mots non signes */ \
/* en hexa-decimal par la fonction 'SPrint'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* Q U E L Q U E S A R G U M E N T S S T A N D A R D S P O U R L E S C O M M A N D E S : */
/* */
/*************************************************************************************************************************************/
#define __NOM_UNDEF_VIDE \
C_VIDE \
/* Destine a definir un nom vide... */
#define __ARGUMENT_PIPE \
C_EGAL \
/* Destine a preciser qu'un certain fichier sera accede via un "pipe". */
#define __ARGUMENT_PAR_DEFAUT \
C_POINT \
/* Destine a forcer une valeur par defaut pour un argument. */
#if ( (defined(SYSTEME_DECALPHA340_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA350_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA464_OSF1_CC)) \
|| (defined(SYSTEME_VAX8600_ULTRIX_CC)) \
|| (defined(SYSTEME_VAX9000_ULTRIX_CC)) \
)
# define NOM_UNDEF_VIDE \
nom_UNDEF_vide \
/* Destine a definir un nom vide... */
# define ARGUMENT_PIPE \
argument_pipe \
/* Destine a preciser qu'un certain fichier sera accede via un "pipe". */
# define ARGUMENT_PAR_DEFAUT \
argument_par_defaut \
/* Destine a forcer une valeur par defaut pour un argument. */
#Aif ( (defined(SYSTEME_DECALPHA340_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA350_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA464_OSF1_CC)) \
|| (defined(SYSTEME_VAX8600_ULTRIX_CC)) \
|| (defined(SYSTEME_VAX9000_ULTRIX_CC)) \
)
# define NOM_UNDEF_VIDE \
__NOM_UNDEF_VIDE \
/* Destine a definir un nom vide... */
# define ARGUMENT_PIPE \
__ARGUMENT_PIPE \
/* Destine a preciser qu'un certain fichier sera accede via un "pipe". */
# define ARGUMENT_PAR_DEFAUT \
__ARGUMENT_PAR_DEFAUT \
/* Destine a forcer une valeur par defaut pour un argument. */
#Eif ( (defined(SYSTEME_DECALPHA340_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA350_OSF1_CC)) \
|| (defined(SYSTEME_DECALPHA464_OSF1_CC)) \
|| (defined(SYSTEME_VAX8600_ULTRIX_CC)) \
|| (defined(SYSTEME_VAX9000_ULTRIX_CC)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P O U R P E R M E T T R E L ' E N T R E E D E S P A R A M E T R E S */
/* D ' U N E C O M M A N D E V I A D E S ' setenv ' : */
/* */
/*************************************************************************************************************************************/
#define PERMETTRE_L_ENTREE_DES_PARAMETRES_VIA_DES_setenv \
VRAI
#define NE_PAS_PERMETTRE_L_ENTREE_DES_PARAMETRES_VIA_DES_setenv \
NOTL(PERMETTRE_L_ENTREE_DES_PARAMETRES_VIA_DES_setenv)
/* Valeurs possibles de 'entrer_des_parametres_via_des_setenv' (le 19980420092917). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P O U R D O N N E R D E S A I D E S D I V E R S E S : */
/* */
/*************************************************************************************************************************************/
#define TESTER_LA_DOUBLE_DEFINITION_DES_PARAMETRES \
VRAI
#define NE_PAS_TESTER_LA_DOUBLE_DEFINITION_DES_PARAMETRES \
NOTL(TESTER_LA_DOUBLE_DEFINITION_DES_PARAMETRES)
/* Valeurs possibles de 'tester_la_double_definition_des_parametres'... */
#define EDITER_LES_COMMANDES_AVANT_EXECUTION \
VRAI
#define NE_PAS_EDITER_LES_COMMANDES_AVANT_EXECUTION \
NOTL(EDITER_LES_COMMANDES_AVANT_EXECUTION)
/* Valeurs possibles de 'editer_les_commandes_avant_execution'... */
#define PERMETTRE_L_ACCES_AU_SOURCE_DU_PROGRAMME \
VRAI
#define NE_PAS_PERMETTRE_L_ACCES_AU_SOURCE_DU_PROGRAMME \
NOTL(PERMETTRE_L_ACCES_AU_SOURCE_DU_PROGRAMME)
/* Valeurs possibles de 'permettre_l_acces_au_source_du_programme'... */
#define PERMETTRE_L_ACCES_A_LA_LISTE_DES_FONCTIONS_REFERENCEES_PAR_LE_PROGRAMME \
VRAI
#define NE_PAS_PERMETTRE_L_ACCES_A_LA_LISTE_DES_FONCTIONS_REFERENCEES_PAR_LE_PROGRAMME \
NOTL(PERMETTRE_L_ACCES_A_LA_LISTE_DES_FONCTIONS_REFERENCEES_PAR_LE_PROGRAMME)
/* Valeurs de 'permettre_l_acces_a_la_liste_des_fonctions_referencees_par_le_programme' */
/* possibles (introduites le 20120626104316). */
#define EDITER_LE_NOM_SYNTHETIQUE_DE_LA_COMMANDE_COURANTE \
VRAI
#define NE_PAS_EDITER_LE_NOM_SYNTHETIQUE_DE_LA_COMMANDE_COURANTE \
NOTL(EDITER_LE_NOM_SYNTHETIQUE_DE_LA_COMMANDE_COURANTE)
/* Valeurs possibles de 'editer_le_NOM_SYNTHETIQUE_de_la_commande_courante'... */
#define EDITER_LE_NOM_ABSOLU_DU_SOURCE_c_DE_LA_COMMANDE_COURANTE \
VRAI
#define NE_PAS_EDITER_LE_NOM_ABSOLU_DU_SOURCE_c_DE_LA_COMMANDE_COURANTE \
NOTL(EDITER_LE_NOM_ABSOLU_DU_SOURCE_c_DE_LA_COMMANDE_COURANTE)
/* Valeurs possibles de 'editer_le_NOM_ABSOLU_DU_SOURCE_c_de_la_commande_courante' */
/* (introduit le 20240104111119)... */
#define EDITER_LES_DIFFERENTES_VARIABLES_D_ENVIRONNEMENT_UTILES \
VRAI
#define NE_PAS_EDITER_EDITER_LES_DIFFERENTES_VARIABLES_D_ENVIRONNEMENT_UTILES \
NOTL(EDITER_LES_DIFFERENTES_VARIABLES_D_ENVIRONNEMENT_UTILES)
/* Valeurs possibles de 'editer_les_differentes_variables_d_environnement_utiles' (introduit */
/* le 20091114113908). */
#define EDITER_LES_DIFFERENTES_VARIABLES_D_ENVIRONNEMENT_UTILES_DANS_LES_LIBRAIRIES_DYNAMIQUES \
VRAI
#define NE_PAS_EDITER_EDITER_LES_DIFFERENTES_VARIABLES_D_ENVIRONNEMENT_UTILES_DANS_LES_LIBRAIRIES_DYNAMIQUES \
NOTL(EDITER_LES_DIFFERENTES_VARIABLES_D_ENVIRONNEMENT_UTILES_DANS_LES_LIBRAIRIES_DYNAMIQUES)
/* Pour 'editer_les_differentes_variables_d_environnement_utiles_dans_les_librairies' et */
/* lui donner sa valeur (introduit le 20091114113908). */
#define EDITER_LES_DIFFERENTES_VERSIONS_DU_PROGRAMME \
VRAI
#define NE_PAS_EDITER_LES_DIFFERENTES_VERSIONS_DU_PROGRAMME \
NOTL(EDITER_LES_DIFFERENTES_VERSIONS_DU_PROGRAMME)
/* Valeurs possibles de 'editer_les_differentes_versions_du_programme'... */
#define EDITER_LES_DIFFERENTES_VERSIONS_DU_PROGRAMME_DANS_LES_LIBRAIRIES_DYNAMIQUES \
VRAI
#define NE_PAS_EDITER_LES_DIFFERENTES_VERSIONS_DU_PROGRAMME_DANS_LES_LIBRAIRIES_DYNAMIQUES \
NOTL(EDITER_LES_DIFFERENTES_VERSIONS_DU_PROGRAMME_DANS_LES_LIBRAIRIES_DYNAMIQUES)
/* Pour 'editer_les_differentes_versions_du_programme_dans_les_librairies' et */
/* lui donner sa valeur (introduit le 20091114113908). */
#define EDITER_LA_LISTE_DES_LIBRAIRIES_DYNAMIQUES_UTILISEES \
VRAI
#define NE_PAS_EDITER_LA_LISTE_DES_LIBRAIRIES_DYNAMIQUES_UTILISEES \
NOTL(EDITER_LA_LISTE_DES_LIBRAIRIES_DYNAMIQUES_UTILISEES)
/* Pour 'EDITER_LA_LISTE_DES_LIBRAIRIES_DYNAMIQUES_UTILISEES' et lui donner sa valeur */
/* (introduit le 20220824180116). */
#define EDITER_LES_DIFFERENTS_BUGS_RECONNUS \
VRAI
#define NE_PAS_EDITER_LES_DIFFERENTS_BUGS_RECONNUS \
NOTL(EDITER_LES_DIFFERENTS_BUGS_RECONNUS)
/* Valeurs possibles de 'editer_les_differents_bugs_reconnus'... */
#define EDITER_LES_DIFFERENTS_INCLUDES_DU_PROGRAMME \
VRAI
#define NE_PAS_EDITER_LES_DIFFERENTS_INCLUDES_DU_PROGRAMME \
NOTL(EDITER_LES_DIFFERENTS_INCLUDES_DU_PROGRAMME)
/* Valeurs possibles de 'editer_les_differents_includes_du_programme'... */
#define LISTER_TOUS_LES_MESSAGES_POSSIBLES \
VRAI
#define NE_PAS_LISTER_TOUS_LES_MESSAGES_POSSIBLES \
NOTL(LISTER_TOUS_LES_MESSAGES_POSSIBLES)
/* Valeurs possibles de 'lister_tous_les_messages_possibles' (introduit le 20000524180053). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* V E R S I O N S D E S P R O C E D U R E S S T A N D A R D S D E C O N V E R S I O N : */
/* */
/*************************************************************************************************************************************/
#nodefine gPROCESS_PARAMETRE_ENTREE_PAR_setenv_VERSION_01 \
/* Dans cette version, les parametres ne peuvent pas etre entres via des 'setenv'... */
#define gPROCESS_PARAMETRE_ENTREE_PAR_setenv_VERSION_02 \
/* Dans cette version, les parametres peuvent etre entres via des 'setenv'... */
#nodefine gPROCESS_PARAMETRE_EDITION_VECTEUR_N_VERSION_01 \
/* Dans cette version, des vecteurs de longueur connue et de tout '__ParaTyp' peuvent */ \
/* etre edites. */
#define gPROCESS_PARAMETRE_EDITION_VECTEUR_N_VERSION_02 \
/* Dans cette version, seuls des vecteurs de longueur connue et de type 'TYPE_FORMAT_FLOT' */ \
/* peuvent etre edites... */
#nodefine gPROCESS_PARAMETRE_EDITION_VECTEUR_VERSION_01 \
/* Dans cette version, des vecteurs de longueur inconnue et de tout '__ParaTyp' peuvent */ \
/* etre edites. */
#define gPROCESS_PARAMETRE_EDITION_VECTEUR_VERSION_02 \
/* Dans cette version, seuls des vecteurs de longueur inconnue et de type 'TYPE_FORMAT_FLOT' */ \
/* peuvent etre edites... */
/* ATTENTION : 'INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_0?' doivent */
/* etre definis ici (et non pas dans 'v $xiii/Images$DEF') car, en effet, leur existence */
/* est testee ci-apres, alors que '$xiii/Images$DEF' est inclus apres '$xig/fonct$vv$DEF'... */
#nodefine INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_01 \
/* Cette facon d'initialiser le format des images utilise le mode 'Std'. */
#nodefine INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_02 \
/* Cette facon d'initialiser le format des images utilise le mode 'Pal' (introduit le */ \
/* 20020122102707). */
#nodefine INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_03 \
/* Cette facon d'initialiser le format des images utilise les variables d'environnement */ \
/* {{$Xmin,$Xmax},{$Ymin,$Ymax}} lorsqu'elles existent, ou le mode 'Pal' dans le cas */ \
/* contraire (introduit le 20020126150829). */
#define INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_04 \
/* Cette facon d'initialiser le format des images utilise les variables d'environnement */ \
/* {{$Xmin,$Xmax},{$Ymin,$Ymax},{$Zmin,$Zmax}} lorsqu'elles existent, ou le mode 'Pal' */ \
/* (en ce qui concerne {X,Y}) et le mode par defaut (pour 'Z') dans le cas contraire */ \
/* (introduit le 20020126150829). J'ai immediatement note (le 20020212160210) que cela */ \
/* introduisait une difference importante d'initialisation car, en effet, avant cette */ \
/* date, la valeur par defaut de 'Zmax' etait : */ \
/* */ \
/* Zmax=511 ('v $xiii/Images$STR k___Zmax') */ \
/* */ \
/* alors qu'apres cette date, elle devient : */ \
/* */ \
/* Zmax=127 ('v $Fimages setenv...Zmax') */ \
/* */ \
/* A priori, cela ne devrait pas avoir de consequences. Au passage, cela devrait etre */ \
/* plutot benefique en reduisant la taille des eventuels albums dans le programme courant... */ \
/* */ \
/* Le 20020304182857, j'ai retabli : */ \
/* */ \
/* Zmax=511 ('v $Fimages dimension_formatZ') */ \
/* */ \
/* et ce a cause du programme 'v $xci/accumule.02$K derniere_tranche_verticale' afin que */ \
/* 'DERNIERE_TRANCHE_VERTICALE' (qui vaut la valeur de la variable 'Zmax') et la variable */ \
/* 'Zmax' apres 'INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi' (qui vaut '$Zmax') */ \
/* aient la meme valeur afin que '_____lNORMALISE_OZ(...)' fonctionne correctement... */ \
/* */ \
/* Pour revenir en arriere, il suffirait soit de reactiver l'option de version */ \
/* 'INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_03' ci-dessus, */ \
/* soit de supprimer les {setenv,unset} de definition de {$Zmin,$Zmax} dans le fichier */ \
/* 'v $Fimages setenv...Zmax'. */
#nodefine INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_05 \
/* Identique a 'INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_03', mais */ \
/* avec validation des axes (introduit le 20020213100517). */ \
/* */ \
/* ATTENTION, j'ai decouvert le 20020912142305 qu'il ne fallait surtout pas utiliser la */ \
/* validation des axes a ce moment de l'entree des parametres ('valider_les_axes_OX_OY_OZ' */ \
/* n'ayant pas encore ete defini) et ce a cause d'utilisations tres particuliere du type */ \
/* de 'v $xcg/transparents$Z xci/minimum' ou les dimensions des axes sont a priori tout a */ \
/* fait quelconque... */
#nodefine INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_06 \
/* Identique a 'INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_04', mais */ \
/* avec validation des axes (introduit le 20020213100517). */ \
/* */ \
/* ATTENTION, j'ai decouvert le 20020912142305 qu'il ne fallait surtout pas utiliser la */ \
/* validation des axes a ce moment de l'entree des parametres ('valider_les_axes_OX_OY_OZ' */ \
/* n'ayant pas encore ete defini) et ce a cause d'utilisations tres particuliere du type */ \
/* de 'v $xcg/transparents$Z xci/minimum' ou les dimensions des axes sont a priori tout a */ \
/* fait quelconque. A cette date, je suis donc repasse a la version */ \
/* 'INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_04'... */
/* ATTENTION : 'INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_0?' doivent */
/* etre definis ici (et non pas dans 'v $xiii/Images$DEF') car, en effet, leur existence */
/* est testee ci-apres, alors que '$xiii/Images$DEF' est inclus apres '$xig/fonct$vv$DEF'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R O C E D U R E S S T A N D A R D S D E C O N V E R S I O N : */
/* */
/* */
/* Definition : */
/* */
/* les procedures suivantes permettent */
/* de definir "recursivement" la valeur */
/* d'un parametre ; cela signifie que */
/* si celui-ci est absent, il conserve */
/* sa valeur initiale (dite "par defaut"). */
/* On notera, qu'un meme parametre peut */
/* etre recupere plusieurs fois avec des */
/* titres differents (mais synonymes...). */
/* */
/* */
/* Utilisation : */
/* */
/* GET_PARAMETRE_K(liste_des_arguments,titre_attendu,parametre_K,valeur_K_par_defaut); */
/* GET_PARAMETRE_C(liste_des_arguments,titre_attendu,parametre_C,valeur_C_par_defaut); */
/* GET_PARAMETRE_L(liste_des_arguments,titre_attendu,parametre_L,valeur_L_par_defaut); */
/* GET_PARAMETRE_N(liste_des_arguments,titre_attendu,parametre_L,valeur_L_par_defaut); */
/* GET_PARAMETRE_I(liste_des_arguments,titre_attendu,parametre_I,valeur_I_par_defaut); */
/* GET_PARAMETRE_X(liste_des_arguments,titre_attendu,parametre_X,valeur_X_par_defaut); */
/* GET_PARAMETRE_F(liste_des_arguments,titre_attendu,parametre_F,valeur_F_par_defaut); */
/* GET_PARAMETRE_P(liste_des_arguments,titre_attendu,parametre_P,valeur_P_par_defaut); */
/* */
/* */
/* Hierarchie : */
/* */
/* g1PROCESS_PARAMETRE(...) */
/* gPROCESS_PARAMETRE(...) */
/* PROCESS_PARAMETRE(...) */
/* GET_PARAMETRE(...) */
/* GET_PARAMETRE_K(...) */
/* GIT_ARGUMENT_K(...) */
/* GET_ARGUMENT_K(...) */
/* GET_ARGUMENTS2_K(...) */
/* GET_ARGUMENTS3_K(...) */
/* GET_ARGUMENTS4_K(...) */
/* GET_PARAMETRE_C(...) */
/* GIT_ARGUMENT_C(...) */
/* GET_ARGUMENT_C(...) */
/* GET_ARGUMENTS2_C(...) */
/* GET_ARGUMENTS3_C(...) */
/* GET_ARGUMENTS4_C(...) */
/* GET_PARAMETRE_L(...) */
/* GET_PARAMETRE_N(...) */
/* GIT_ARGUMENT_N(...) */
/* GET_ARGUMENT_N(...) */
/* GET_ARGUMENTS2_N(...) */
/* GET_ARGUMENTS3_N(...) */
/* GET_ARGUMENTS4_N(...) */
/* GET_ARGUMENTS5_N(...) */
/* GET_ARGUMENTS6_N(...) */
/* GET_ARGUMENTS7_N(...) */
/* GET_ARGUMENTS8_N(...) */
/* GET_ARGUMENTS9_N(...) */
/* GET_ARGUMENTSa_N(...) */
/* GIT_ARGUMENT_L(...) */
/* GET_ARGUMENT_M(...) */
/* GET_ARGUMENT_L(...) */
/* GET_ARGUMENTS2_L(...) */
/* GET_ARGUMENTS3_L(...) */
/* GET_ARGUMENTS4_L(...) */
/* GET_ARGUMENTS5_L(...) */
/* GET_ARGUMENTS6_L(...) */
/* GET_ARGUMENTS7_L(...) */
/* GET_ARGUMENTS8_L(...) */
/* GET_ARGUMENTS9_L(...) */
/* GET_ARGUMENTSa_L(...) */
/* GET_PARAMETRE_I(...) */
/* GIT_ARGUMENT_I(...) */
/* GET_ARGUMENT_E(...) */
/* GET_ARGUMENT_I(...) */
/* GET_ARGUMENTS2_I(...) */
/* GET_ARGUMENTS2g_I(...) */
/* GET_ARGUMENTS3_I(...) */
/* GET_ARGUMENTS3g_I(...) */
/* GET_ARGUMENTS4_I(...) */
/* GET_ARGUMENT_J(...) */
/* GET_PARAMETRE_X(...) */
/* GET_ARGUMENT_X(...) */
/* GET_ARGUMENTS2_X(...) */
/* GET_ARGUMENTS3_X(...) */
/* GET_ARGUMENTS4_X(...) */
/* GET_ARGUMENT_Y(...) */
/* GET_PARAMETRE_F(...) */
/* GIT_ARGUMENT_F(...) */
/* GET_ARGUMENT_F(...) */
/* GET_ARGUMENTS2_F(...) */
/* GET_ARGUMENTS2g_F(...) */
/* GET_ARGUMENTS3_F(...) */
/* GET_ARGUMENTS3g_F(...) */
/* GET_ARGUMENTS4_F(...) */
/* GET_ARGUMENT_G(...) */
/* GET_PARAMETRE_P(...) */
/* GIT_ARGUMENT_P(...) */
/* GET_ARGUMENT_P(...) */
/* GET_ARGUMENTS2_P(...) */
/* GET_ARGUMENTS3_P(...) */
/* GET_ARGUMENTS4_P(...) */
/* PROKESS_PARAMETRE_K(...) */
/* PROKISS_ARGUMENT_K(...) */
/* PROKESS_ARGUMENT_K(...) */
/* PROCESS_PARAMETRE_K(...) */
/* PROCISS_ARGUMENT_K(...) */
/* PROCESS_ARGUMENT_K(...) */
/* PROCESS_ARGUMENTS2_K(...) */
/* PROKESS_PARAMETRE_C(...) */
/* PROKISS_ARGUMENT_C(...) */
/* PROKESS_ARGUMENT_C(...) */
/* PROCESS_PARAMETRE_C(...) */
/* PROCISS_ARGUMENT_C(...) */
/* PROCESS_ARGUMENT_C(...) */
/* PROCESS_ARGUMENT_FICHIER(...) */
/* PROCESS_ARGUMENTS2_C(...) */
/* PROKESS_PARAMETRE_L(...) */
/* PROKESS_PARAMETRE_N(...) */
/* PROKISS_ARGUMENT_N(...) */
/* PROKESS_ARGUMENT_N(...) */
/* PROCESS_PARAMETRE_N(...) */
/* PROCISS_ARGUMENT_N(...) */
/* PROCESS_ARGUMENT_N(...) */
/* PROCESS_ARGUMENTS2_N(...) */
/* PROKISS_ARGUMENT_L(...) */
/* PROKESS_ARGUMENT_L(...) */
/* PROCESS_PARAMETRE_L(...) */
/* PROCISS_ARGUMENT_L(...) */
/* PROCESS_ARGUMENT_L(...) */
/* PROCESS_ARGUMENTS2_L(...) */
/* PROKESS_PARAMETRE_I(...) */
/* PROKISS_ARGUMENT_I(...) */
/* PROKESS_ARGUMENT_I(...) */
/* PROCESS_PARAMETRE_I(...) */
/* PROCISS_ARGUMENT_I(...) */
/* PROCESS_ARGUMENT_I(...) */
/* PROCESS_ARGUMENTS2_I(...) */
/* PROKESS_PARAMETRE_J(...) */
/* PROCESS_PARAMETRE_J(...) */
/* PROCESS_ARGUMENT_J(...) */
/* PROKESS_PARAMETRE_X(...) */
/* PROKISS_ARGUMENT_X(...) */
/* PROKESS_ARGUMENT_X(...) */
/* PROCESS_PARAMETRE_X(...) */
/* PROCISS_ARGUMENT_X(...) */
/* PROCESS_ARGUMENT_X(...) */
/* PROCESS_ARGUMENTS2_X(...) */
/* PROKESS_PARAMETRE_Y(...) */
/* PROCESS_PARAMETRE_Y(...) */
/* PROCESS_ARGUMENT_Y(...) */
/* PROKESS_PARAMETRE_F(...) */
/* PROKISS_ARGUMENT_F(...) */
/* PROKESS_ARGUMENT_F(...) */
/* PROCESS_PARAMETRE_F(...) */
/* PROCISS_ARGUMENT_F(...) */
/* PROCESS_ARGUMENT_F(...) */
/* PROCESS_ARGUMENTS2_F(...) */
/* PROKESS_PARAMETRE_P(...) */
/* PROKISS_ARGUMENT_P(...) */
/* PROKESS_ARGUMENT_P(...) */
/* PROCESS_PARAMETRE_P(...) */
/* PROCISS_ARGUMENT_P(...) */
/* PROCESS_ARGUMENT_P(...) */
/* PROCESS_ARGUMENTS2_P(...) */
/* PROCESF_ARGUMENT_C(...) */
/* PROCESF_ARGUMENT_FICHIER(...) */
/* PROKESF_ARGUMENT_C(...) */
/* PROKESF_ARGUMENT_FICHIER(...) */
/* */
/* */
/* ATTENTION : */
/* */
/* Ajouter de nouvelles procedures ici (par */
/* exemple 'PROCESF_ARGUMENT_C(...)' peut exiger */
/* la modification de 'v $xcg/Voptions$Z' et de */
/* 'v $xcg/Voptions$D/get_argument$sed'. */
/* */
/* */
/* ATTENTION : */
/* */
/* Je note le 20190806104105 (bien tardivement) */
/* que les procedures 'GET_ARGUMENTS?_?(...)' ne */
/* donnent pas pleinement satisfaction lors de */
/* l'usage de : */
/* */
/* Parametres=VRAI */
/* */
/* si tous les parametres a positionner n'ont pas */
/* la meme valeur par defaut ; c'est alors le premier */
/* qui est edite. Cela s'est vu a cette date avec */
/* 'v $xiii/di_image$FON _____rapport_critique' et */
/* 'v $xci/jeu_vie.01$K' qui ne donnait que la valeur */
/* */
/* rc=+0.375 (=3/8) */
/* */
/* alors que la valeur +0.4444444444444444 (=4/9) */
/* n'apparaissait pas. C'est cela qui a conduit a */
/* l'introduction de 'v $xci/jeu_vie.01$K rapport_critique_variable='. */
/* en plus de 'v $xci/jeu_vie.01$K rapport_critique=' : */
/* */
/* GET_ARGUMENT_F("rapport_critique=""rc=",Ijeu_de_la_vie_generalise_____rapport_critique); */
/* GET_ARGUMENT_F("rapport_critique_variable=""rcv=",Ijeu_de_la_vie_generalise_variable_____rapport_critique); */
/* */
/* a la place de : */
/* */
/* GET_ARGUMENTS2_F("rapport_critique=""rc=" */
/* ,Ijeu_de_la_vie_generalise_____rapport_critique */
/* ,Ijeu_de_la_vie_generalise_variable_____rapport_critique */
/* ); */
/* */
/* qui ne donnait donc pas satisfaction... */
/* */
/* Cela a conduit le 20190806132343 a la mise en place de */
/* la validation 'GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(...)'. */
/* On notera a ce propos le traitement specifique (et unique...) de */
/* 'v $xig/fonct$vv$DEF .DepthCueingMinimal=dcm=.' destine a garantir */
/* simplement la compatibilite anterieure... */
/* */
/* */
/* ATTENTION : */
/* */
/* Les 'PROCESS_PARAMETRE_...(...)' qui suivent */
/* peuvent impliquer des contraintes dans l'ordre */
/* de presentation des parametres (voir par exemple */
/* le module 'v $xrq/nucleon.Lb.2$I$INUTILE'). */
/* */
/* PROKESS_PARAMETRE_K(liste_des_arguments,titre_attendu,parametre_K,valeur_K_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKESS_PARAMETRE_C(liste_des_arguments,titre_attendu,parametre_C,valeur_C_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKESS_PARAMETRE_L(liste_des_arguments,titre_attendu,parametre_L,valeur_L_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKESS_PARAMETRE_N(liste_des_arguments,titre_attendu,parametre_L,valeur_L_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKESS_PARAMETRE_I(liste_des_arguments,titre_attendu,parametre_I,valeur_I_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKESS_PARAMETRE_X(liste_des_arguments,titre_attendu,parametre_I,valeur_I_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKESS_PARAMETRE_F(liste_des_arguments,titre_attendu,parametre_F,valeur_F_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKESS_PARAMETRE_P(liste_des_arguments,titre_attendu,parametre_P,valeur_P_par_defaut,seq1,seqI,seqC,seqN); */
/* */
/* PROCESS_PARAMETRE_K(liste_des_arguments,titre_attendu,parametre_K,valeur_K_par_defaut,sequenceI,sequenceC); */
/* PROCESS_PARAMETRE_C(liste_des_arguments,titre_attendu,parametre_C,valeur_C_par_defaut,sequenceI,sequenceC); */
/* PROCESS_PARAMETRE_L(liste_des_arguments,titre_attendu,parametre_L,valeur_L_par_defaut,sequenceI,sequenceC); */
/* PROCESS_PARAMETRE_N(liste_des_arguments,titre_attendu,parametre_L,valeur_L_par_defaut,sequenceI,sequenceC); */
/* PROCESS_PARAMETRE_I(liste_des_arguments,titre_attendu,parametre_I,valeur_I_par_defaut,sequenceI,sequenceC); */
/* PROCESS_PARAMETRE_X(liste_des_arguments,titre_attendu,parametre_I,valeur_I_par_defaut,sequenceI,sequenceC); */
/* PROCESS_PARAMETRE_F(liste_des_arguments,titre_attendu,parametre_F,valeur_F_par_defaut,sequenceI,sequenceC); */
/* PROCESS_PARAMETRE_P(liste_des_arguments,titre_attendu,parametre_P,valeur_P_par_defaut,sequenceI,sequenceC); */
/* */
/* (ou 'seqI,seqC' designe 'sequence_inconditionnelle,sequence_conditionnelle') */
/* */
/* GET_PARAMETRES(nombre_d_arguments_y_compris_le_nom,La,BLOC(liste_recup_1),BLOC(action_intermediaire),BLOC(liste_recup_2)); */
/* */
/* */
/* GIT_ARGUMENT_K(titre_attendu,parametre_K,valeur_K_par_defaut); */
/* GIT_ARGUMENT_C(titre_attendu,parametre_C,valeur_C_par_defaut); */
/* GIT_ARGUMENT_L(titre_attendu,parametre_L,valeur_L_par_defaut); */
/* GIT_ARGUMENT_N(titre_attendu,parametre_L,valeur_L_par_defaut); */
/* GIT_ARGUMENT_I(titre_attendu,parametre_I,valeur_I_par_defaut); */
/* GIT_ARGUMENT_F(titre_attendu,parametre_F,valeur_F_par_defaut); */
/* GIT_ARGUMENT_P(titre_attendu,parametre_P,valeur_P_par_defaut); */
/* */
/* */
/* ATTENTION : */
/* */
/* Les 'PROCISS_ARGUMENT_...(...)' qui suivent */
/* peuvent impliquer des contraintes dans l'ordre */
/* de presentation des arguments (voir par exemple */
/* le module 'v $xrq/nucleon.Lb.2$I$INUTILE'). */
/* */
/* PROKISS_ARGUMENT_K(titre_attendu,parametre_K,valeur_K_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKISS_ARGUMENT_C(titre_attendu,parametre_C,valeur_C_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKISS_ARGUMENT_L(titre_attendu,parametre_L,valeur_L_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKISS_ARGUMENT_N(titre_attendu,parametre_L,valeur_L_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKISS_ARGUMENT_I(titre_attendu,parametre_I,valeur_I_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKISS_ARGUMENT_X(titre_attendu,parametre_I,valeur_I_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKISS_ARGUMENT_F(titre_attendu,parametre_F,valeur_F_par_defaut,seq1,seqI,seqC,seqN); */
/* PROKISS_ARGUMENT_P(titre_attendu,parametre_P,valeur_P_par_defaut,seq1,seqI,seqC,seqN); */
/* */
/* PROCISS_ARGUMENT_K(titre_attendu,parametre_K,valeur_K_par_defaut,sequenceI,sequenceC); */
/* PROCISS_ARGUMENT_C(titre_attendu,parametre_C,valeur_C_par_defaut,sequenceI,sequenceC); */
/* PROCISS_ARGUMENT_L(titre_attendu,parametre_L,valeur_L_par_defaut,sequenceI,sequenceC); */
/* PROCISS_ARGUMENT_N(titre_attendu,parametre_L,valeur_L_par_defaut,sequenceI,sequenceC); */
/* PROCISS_ARGUMENT_I(titre_attendu,parametre_I,valeur_I_par_defaut,sequenceI,sequenceC); */
/* PROCISS_ARGUMENT_X(titre_attendu,parametre_I,valeur_I_par_defaut,sequenceI,sequenceC); */
/* PROCISS_ARGUMENT_F(titre_attendu,parametre_F,valeur_F_par_defaut,sequenceI,sequenceC); */
/* PROCISS_ARGUMENT_P(titre_attendu,parametre_P,valeur_P_par_defaut,sequenceI,sequenceC); */
/* */
/* (ou 'seqI,seqC' designe 'sequence_inconditionnelle,sequence_conditionnelle') */
/* */
/* GET_ARGUMENT_K(titre_attendu,parametre_K); */
/* GET_ARGUMENT_C(titre_attendu,parametre_C); */
/* GET_ARGUMENT_L(titre_attendu,parametre_L); */
/* GET_ARGUMENT_N(titre_attendu,parametre_L); */
/* GET_ARGUMENT_I(titre_attendu,parametre_I); */
/* GET_ARGUMENT_X(titre_attendu,parametre_X); */
/* GET_ARGUMENT_J(titre_attendu,parametre_I); */
/* GET_ARGUMENT_Y(titre_attendu,parametre_I); */
/* GET_ARGUMENT_F(titre_attendu,parametre_F); */
/* GET_ARGUMENT_G(titre_attendu,parametre_G); */
/* GET_ARGUMENT_P(titre_attendu,parametre_P); */
/* */
/* */
/* ATTENTION : */
/* */
/* Les 'PROCESS_ARGUMENT_...(...)' qui suivent */
/* peuvent impliquer des contraintes dans l'ordre */
/* de presentation des arguments (voir par exemple */
/* le module 'v $xrq/nucleon.Lb.2$I$INUTILE'). */
/* */
/* PROKESS_ARGUMENT_K(titre_attendu,parametre_K,seq1,seqI,seqC,seqN); */
/* PROKESS_ARGUMENT_C(titre_attendu,parametre_C,seq1,seqI,seqC,seqN); */
/* PROKESF_ARGUMENT_C(titre_attendu,parametre_C,seq1,seqI,seqC,seqN); */
/* PROKESS_ARGUMENT_L(titre_attendu,parametre_L,seq1,seqI,seqC,seqN); */
/* PROKESS_ARGUMENT_N(titre_attendu,parametre_L,seq1,seqI,seqC,seqN); */
/* PROKESS_ARGUMENT_I(titre_attendu,parametre_I,seq1,seqI,seqC,seqN); */
/* PROKESS_ARGUMENT_X(titre_attendu,parametre_I,seq1,seqI,seqC,seqN); */
/* PROKESS_ARGUMENT_F(titre_attendu,parametre_F,seq1,seqI,seqC,seqN); */
/* PROKESS_ARGUMENT_P(titre_attendu,parametre_P,seq1,seqI,seqC,seqN); */
/* */
/* PROCESS_ARGUMENT_K(titre_attendu,parametre_K,sequenceI,sequenceC); */
/* PROCESS_ARGUMENT_C(titre_attendu,parametre_C,sequenceI,sequenceC); */
/* PROCESF_ARGUMENT_C(titre_attendu,parametre_C,sequenceI,sequenceC); */
/* PROCESS_ARGUMENT_L(titre_attendu,parametre_L,sequenceI,sequenceC); */
/* PROCESS_ARGUMENT_N(titre_attendu,parametre_L,sequenceI,sequenceC); */
/* PROCESS_ARGUMENT_I(titre_attendu,parametre_I,sequenceI,sequenceC); */
/* PROCESS_ARGUMENT_X(titre_attendu,parametre_I,sequenceI,sequenceC); */
/* PROCESS_ARGUMENT_F(titre_attendu,parametre_F,sequenceI,sequenceC); */
/* PROCESS_ARGUMENT_P(titre_attendu,parametre_P,sequenceI,sequenceC); */
/* */
/* */
/* ATTENTION : */
/* */
/* Les 'GET_ARGUMENTS?(...)' qui suivent exigent */
/* au minimum les includes suivants : */
/* */
/* #include "DEFINITIONS.I" */
/* #include INCLUDES_MINI */
/* */
/* a cause de la variable 'editer_la_valeur_des_parametres_d_une_commande, */
/* qui est definie dans 'v $xig/fonct$vv$FON' et qu'elles utilisent... */
/* */
/* */
/* GET_ARGUMENTS_(nombre_d_arguments_y_compris_le_nom,BLOC(liste_de_recuperation)); */
/* GET_ARGUMENTSi(nombre_d_arguments_y_compris_le_nom,BLOC(liste_de_recuperation)); */
/* GET_ARGUMENTSv(nombre_d_arguments_y_compris_le_nom,BLOC(liste_de_recuperation)); */
/* GET_ARGUMENTSg(nombre_d_arguments_y_compris_le_nom,BLOC(liste_de_recuperation)); */
/* */
/* */
/* Voici les imbrications des definitions */
/* de ces procedures : */
/* */
/* */
/* GET_ARGUMENTS_(...) */
/* | */
/* -------> GET_PARAMETRES(...) */
/* */
/* GET_ARGUMENTSf(...) */
/* | */
/* -------> GET_PARAMETRES(...) */
/* */
/* GET_ARGUMENTSi(...) */
/* | */
/* -------> GET_PARAMETRES(...) */
/* */
/* GET_ARGUMENTSv(...) */
/* | */
/* -------> GET_ARGUMENTSi(...) */
/* | */
/* -------> GET_PARAMETRES(...) */
/* */
/* GET_ARGUMENTSg(...) */
/* | */
/* -------> GET_ARGUMENTSv(...) */
/* | */
/* -------> GET_ARGUMENTSi(...) */
/* | */
/* -------> GET_PARAMETRES(...) */
/* */
/* */
/* Le principe des 'GET_ARGUMENTS?(...)' est */
/* d'imbriquer deux boucles. La plus exterieure */
/* consiste a prendre les uns apres les autres */
/* les parametres effectifs d'appel. La plus */
/* interieure consiste a comparer chacun d'eux */
/* a l'ensemble de tous les parametres possibles. */
/* Soit : */
/* */
/* */
/* foreach ParametreCourant (ListeParametresCourants) */
/* { */
/* foreach ParametrePossible (ListeParametresPossibles) */
/* { */
/* if (ParametreCourant == ParametrePossible) */
/* { */
/* TRAITER(ParametreCourant); */
/* } */
/* else */
/* { */
/* } */
/* endif */
/* */
/* if (ParametreCourant == DERNIER(ListeParametresCourants) */
/* { */
/* EDITER(ParametrePossible); */
/* } */
/* else */
/* { */
/* } */
/* endif */
/* } */
/* end */
/* } */
/* end */
/* */
/* */
/* On notera donc bien que c'est lors du traitement */
/* du dernier 'ParametreCourant' de la liste */
/* 'ListeParametresCourants' que sont edites */
/* (optionnellement) les 'ParametrePossible's... */
/* */
/* */
/* ATTENTION : */
/* */
/* Les 'GET_ARGUMENTS?(...)' qui precedent exigent */
/* au minimum les includes suivants : */
/* */
/* #include "DEFINITIONS.I" */
/* #include INCLUDES_MINI */
/* */
/* a cause de la variable 'editer_la_valeur_des_parametres_d_une_commande' */
/* qui est definie dans 'v $xig/fonct$vv$FON' et qu'elles utilisent ; de meme */
/* a cause de la variable 'bloquer_tous_les_messages_d_erreur_des_fichiers' */
/* qui vient d'etre definie dans 'v $xig/fonct$vv$FON' a laquelle on ajoutera */
/* 'attendre_un_fichier_inexistant_ou_non_conforme'. */
/* */
/* */
/* Pseudo-procedures : */
/* */
/* Il existe actuellement trois "pseudo-procedures" */
/* c'est-a-dire des procedures qui ne sont pas definies */
/* dans '$xil', mais uniquement utilisees par '$xcc/cpp$Z' */
/* de facon a ce qu'il puisse faire certaine choses sur */
/* le source '$c' genere. Il s'agit de : */
/* */
/* D_STATIK(...) ('v $xiii/Images$DEF') */
/* G_STATIK() ('v $xig/fonct$vv$DEF') */
/* G_LISTER_TOUS_LES_MESSAGES_POSSIBLES() ('v $xig/fonct$vv$DEF') */
/* */
/* ou l'on indique les fichiers ou elles sont referencees. */
/* Donc, seul le nom de ces "pseudo-procedures" compte... */
/* */
/* */
/* Note sur l'entree des PARAMETRES via des 'setenv' : */
/* */
/* Je rappelle le 20190110094426 qu'il est */
/* possibles de communiquer les parametres */
/* d'une commande via des 'setenv' et ce a */
/* condition d'activer cette fonctionnalite */
/* via le parametre "Environnement=VRAI". */
/* Ainsi, par exemple : */
/* */
/* $xcg/ADD2.01$X a=1200 b=34 */
/* */
/* donnera comme resultat '+1234', tout comme : */
/* */
/* setenv P__a 1200 */
/* setenv P__b 34 */
/* $xcg/ADD2.01$X Environnement=VRAI */
/* */
/* ou encore de facon plus "specifique" a cette */
/* commande : */
/* */
/* unsetenv P__ */
/* setenv P__xcg_ADD2_01__a 1200 */
/* setenv P__xcg_ADD2_01__b 34 */
/* $xcg/ADD2.01$X Environnement=VRAI */
/* */
/*************************************************************************************************************************************/
#define SEQUENCE_D_ECHAPPEMENT_VT100_DEBUT_1 \
K_ESC
#define SEQUENCE_D_ECHAPPEMENT_VT100_DEBUT_2 \
K_CG
/* Debut des sequences d'echappement 'VT100' (introduit le 20060610100931)... */
/* */
/* Le 20060612134834, je note que tout cela peut se "mettre en serie" a condition de */
/* separer les differentes sequences par un ";". Ainsi, par exemple : */
/* */
/* E[33;7m */
/* */
/* (ou "E" represente 'K_ESC') provoque des caracteres jaunes ("33") inverses ("7"), ce qui */
/* donne donc des caracteres noirs sur fond jaune... */
/* */
/* Je note le 20080212153757 que cela peut aussi s'utiliser directement sous '$CSH'. Ainsi, */
/* par exemple : */
/* */
/* echo "A""$CoDe_1b""[33;7m""B""$CoDe_1b""[0m""C" */
/* */
/* \______________/ \___________/ */
/* */
/* jaune inverse normal */
/* */
/* a condition de disposer de '$CoDe_1b' (defini via 'CodexB', 'v $xE/.alias.1$vv$Y CodexB') */
/* donnera un "A" normal, suivi d'un "B" jaune inverse et suivi enfin d'un "C" normal... */
#define SEQUENCE_D_ECHAPPEMENT_VT100_INITIALISATION_GENERALE \
C_0
#define SEQUENCE_D_ECHAPPEMENT_VT100_LUMINANCE_FORTE \
C_1
#define SEQUENCE_D_ECHAPPEMENT_VT100_LUMINANCE_FAIBLE \
C_2
#define SEQUENCE_D_ECHAPPEMENT_VT100_SOULIGNAGE \
C_4
#define SEQUENCE_D_ECHAPPEMENT_VT100_CLIGNOTEMENT \
C_5
#define SEQUENCE_D_ECHAPPEMENT_VT100_INVERSION \
C_7
#define SEQUENCE_D_ECHAPPEMENT_VT100_INVISIBLE \
C_8
/* Sequences d'echappement 'VT100' generales (introduit le 20060610100931)... */
#define SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES \
C_3
#define SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES__________NOIR \
SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES ## C_0
#define SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES__________ROUGE \
SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES ## C_1
#define SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES__________VERT \
SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES ## C_2
#define SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES__________JAUNE \
SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES ## C_3
#define SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES__________BLEU \
SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES ## C_4
#define SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES__________MAGENTA \
SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES ## C_5
#define SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES__________CYAN \
SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES ## C_6
#define SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES__________BLANC \
SEQUENCE_D_ECHAPPEMENT_VT100_CARACTERES ## C_7
/* Sequences d'echappement 'VT100' pour les caracteres (introduit le 20060610100931)... */
/* */
/* Voici la liste des possibilites : */
/* */
/* 30 : caracteres NOIR */
/* 31 : caracteres ROUGE */
/* 32 : caracteres VERT */
/* 33 : caracteres JAUNE */
/* 34 : caracteres BLEU */
/* 35 : caracteres MAGENTA */
/* 36 : caracteres CYAN */
/* 37 : caracteres BLANC */
/* */
#define SEQUENCE_D_ECHAPPEMENT_VT100_FOND \
C_4
#define SEQUENCE_D_ECHAPPEMENT_VT100_FOND__________NOIR \
SEQUENCE_D_ECHAPPEMENT_VT100_FOND ## C_0
#define SEQUENCE_D_ECHAPPEMENT_VT100_FOND__________ROUGE \
SEQUENCE_D_ECHAPPEMENT_VT100_FOND ## C_1
#define SEQUENCE_D_ECHAPPEMENT_VT100_FOND__________VERT \
SEQUENCE_D_ECHAPPEMENT_VT100_FOND ## C_2
#define SEQUENCE_D_ECHAPPEMENT_VT100_FOND__________JAUNE \
SEQUENCE_D_ECHAPPEMENT_VT100_FOND ## C_3
#define SEQUENCE_D_ECHAPPEMENT_VT100_FOND__________BLEU \
SEQUENCE_D_ECHAPPEMENT_VT100_FOND ## C_4
#define SEQUENCE_D_ECHAPPEMENT_VT100_FOND__________MAGENTA \
SEQUENCE_D_ECHAPPEMENT_VT100_FOND ## C_5
#define SEQUENCE_D_ECHAPPEMENT_VT100_FOND__________CYAN \
SEQUENCE_D_ECHAPPEMENT_VT100_FOND ## C_6
#define SEQUENCE_D_ECHAPPEMENT_VT100_FOND__________BLANC \
SEQUENCE_D_ECHAPPEMENT_VT100_FOND ## C_7
/* Sequences d'echappement 'VT100' pour les fonds (introduit le 20060610100931)... */
/* */
/* Voici la liste des possibilites : */
/* */
/* 40 : fond NOIR */
/* 41 : fond ROUGE */
/* 42 : fond VERT */
/* 43 : fond JAUNE */
/* 44 : fond BLEU */
/* 45 : fond MAGENTA */
/* 46 : fond CYAN */
/* 47 : fond BLANC */
/* */
#define SEQUENCE_D_ECHAPPEMENT_VT100_FIN \
K_m \
/* Fin des sequences d'echappement 'VT100' (introduit le 20060610100931)... */
#define PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
UN \
/* Valeur a donner initialement a 'NUMERO_UNIQUE_de_l_argument_possible_courant'... */
#define NOMBRE_MAXIMAL_DE_NUMEROS_UNIQUES_DES_ARGUMENTS_POSSIBLES \
GRO12(CENT) \
/* Afin de generer les listes utiles... */ \
/* */ \
/* A cause de 'v $xrv/o_homographique.81$K GET_ARGUMENTS_', le 20220605095701 la valeur */ \
/* 'MILLE' a ete remplacee par 'GRO12(CENT)'... */
#define NOMBRE_DE_CHIFFRES_POUR_EDITER_LES_NUMEROS_UNIQUES_DES_ARGUMENTS_POSSIBLES \
NOMBRE_DE_CHIFFRES_DECIMAUX(NOMBRE_MAXIMAL_DE_NUMEROS_UNIQUES_DES_ARGUMENTS_POSSIBLES) \
/* Afin d'editer les listes utiles... */ \
/* */ \
/* La procedure 'NOMBRE_DE_CHIFFRES_DECIMAUX(...)' fut introduite le 20051210181752... */
#define FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Parametre_1 \
chain_numero(niveau_des_gPROCESS_PARAMETRE,UN)
#define FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Parametre \
chain_Aconcaten3("Parametre.",FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Parametre_1,".")
/* Le 20060208101231, la definition anterieure "Parametre..." a evoluee de facon a integrer */
/* le dispositif distinguant les appels aux procedures de type 'GET_ARGUMENT_?(...)' et */
/* 'PROCESS_ARGUMENT_?(...)' qui ont lieu directement et ceux qui ont lieu via une autre */
/* procedure... */
#define FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Parametre_Synonyme \
"............"
#define FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Parametre_ligne_suite_Vecteur \
" "
#define FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Numero_Parametre \
" %0*d/%0*d : "
#define FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Numero_Parametre_ligne_suite_Vecteur \
" %*s "
#define FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_1 \
chain_Aconcaten2(COND(IFET(IL_FAUT(sauter_une_ligne_pour_chaque_nouveau_Parametre) \
,IL_NE_FAUT_PAS(alterner_les_parametres_pour_plus_de_lisibilite) \
) \
,C_LF \
,C_VIDE \
) \
,ccCHAR(FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Parametre) \
)
#define FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_2 \
chain_Aconcaten2(COND(IFET(IL_FAUT(sauter_une_ligne_pour_chaque_nouveau_Parametre) \
,IL_NE_FAUT_PAS(alterner_les_parametres_pour_plus_de_lisibilite) \
) \
,C_LF \
,C_VIDE \
) \
,ccCHAR(FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Parametre_Synonyme) \
)
#define FORMAT_D_EDITION_DES_IDENTITES_UNIQUES \
chain_Aconcaten2(COND(EST_FAUX(l_argument_possible_courant_est_un_synonyme_d_argument_anterieur) \
,FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_1 \
,COND(IFEQ(IDENTITE_de_l_argument_possible_courant \
,IDENTITE_de_l_argument_possible_precedent_precedent \
) \
,ccCHAR(FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Parametre_Synonyme) \
,FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_2 \
) \
) \
,FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Numero_Parametre \
) \
/* Format d'edition des identites UNIQUEs des parametres possibles (le 20000202084613). */ \
/* La discrimination entre "non synonyme" et "synonyme" a ete introduite le 20030214093316 */ \
/* et on notera que l'on laisse '%0*d' pour les "synonyme"s afin d'une part de garantir la */ \
/* tabulation et d'autre part de permettre aux synonymes d'un parametre de ne pas etre */ \
/* necessairement contigus ('NUMERO_UNIQUE_de_l_argument_possible_courant', leur numero */ \
/* commun, permettant alors de les "regrouper"...). */ \
/* */ \
/* Le test relatif a 'IDENTITE_de_l_argument_possible_precedent_precedent' a ete introduit */ \
/* le 20060316170930 pour prendre en compte les cas des parametres synonymes "disperses" */ \
/* comme c'est par exemple le cas de 'v $xci/interpole.03$K imageA1:A='. On notera avec */ \
/* attention le commentaire relatif a 'IDENTITE_de_l_argument_possible_precedent_precedent' */ \
/* dans 'v $xig/fonct$vv$DEF gPROCESS_PARAMETRE_IDENTITE'... */ \
/* */ \
/* Le test relatif a 'alterner_les_parametres_pour_plus_de_lisibilite' a ete introduit le */ \
/* 20060622135953 car, en effet, il y a incompatibilite entre les sauts de ligne et la */ \
/* notion d'alternance : les sauts de ligne introduisent alors une 'C_LF' entre la sequence */ \
/* d'alternance 'ALTERNANCE_DES_PARAMETRES_DEBUT' et la premiere ligne des parametres qui */ \
/* suit, ce qui a pour effet de marquer cette ligne jusqu'a l'extremite droite de la fenetre */ \
/* et non pas jusqu'a son 'K_LF'... */ \
/* */ \
/* Le 20081113173427, j'ai tente d'editer le nombre maximal de parametres. Cela impliquait */ \
/* les mofifications suivantes : */ \
/* */ \
/* #define FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Numero_Parametre \ */ \
/* " %0*d/%0*d : " */ \
/* #define FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Numero_Parametre_ligne_suite_... \ */ \
/* " %*s " */ \
/* */ \
/* mais j'y ai renonce le 20081115105359 ('v $xig/fonct$vv$FON 20081113173432')... */ \
/* */ \
/* Finalement, cela a pu etre retabli grace a 'v $xcc/cpp$Z 20081116112629'... */
#define FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_SUITE_POUR_LES_VECTEURS \
chain_Aconcaten2(FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Parametre_ligne_suite_Vecteur \
,FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Numero_Parametre_ligne_suite_Vecteur \
) \
/* Identique a 'FORMAT_D_EDITION_DES_IDENTITES_UNIQUES' mais destine a editer les lignes */ \
/* "suite" pour l'edition des vecteurs (introduit le 20030627131610). */ \
/* */ \
/* Pour 'FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_Numero_Parametre_ligne_suite_Vecteur', je */ \
/* note le 20051117171925 que le format : */ \
/* */ \
/* " %*s " */ \
/* */ \
/* est utilise avec comme arguments : */ \
/* */ \
/* NOMBRE_DE_CHIFFRES_POUR_EDITER_LES_NUMEROS_UNIQUES_DES_ARGUMENTS_POSSIBLES */ \
/* C_VIDE */ \
/* */ \
/* ce qui demande d'imprimer la chaine vide ('C_VIDE') sur une longueur egale exactement */ \
/* a 'NOMBRE_DE_CHIFFRES_POUR_EDITER_LES_NUMEROS_UNIQUES_DES_ARGUMENTS_POSSIBLES', ce qui */ \
/* revient donc a tabuler d'une quantite egale a ce nombre (puisque la chaine est vide...). */
#define FORMAT_D_EDITION_DES_TITRES \
"%-*s" \
/* Format d'edition des titres afin de tabuler les titres, et leurs valeurs affectees... */ \
/* Ce parametre a ete deplace de '$xig/fonct$vv$FON' a '$xig/fonct$vv$DEF' le 20000125095156 */ \
/* apres l'introduction des variables de type '__Para...'. */
#define EN_TETE_DE_LA_LISTE_DES_PREMIERES_VALEURS_D_UN_VECTEUR \
"------------------------------valeur " \
/* Pour introduire la liste des premieres valeurs d'un parametre de type "vecteur". */
#define FORMAT_D_EDITION_DES_TYPES_DES_VALEURS_SCALAIRES \
"%s :: " \
/* Format d'edition des valeurs des parametres (valeurs scalaires). */ \
/* */ \
/* Avant le 20060316163851, ce symbole etait 'FORMAT_D_EDITION_DES_VALEURS_SCALAIRES' et */ \
/* avant le 20060316160021, c'etait 'FORMAT_D_EDITION_DES_VALEURS' qui etait utilise aussi */ \
/* bien pour les valeurs scalaires que pour les valeurs vectorielles... */
#define FORMAT_D_EDITION_DES_TYPES_DES_VALEURS_VECTORIELLES \
"%s :: " \
/* Format d'edition des valeurs des parametres (valeurs vectorielles) introduit le */ \
/* 20060316162827, suite a l'introduction de 'INDICATEUR_DE_TYPE_____A_R'... */ \
/* */ \
/* Avant le 20060316163851, ce symbole etait 'FORMAT_D_EDITION_DES_VALEURS_VECTORIELLES'... */
#define INDICATEUR_DE_TYPE_____A_R \
"Indicateur_____A_R" \
/* Chaine introduite le 20060310101333... */
#define FORMAT_D_EDITION_DU_NOM_DES_VALEURS \
"%s" \
/* Format d'edition de l'eventuel nom des parametres introduit le 20011230075829. */
#define NOM_DES_VALEURS_PREMIER_SYNONYME(parametre) \
"[[[[parametre]]]]"
#define NOM_DES_VALEURS_SYNONYMES_SUIVANTS \
"="
/* Pour l'edition du noms des valeurs... */
#define TABULATION_DES_VALEURS_AFFECTEES_AUX_TITRES \
ADD2(SOIXANTE_DIX,CINQ) \
/* Tabulation (arbitraire) des valeurs affectees aux titres. Cela facilite la lecture ; pour */ \
/* faciliter l'association "titre-valeur", il suffira d'inverser la video de la ligne en */ \
/* cliquant trois fois avec la souris. Le 20000124161142, ayant constate des titres tres */ \
/* longs ('v $xrk/rdn_walk.52$K LISTE_TRANSLATION_VITESSE_OX2_REFRACTION_REFLEXION'), la */ \
/* valeur 'QUARANTE' a ete remplacee par 'SOIXANTE'. */ \
/* */ \
/* Ce parametre a ete deplace de '$xig/fonct$vv$FON' a '$xig/fonct$vv$DEF' le 20000125095156 */ \
/* apres l'introduction des variables de type '__Para...'. */ \
/* */ \
/* Le 20000202084613, la valeur a ete augmentee de 'DEUX' afin de compenser l'edition de */ \
/* 'NUMERO_UNIQUE_de_l_argument_possible_courant', puis le 20000203100529, apres avoir */ \
/* supprime l'edition de 'IDENTITE_de_l_argument_possible_courant', la valeur 'DEUX' a ete */ \
/* remplacee par 'TREIZE'. Le 20000531111959, je suis passe de 'TREIZE' a 'VINGT' apres */ \
/* avoir ajoute "Parametre"... */ \
/* */ \
/* Le 20011230095027, apres l'introduction de l'option "TabulationParametres=", ce parametre */ \
/* a ete reduit de 'ADD2(SOIXANTE,VINGT)' a 'SOIXANTE' de facon a ce que, lorsque les noms */ \
/* des parametres sont edites, les lignes ne soient pas trop longues et donc ne se replient */ \
/* pas... */ \
/* */ \
/* Le 20081113173427, j'ai tente d'editer le nombre maximal de parametres. Cela impliquait */ \
/* les mofifications suivantes : */ \
/* */ \
/* #define TABULATION_DES_VALEURS_AFFECTEES_AUX_TITRES \ */ \
/* SOUS(SOIXANTE,CINQ) */ \
/* */ \
/* mais j'y ai renonce le 20081115105359 ('v $xig/fonct$vv$FON 20081113173432')... */ \
/* */ \
/* Finalement, cela a pu etre retabli grace a 'v $xcc/cpp$Z 20081116112629', en notant que */ \
/* finalement la tabulation n'a pas changee (malgre le 'ADD2(...,ZERO)' afin de conserver */ \
/* la mise en page precedente... */ \
/* */ \
/* Le 20101005095320, je suis passe de 'ADD2(SOIXANTE,ZERO)' a 'ADD2(SOIXANTE,CINQ)' a cause */ \
/* de "generation_d_un_nom_relatif_temporaire_compatibilite_20061226="... */ \
/* */ \
/* Le 20121025184449, je suis passe de 'ADD2(SOIXANTE,CINQ)' a 'ADD2(SOIXANTE_DIX,CINQ) a */ \
/* cause de "Fmise_a_jour_du_systeme_de_gestion_de_fichiers_compatibilite_20121025="... */
#define EN_TETE_COMPLETE_DE_titre_attendu_LORS_DES_ENTREES_VIA_DES_SETENV \
EGAs(chain_Aconcaten3("P__",NOM_SYNTHETIQUE_DU_FICHIER_COURANT,"__"))
#define EN_TETE_DE_titre_attendu_LORS_DES_ENTREES_VIA_DES_SETENV \
GvarDefaut("P__",EN_TETE_COMPLETE_DE_titre_attendu_LORS_DES_ENTREES_VIA_DES_SETENV)
/* Les variables d'environnement ('setenv') permettant de definir certains parametres d'une */
/* commande doivent commencer par une chaine specifique afin d'eviter des "collisions" avec */
/* des variables pre-existantes. Par exemple, a "Xmin=" on associera '$P__Xmin'. Ceci a ete */
/* introduit le 19980420092917. Le 20000628104614 a ete introduit une nouvelle possibilite. */
/* Si la variable d'environnement '$P__' existe, c'est elle qui fixe l'en-tete des noms des */
/* variables d'entree des parametres. Par contre si elle n'existe pas, la concatenation de */
/* "P__" et du nom synthetique du programme qui est utilise ' ce nom synthetique est, par */
/* exemple, "xrk_rdn_walk_52' pour '$xrk/rdn_walk.52$K' ; ainsi, pour acceder au parametre */
/* de nom "PARAMETRE" et de valeur "VALEUR" on utilisera : */
/* */
/* setenv P__PARAMETRE VALEUR */
/* */
/* ou : */
/* */
/* unsetenv P__ */
/* setenv P__xrk_rdn_walk_52__PARAMETRE VALEUR */
/* */
/* suivant que la variable d'environnement ('setenv') '$P__' existe (avec pour valeur */
/* "P__" dans cet exemple) ou n'existe pas... */
/* */
/* Le 20190110102120 fut introduite 'EN_TETE_COMPLETE_DE_titre_attendu_LORS_DES_ENTREES...'. */
/* En fait, l'idee etait alors de concatener une nouvelle variable d'environnement */
/* specifique a chaque '$K' et qui contiendrait un certain nombre de definitions de */
/* valeurs de parametres destinees a etre concatenees a la suite des arguments d'appel */
/* de ces '$K's. Or cela serait une chaine de caracteres, alors que la suite des arguments */
/* d'appel d'un '$K' est un tableau de telles chaines ('v $xil/defi_c1$vv$DEF BCommande'), */
/* d'ou l'incompatibilite et le renoncement a implementer ce dispositif... */
#define FORCER_sequenceC_DANS_gPROCESS_PARAMETRE_LORS_DE_LA_DERNIERE_RECHERCHE \
VRAI
#define NE_PAS_FORCER_sequenceC_DANS_gPROCESS_PARAMETRE_LORS_DE_LA_DERNIERE_RECHERCHE \
NOTL(FORCER_sequenceC_DANS_gPROCESS_PARAMETRE_LORS_DE_LA_DERNIERE_RECHERCHE)
/* Pour definir le parametre 'fC' de 'gPROCESS_PARAMETRE(...)' introduit le 20000207110651. */
/* Les definitions suivantes sont destinees a "compactifier" les sources '$c'. On trouve */
/* deux sortes de definition : */
/* */
/* @define wMN \ */
/* VARIABLE_EXTERNE */
/* #define VARIABLE_EXTERNE \ */
/* wMN */
/* */
/* pour les variables externes, et : */
/* */
/* #define VARIABLE_LOCALE \ */
/* wMN */
/* */
/* pour les variables locales (ou "M" et "N" designent en general un chiffre quelconque...). */
#define Selection_FORMAT(format1,format2) \
SE22(format1,format2) \
/* Introduit le 20180330113803 afin de passer a une version plus economique des allocations */ \
/* memoire le 20180330114416... */
#define FORMAT_CHAI_2 \
Selection_FORMAT(cFORMAT_CHAI_2,format_EGAr____FORMAT_CHAI_2)
#define FORMAT_CHAI \
Selection_FORMAT(cFORMAT_CHAI,format_EGAr____FORMAT_CHAI)
#define FORMAT_CHAI_EDITION \
Selection_FORMAT(cFORMAT_CHAI_EDITION,format_EGAr____FORMAT_CHAI_EDITION)
#define FORMAT_CHAR_EDITION \
Selection_FORMAT(cFORMAT_CHAR_EDITION,format_EGAr____FORMAT_CHAR_EDITION)
#define FORMAT_CHAR_EDITION_BACKSLASHEE \
Selection_FORMAT(cFORMAT_CHAR_EDITION_BACKSLASHEE,format_EGAr____FORMAT_CHAR_EDITION_BACKSLASHEE)
#define FORMAT_CHAR_HEXA_DECIMAL_EDITION_1 \
Selection_FORMAT(cFORMAT_CHAR_HEXA_DECIMAL_EDITION_1,format_EGAr____FORMAT_CHAR_HEXA_DECIMAL_EDITION_1)
#define FORMAT_CHAR_HEXA_DECIMAL_EDITION \
Selection_FORMAT(cFORMAT_CHAR_HEXA_DECIMAL_EDITION,format_EGAr____FORMAT_CHAR_HEXA_DECIMAL_EDITION)
#define FORMAT_FLOT \
Selection_FORMAT(cFORMAT_FLOT,format_EGAr____FORMAT_FLOT)
#define FORMAT_FLOT_EDITION \
Selection_FORMAT(cFORMAT_FLOT_EDITION,format_EGAr____FORMAT_FLOT_EDITION)
#define FORMAT_FLOT_EDITION__NON_SIGNE \
Selection_FORMAT(cFORMAT_FLOT_EDITION__NON_SIGNE,format_EGAr____FORMAT_FLOT_EDITION__NON_SIGNE)
#define FORMAT_HEXA_DECIMAL \
Selection_FORMAT(cFORMAT_HEXA_DECIMAL,format_EGAr____FORMAT_HEXA_DECIMAL)
#define FORMAT_HEXA_DECIMAL_SANS_0_EDITION \
Selection_FORMAT(cFORMAT_HEXA_DECIMAL_SANS_0_EDITION,format_EGAr____FORMAT_HEXA_DECIMAL_SANS_0_EDITION)
#define FORMAT_HEXA_DECIMAL_EDITION_1 \
Selection_FORMAT(cFORMAT_HEXA_DECIMAL_EDITION_1,format_EGAr____FORMAT_HEXA_DECIMAL_EDITION_1)
#define FORMAT_HEXA_DECIMAL_EDITION \
Selection_FORMAT(cFORMAT_HEXA_DECIMAL_EDITION,format_EGAr____FORMAT_HEXA_DECIMAL_EDITION)
#define FORMAT_INTE \
Selection_FORMAT(cFORMAT_INTE,format_EGAr____FORMAT_INTE)
#define FORMAT_INTE_EDITION \
Selection_FORMAT(cFORMAT_INTE_EDITION,format_EGAr____FORMAT_INTE_EDITION)
#define FORMAT_INTE_EDITION__NON_SIGNE \
Selection_FORMAT(cFORMAT_INTE_EDITION__NON_SIGNE,format_EGAr____FORMAT_INTE_EDITION__NON_SIGNE)
/* Introduit le 20180330101517 dans le but a venir de reduire le nombre d'allocations */
/* memoire... */
#define INCR_INDEX_DES_ARGUMENTS_POSSIBLES(index_a_incrementer,message_d_erreur) \
Bblock \
DEFV(Int,INIT(valeur_maximale_de_l_index_a_incrementer \
,LSTX(PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
,NOMBRE_MAXIMAL_DE_NUMEROS_UNIQUES_DES_ARGUMENTS_POSSIBLES \
) \
) \
); \
\
Test(IFLT(index_a_incrementer,valeur_maximale_de_l_index_a_incrementer)) \
Bblock \
INCR(index_a_incrementer,I); \
/* Cas ou il ne reste plus de place dans les listes... */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR(message_d_erreur); \
CALS(FPrer2II("(l'index courant vaut %d alors qu'il ne peut exceder %d)\n" \
,index_a_incrementer \
,valeur_maximale_de_l_index_a_incrementer \
) \
); \
/* Le 20221124120306, 'CAL1(Prer2(...))' a ete remplace par 'CALS(FPrer2(...))' afin de */ \
/* reduire la taille des '$xc's et des '$X's ('v $xtc/xcg_ADD2.01.20221124111411$c' qui */ \
/* a permis de mettre en evidence la necessite de cette optimisation, ce qui a ete ensuite */ \
/* verifie avec 'v $xtc/xcg_ADD2.01.20221124124248$c'...). */ \
/* */ \
/* Le 20221125112912, le nom 'FPrer2' a ete change en 'FPrer2II' afin de rappeler le */ \
/* type des deux arguments... */ \
Eblock \
ETes \
Eblock \
/* Gestion des debordements de liste (introduit le 20070820163243...). */
#define gPROCESS_PARAMETRE_IDENTITE(ityp) \
/* L'argument 'styp' a ete introduit le 20061121094424 (voir a ce propos les explications */ \
/* donnees dans 'v $xig/fonct$vv$FON 20061121091238'). Le nom 'styp' a ete change en */ \
/* 'ityp' le 20061123175305 car, en effet, 'styp' contient une ambiguite intrinseque */ \
/* puisqu'il s'agit d'une taille et que, par exemple, 'Int' et 'Logical' ont la meme */ \
/* taille sans etre synonymes... */ \
Bblock \
EGAL(IDENTITE_de_l_argument_possible_courant \
,bSOU(pointeurC_parametre,pointeurC_parametre_fictif_IDENTITE_des_arguments) \
); \
/* Memorisation de l'identite du parametre possible courant. */ \
\
Test(IFET(EST_VRAI(c_est_la_derniere_recherche_des_parametres) \
,IFGE(numero_d_argument_courant,NUMERO_PREMIER_ARGUMENT) \
) \
) \
/* Je note le 20111219175904 que le test : */ \
/* */ \
/* IFGE(numero_d_argument_courant,NUMERO_PREMIER_ARGUMENT) */ \
/* */ \
/* est toujours 'FAUX' lorsque 'IL_FAUT(editer_la_valeur_des_parametres_d_une_commande)'. */ \
/* En consequence, 'NUMERO_UNIQUE_de_l_argument_possible_courant' n'a donc une valeur */ \
/* significative que dans ce cas et dans 'gPROCESS_PARAMETRE_VALIDATION_DU_TYPE(...)' il */ \
/* n'est donc pas possible d'editer 'NUMERO_UNIQUE_de_l_argument_possible_courant'... */ \
Bblock \
EGAL(l_argument_possible_courant_est_un_synonyme_d_argument_anterieur,FAUX); \
/* Pour permettre de ne pas editer les synonymes (introduit le 20010420140719)... */ \
\
Test(Ftest_IDENTITE_de_l_argument_possible()) \
Bblock \
EGAL(NUMERO_UNIQUE_de_l_argument_possible_courant \
,PRED(NUMERO_de_l_argument_possible_courant) \
); \
/* En effet, il y a eu un 'INCR(...)' de trop lorsqu'au "tour" precedent l'argument */ \
/* 'IDENTITE_de_l_argument_possible_courant' ('IDENTITE_de_l_argument_possible_precedent' */ \
/* actuel) etait different de celui qui le precedait... */ \
Eblock \
ATes \
Bblock \
EGAL(NUMERO_UNIQUE_de_l_argument_possible_courant \
,NEUT(NUMERO_de_l_argument_possible_courant) \
); \
/* A priori (quitte a changer cela plus loin...). */ \
Eblock \
ETes \
\
EGAL(NUMERO_UNIQUE_maximal_de_l_argument_possible_courant \
,MAX2(NUMERO_UNIQUE_maximal_de_l_argument_possible_courant \
,NUMERO_UNIQUE_de_l_argument_possible_courant \
) \
); \
/* Introduit le 20081117092814 afin de valider 'nombre_d_arguments_possibles_regroupes_...'. */ \
/* */ \
/* On notera bien que 'NUMERO_UNIQUE_maximal_de_l_argument_possible_courant' ne peut pas */ \
/* remplacer 'nombre_d_arguments_possibles_regroupes_par_classe_de_synonymes' car, en effet, */ \
/* c'est lorsque 'EST_VRAI(c_est_la_derniere_recherche_des_parametres)' qu'a lieu l'edition */ \
/* des parametres : cela demande que le nombre maximal d'arguments soit connu avant toute */ \
/* edition, or 'NUMERO_UNIQUE_maximal_de_l_argument_possible_courant' evolue en permanence */ \
/* et est evalue en meme temps ('EST_VRAI(c_est_la_derniere_recherche_des_parametres)'), */ \
/* alors que 'v $xcc/cpp$Z nombre_d_arguments_possibles_regroupes_par_classe_de_synonymes' */ \
/* est "pre-calcule"... */ \
\
Test(EST_VRAI(c_est_le_premier_argument_possible_courant)) \
Bblock \
EGAL(c_est_le_premier_argument_possible_courant,FAUX); \
/* Pour le premier parametre possible, le numero initial est conserve. */ \
EGAL(ITb1(IDENTITE_des_arguments_possibles \
,INDX(NUMERO_de_l_argument_possible_courant \
,PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
) \
) \
,IDENTITE_de_l_argument_possible_courant \
); \
EGAL(ITb1(ITYP_des_arguments_possibles \
,INDX(NUMERO_de_l_argument_possible_courant \
,PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
) \
) \
,ityp \
); \
/* Initialisation du processus de gestion des synonymes... */ \
/* */ \
/* ATTENTION : jusqu'au 20070819174619, c'etait 'IDENTITE_des_arguments_possibles' qui */ \
/* figurait ci-dessus au-lieu de 'ITYP_des_arguments_possibles' par erreur ! */ \
\
INCR_INDEX_DES_ARGUMENTS_POSSIBLES(NUMERO_de_l_argument_possible_courant \
,"debordement de la liste des arguments possibles (2)" \
); \
/* Lorsqu'il reste de la place dans la liste, on memorise l'argument courant qui n'avait */ \
/* donc pas de synonyme... */ \
Eblock \
ATes \
Bblock \
DEFV(Int,INIT(NUMERO_des_arguments_possibles_precedents \
,PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
) \
); \
DEFV(Logical,INIT(continuer_a_chercher_un_synonyme,VRAI)); \
/* Donnees pour la recherche des synonymes. */ \
\
Tant(IL_FAUT(continuer_a_chercher_un_synonyme)) \
Bblock \
Test(IFET(IFEQ(ITb1(IDENTITE_des_arguments_possibles \
,INDX(NUMERO_des_arguments_possibles_precedents \
,PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
) \
) \
,IDENTITE_de_l_argument_possible_courant \
) \
,IFEQ(ITb1(ITYP_des_arguments_possibles \
,INDX(NUMERO_des_arguments_possibles_precedents \
,PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
) \
) \
,ityp \
) \
) \
) \
Bblock \
EGAL(l_argument_possible_courant_est_un_synonyme_d_argument_anterieur,VRAI); \
/* Pour permettre de ne pas editer les synonymes (introduit le 20010420140719)... */ \
\
EGAL(NUMERO_UNIQUE_de_l_argument_possible_courant,NUMERO_des_arguments_possibles_precedents); \
EGAL(continuer_a_chercher_un_synonyme,FAUX); \
/* Cas ou l'argument courant possede un synonyme deja rencontre ; on arrete donc ici la */ \
/* recherche... */ \
Eblock \
ATes \
Bblock \
/* Cas ou l'on n'a pas encore trouve de synonyme pour l'argument courant : */ \
Test(IFET(IFLT(NUMERO_des_arguments_possibles_precedents \
,NUMERO_de_l_argument_possible_courant \
) \
,IFLT(NUMERO_des_arguments_possibles_precedents \
,LSTX(PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
,NOMBRE_MAXIMAL_DE_NUMEROS_UNIQUES_DES_ARGUMENTS_POSSIBLES \
) \
) \
) \
) \
Bblock \
INCR(NUMERO_des_arguments_possibles_precedents,I); \
/* Cas ou il y a encore des arguments precedents non utilises pour cette recherche de */ \
/* synonyme : on continue... */ \
Eblock \
ATes \
Bblock \
/* Lorsque l'on a explore tous les arguments precedents sans succes, cela signifie que */ \
/* l'argument courant n'a pas de synonyme. */ \
Test(IFLE(NUMERO_de_l_argument_possible_courant \
,LSTX(PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
,NOMBRE_MAXIMAL_DE_NUMEROS_UNIQUES_DES_ARGUMENTS_POSSIBLES \
) \
) \
) \
Bblock \
EGAL(ITb1(IDENTITE_des_arguments_possibles \
,INDX(NUMERO_de_l_argument_possible_courant \
,PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
) \
) \
,IDENTITE_de_l_argument_possible_courant \
); \
EGAL(ITb1(ITYP_des_arguments_possibles \
,INDX(NUMERO_de_l_argument_possible_courant \
,PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
) \
) \
,ityp \
); \
\
INCR(NUMERO_de_l_argument_possible_courant,I); \
/* Lorsqu'il reste de la place dans la liste, on memorise l'argument courant qui n'avait */ \
/* donc pas de synonyme... */ \
Eblock \
ATes \
Bblock \
/* Lorsqu'il n'y a plus de place dans la liste, on se contente du processus simpliste qui */ \
/* se contente de comparer les arguments strictement consecutifs... */ \
PRINT_ERREUR("debordement de la liste des arguments possibles (1)"); \
\
Test(IFEQ(IDENTITE_de_l_argument_possible_courant \
,IDENTITE_de_l_argument_possible_precedent \
) \
) \
Bblock \
Eblock \
ATes \
Bblock \
INCR(NUMERO_de_l_argument_possible_courant,I); \
/* Pour les parametres possibles suivants, le numero est incremente si le parametre */ \
/* possible est different du precedent. On notera que ce dispositif ne fonctionne bien */ \
/* pour identifier les synonymes que si ceux-ci sont definis les uns a la suite des autres, */ \
/* sans imbrications d'autres parametres entre-eux... */ \
/* */ \
/* ATTENTION : detail amusant, le parametre : */ \
/* */ \
/* "Parametres=" */ \
/* */ \
/* qui est le premier ('v $xig/fonct$vv$DEF GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE') */ \
/* n'est jamais edite (lorsqu'il vaut 'VRAI') puisqu'au moment de son traitement, l'option */ \
/* 'editer_la_valeur_des_parametres_d_une_commande' n'est pas encore active. Ainsi, le */ \
/* premier parametre a edite alors a donc le numero 2 (c'est-a-dire le suivant de 1...). */ \
/* L'origine de ce probleme a enfin ete comprise le 20030710112150 lors de la mise en tete */ \
/* de 'MARQUEUR________DebutParametresGeneraux' dans la procedure de recuperation generale */ \
/* 'GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE' ('v $xig/fonct$vv$DEF 20030710112150'). */ \
Eblock \
ETes \
Eblock \
ETes \
\
EGAL(continuer_a_chercher_un_synonyme,FAUX); \
/* Et evidemment, il faut arreter la recherche... */ \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ETan \
Eblock \
ETes \
\
EGAL(IDENTITE_de_l_argument_possible_precedent_precedent,IDENTITE_de_l_argument_possible_precedent); \
EGAL(IDENTITE_de_l_argument_possible_precedent,IDENTITE_de_l_argument_possible_courant); \
/* ATTENTION : on notera que a la sortie de cette procedure, et tant qu'elle n'est pas */ \
/* reutilisee, on : */ \
/* */ \
/* courant == precedent */ \
/* */ \
/* et donc c'est 'precedent_precedent' qu'il faut tester et non pas 'precedent' si l'on */ \
/* veut savoir si l'element courant est le synonyme de l'element precedent. Cela justifie */ \
/* la programmation de 'v $xig/fonct$vv$DEF FORMAT_D_EDITION_DES_IDENTITES_UNIQUES'... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Gestion de l'identite des parametres destinee princiaplement a identifier les synonymes. */
#define gPROCESS_PARAMETRE_VALIDATION_DU_TYPE(titre_attendu,taille_du_type_attendu,taille_courante) \
Bblock \
Test(EST_VRAI(c_est_la_derniere_recherche_des_parametres)) \
/* Ces tests ont ete introduits le 20010330100201 a la suite de celui qui a ete introduit */ \
/* dans 'v $xig/fonct$vv$FON 20010329144054'. */ \
Bblock \
Test(I3OU(IFOU(IFEQ(taille_du_type_attendu,styp_K) \
,IFEQ(taille_du_type_attendu,styp_C) \
) \
,IFOU(IFEQ(taille_du_type_attendu,styp_L) \
,IFEQ(taille_du_type_attendu,styp_N) \
) \
,I3OU(IFEQ(taille_du_type_attendu,styp_I) \
,IFEQ(taille_du_type_attendu,styp_F) \
,IFEQ(taille_du_type_attendu,styp_P) \
) \
) \
) \
/* Validation introduite le 20111118183450... */ \
/* */ \
/* On notera que j'ai voulu ecrire ici : */ \
/* */ \
/* Choi(taille_du_type_attendu) */ \
/* Bblock */ \
/* Ca7e(styp_K,styp_C,styp_L,styp_N,styp_I,styp_F,styp_P) */ \
/* Bblock */ \
/* (...) */ \
/* Eblock */ \
/* ECa7 */ \
/* */ \
/* Defo */ \
/* Bblock */ \
/* (...) */ \
/* Eblock */ \
/* EDef */ \
/* */ \
/* Mais que cela provoque les messages : */ \
/* */ \
/* error: duplicate case value */ \
/* error: previously used here */ \
/* */ \
/* car, en effet, plusieurs 'styp_?' ont la meme valeur ('styp_L' et 'styp_N' par exemple). */ \
Bblock \
Test(IFNE(taille_du_type_attendu,NE_PAS_VALIDER_UN_styp)) \
Bblock \
Test(IFNE(taille_courante,taille_du_type_attendu)) \
Bblock \
PRINT_ERREUR("il y a surement un conflit de typage d'un Parametre (2)"); \
CAL1(Prer1("(il s'agit du Parametre introduit par '%s', " \
,titre_attendu \
) \
); \
/* Le message a ete mis entre parentheses le 20051213142228... */ \
/* */ \
/* Le 20111219175904 je note que la valeur de 'NUMERO_UNIQUE_de_l_argument_possible_courant' */ \
/* ne peut etre editee ici a cause de 'v $xig/fonct$vv$DEF 20111219175904', cette valeur */ \
/* n'etant pas d'un usage systematique... */ \
CAL1(Prer2("sa longueur courante vaut %d alors qu'elle devrait valoir %d)\n" \
,taille_courante \
,taille_du_type_attendu \
) \
); \
/* Ce message complementaire a ete introduit le 20111112083810... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la taille du type attendu n'est pas reconnue"); \
CAL1(Prer1("(il s'agit du Parametre introduit par '%s', " \
,titre_attendu \
) \
); \
/* Message introduit le 20111219164123... */ \
/* */ \
/* Le 20111219175904 je note que la valeur de 'NUMERO_UNIQUE_de_l_argument_possible_courant' */ \
/* ne peut etre editee ici a cause de 'v $xig/fonct$vv$DEF 20111219175904', cette valeur */ \
/* n'etant pas d'un usage systematique... */ \
CAL1(Prer1("cette taille vaut %d)\n",taille_du_type_attendu)); \
/* Messages introduits le 20111118183450... */ \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Validation eventuelle du type du parametre courant... */
#define gPROCESS_PARAMETRE_DEBUT(titre_attendu,taille_du_type_attendu,taille_courante,identite_du_type_attendu) \
/* L'argument 'identite_du_type_attendu' a ete introduit le 20061123175305... */ \
Bblock \
CALS(FgPROCESS_PARAMETRE_IDENTITE(identite_du_type_attendu)); \
/* Gestion de l'identite des parametres destinee principalement a identifier les synonymes. */ \
\
CALS(FgPROCESS_PARAMETRE_TITRAGE()); \
/* Edition eventuelle du titre des "Parametres" apres que la variable */ \
/* 'NUMERO_UNIQUE_de_l_argument_possible_courant' ait ete mise a jour... */ \
\
CALS(FgPROCESS_PARAMETRE_VALIDATION_DU_TYPE(titre_attendu,taille_du_type_attendu,taille_courante)); \
/* Validation eventuelle du type du parametre courant... */ \
Eblock \
/* Gestion de l'identite des parametres destinee principalement a identifier les synonymes, */ \
/* puis edition eventuelle du titre des "Parametres" apres que la variable */ \
/* 'NUMERO_UNIQUE_de_l_argument_possible_courant' ait ete mise a jour et enfin validation */ \
/* validation eventuelle du type du parametre courant... */
#ifdef gPROCESS_PARAMETRE_ENTREE_PAR_setenv_VERSION_01
# define gPROCESS_PARAMETRE_ENTREE_PAR_setenv(titre_attendu,parametre,va_defaut,FCon) \
Bblock \
Eblock
#Aifdef gPROCESS_PARAMETRE_ENTREE_PAR_setenv_VERSION_01
#Eifdef gPROCESS_PARAMETRE_ENTREE_PAR_setenv_VERSION_01
#ifdef gPROCESS_PARAMETRE_ENTREE_PAR_setenv_VERSION_02
# define gPROCESS_PARAMETRE_ENTREE_PAR_setenv(titre_attendu,parametre,va_defaut,FCon) \
Bblock \
Test(Ftest_ENTREE_PAR_setenv()) \
/* L'entree via une variable 'setenv' n'est fait que lors du premier parcours de la */ \
/* 'liste_de_traitement' car, en effet, contrairement au traitement de 'liste_des_arguments' */ \
/* il ne faut le faire qu'une seule fois. En particulier, cela permet de garantir que pour */ \
/* un argument defini a la fois par variable 'setenv' et par un parametre d'appel, c'est ce */ \
/* dernier qui l'emportera... */ \
/* */ \
/* ATTENTION, ce test par rapport a 'NUMERO_PREMIER_ARGUMENT' fait que la declaration : */ \
/* */ \
/* Environnement=VRAI */ \
/* */ \
/* ou l'equivalence : */ \
/* */ \
/* setenv=VRAI */ \
/* */ \
/* doit etre le premier des parametres d'une commande. Au-dela elle sera ineffective... */ \
/* */ \
/* Le test sur 'bloquer_provisoirement__entrer_des_parametres_via_des_setenv' a ete */ \
/* introduit le 20090422091211... */ \
/* */ \
/* Le 20090422110711 a ete mis en place l'entree via une variable 'setenv' y compris dans */ \
/* le cas ou la commande n'a pas de parametres (ce qui n'etait pas possible avant cette */ \
/* date...). Le test ci-dessus a donc ete modifie en consequences, mais de facon apparemment */ \
/* complique. En fait : */ \
/* */ \
/* IFET(IFGT(nombre_effectif_d_arguments,UN) */ \
/* ,IFEQ(numero_d_argument_courant,NUMERO_PREMIER_ARGUMENT) */ \
/* ) */ \
/* */ \
/* correspond au test anterieur (ou l'entree via des 'setenv's se faisait lors du traitement */ \
/* du premier argument -de numero 'NUMERO_PREMIER_ARGUMENT'-). Alors que : */ \
/* */ \
/* IFEQ(nombre_effectif_d_arguments,UN) */ \
/* */ \
/* traite le cas ou il n'y a aucun argument (l'entree via des 'setenv's se fait alors lors */ \
/* du traitement du nom de la commande -de numero 'NOM_DE_LA_COMMANDE'-). Il semblerait */ \
/* qu'en fait ce dernier test suffise et que les entrees via des 'setenv's puissent toute */ \
/* avoir lieu lors du traitement du nom de la commande, qu'il y ait ou pas des arguemnts. */ \
/* Mais, on ne sait jamais car cela marchait tres bien avant... */ \
Bblock \
DEFV(CHAR,INIT(POINTERc(nom_variable_d_environnement_associee_au_titre_attendu),CHAINE_UNDEF)); \
DEFV(CHAR,INIT(POINTERc(valeur_variable_d_environnement_associee_au_titre_attendu),CHAINE_UNDEF)); \
/* Definition de la variable d'environnement associee au 'titre_attendu'. */ \
\
MOVE_CARACTERE_NE_DEPLACE_QUE_LES_CARACTERES_ALPHA_NUMERIQUES; \
EGAp(nom_variable_d_environnement_associee_au_titre_attendu \
,chain_Aconcaten2(EN_TETE_DE_titre_attendu_LORS_DES_ENTREES_VIA_DES_SETENV \
,titre_attendu \
) \
); \
MOVE_CARACTERE_DEPLACE_TOUS_LES_CARACTERES; \
/* Generation du nom de la variable d'environnement associee au 'titre_attendu' en */ \
/* eliminant tous les codes non alpha-numeriques... */ \
\
EGAp(valeur_variable_d_environnement_associee_au_titre_attendu \
,Gvar(nom_variable_d_environnement_associee_au_titre_attendu) \
); \
/* Recuperation de la valeur de la variable d'environnement associee au 'titre_attendu' */ \
/* si elle existe... */ \
\
Test(IFNE_chaine(valeur_variable_d_environnement_associee_au_titre_attendu,VALEUR_D_UNE_VARIABLE_UNDEF)) \
Bblock \
/* Cas ou la variable d'environnement associee au 'titre_attendu' existe : */ \
begin_nouveau_block \
Bblock \
DEFV(CHAR,INIC(POINTERc(format_EGAq____gPROCESS_PARAMETRE_ENTREE_PAR_setenv) \
,chain_Aconcaten2(titre_attendu \
,valeur_variable_d_environnement_associee_au_titre_attendu \
) \
) \
); \
\
EGAp(parametre \
,FCon(format_EGAq____gPROCESS_PARAMETRE_ENTREE_PAR_setenv \
,titre_attendu \
,va_defaut \
,NE_PAS_EDITER_LES_VALEURS_APRES_Fconversion \
,C_VIDE \
,INDICATEUR_DE_TYPE_____A_R \
) \
); \
/* Entree eventuelle d'un parametre via un 'setenv' (introduit le 19980420092917). */ \
/* */ \
/* La chaine 'INDICATEUR_DE_TYPE_____A_R' a ete introduite le 20060310095832 suite a la */ \
/* modification 'v $xig/fonct$vv$FON 20060310093722' relative a l'introduction du nouvel */ \
/* argument 'A_R' des fonctions 'Fconversion?(...)'. */ \
\
CALZ_FreCC(format_EGAq____gPROCESS_PARAMETRE_ENTREE_PAR_setenv); \
Eblock \
end_nouveau_block \
\
EGAL(valeur_recherchee_dans_un_setenv,valeur_recherchee); \
/* Memorisation du compte-rendu... */ \
Eblock \
ATes \
Bblock \
/* Cas ou la variable d'environnement associee au 'titre_attendu' n'existe pas... */ \
Eblock \
ETes \
\
CALZ_FreCC(nom_variable_d_environnement_associee_au_titre_attendu); \
/* Ce nettoyage a ete introduit le 20030707092751 car il manquait. On notera qu'il ne */ \
/* faut pas faire de : */ \
/* */ \
/* CALS(Free(valeur_variable_d_environnement_associee_au_titre_attendu)); */ \
/* */ \
/* car, en effet, le pointeur renvoye par 'Gvar(...)' n'est pas du tout de meme nature que */ \
/* celui qui est renvoye par 'Malo(...)'. Il semble que 'Gvar(...)' renvoit directement un */ \
/* pointeur sur l'environnement, alors que 'Malo(...)', comme son nom l'indique, fait de */ \
/* l'allocation dynamique dans la pile... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Validation eventuelle du type du parametre courant. Cette procedure a ete introduite */ \
/* le 20020104095016 afin d'offrir la possibilite de mettre ce dispositif en tant que */ \
/* 'VERSION' car, en effet, il est pratiquement pas utilise... */
#Aifdef gPROCESS_PARAMETRE_ENTREE_PAR_setenv_VERSION_02
#Eifdef gPROCESS_PARAMETRE_ENTREE_PAR_setenv_VERSION_02
#define gPROCESS_PARAMETRE_RECUPERATION_ET_TRANSFORMATION(liste_des_arguments,numero_d_argument_courant,abr) \
Bblock \
DEFV(CHAR,INIT(POINTERc(argument_courant),CHAINE_UNDEF)); \
/* Argument courant... */ \
DEFV(CHAR,INIT(POINTERc(debut_de_l_argument_courant),CHAINE_UNDEF)); \
/* Debut de l'argument courant pour voir s'il n'est pas deja prefixe (introduit le */ \
/* 20030705121308). */ \
\
EGAp(argument_courant \
,chain_Acopie(ITb1(liste_des_arguments \
,INDX(numero_d_argument_courant \
,NUMERO_ARGUMENT_COMMANDE \
) \
) \
) \
); \
/* Argument courant... */ \
\
Test(EST_VRAI(abr)) \
Bblock \
/* Cas ou le parametre courant peut etre abrege (on verra a ce propos avec profit les */ \
/* commentaires 'v $xig/fonct$vv$DEF PROCESS_ARGUMENT_C..PreFixeParametres=.' pour */ \
/* une definition et des exemples d'usage) : */ \
Test(EST_VRAI(c_est_la_derniere_recherche_des_parametres)) \
/* Afin de ne compter qu'une seule fois les parametres abregeables... */ \
Bblock \
INCR(nombre_de_parametres_supportant_PreFixeParametres,I); \
/* Comptage introduit le 20030708094336 des parametres supportant le prefixage... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
EGAp(debut_de_l_argument_courant \
,chain_ANcopie(argument_courant \
,chain_Xtaille(prefixe_destine_a_abreger_certains_Parametres_qui_suivent) \
) \
); \
/* Debut de l'argument courant sur une longueur egale a l'eventuel prefixe (introduit le */ \
/* 20030705121308). Ainsi, on va pouvoir tester si l'argument courant ne serait pas deja */ \
/* prefixe par 'prefixe_destine_a_abreger_certains_Parametres_qui_suivent'... */ \
Eblock \
ATes \
Bblock \
/* Cas ou le parametre courant ne peut pas etre abrege... */ \
Eblock \
ETes \
\
begin_nouveau_block \
Bblock \
DEFV(CHAR,INIC(POINTERc(format_EGAq____gPROCESS_PARAMETRE_RECUPERATION_ET_TRANSFORMATION) \
,chain_Aconcaten2 \
(COND(IFET(EST_VRAI(abr) \
,EST_FAUX(chain_compare \
(debut_de_l_argument_courant \
,prefixe_destine_a_abreger_certains_Parametres_qui_suivent \
) \
) \
) \
,prefixe_destine_a_abreger_certains_Parametres_qui_suivent \
,ccCHAR(C_VIDE) \
) \
,argument_courant \
) \
) \
); \
\
EGAp(argument_courant_apres_conversions_majuscules_minuscules_et_prefixage_eventuels_2 \
,chain_Acopie_avec_conversions_possibles_majuscules_minuscules \
(format_EGAq____gPROCESS_PARAMETRE_RECUPERATION_ET_TRANSFORMATION \
,GET_ARGUMENT_____convertir_les_caracteres_majuscules_en_caracteres_minuscules \
,GET_ARGUMENT_____convertir_les_caracteres_minuscules_en_caracteres_majuscules \
,GET_ARGUMENT_____carret_chain_Acopie_avec_conversions_possibles_majuscules_minuscules \
) \
); \
/* Argument courant apres les eventuelles conversions majuscules-minuscules et inversement */ \
/* (introduit le 20010621143912). La possibilite d'abreger une partie des parametres a ete */ \
/* introduite le 20030704090902. Le 20030704142017, les abreviations ont ete rendues */ \
/* optionnelles (via l'argument 'abr'). A compter du 20030705121308 le prefixe d'abreviation */ \
/* (s'il peut etre utilise via l'argument 'abr') n'est applique que s'il ne prefixe pas */ \
/* deja l'argument courant. */ \
/* */ \
/* Ce 'argument_courant_apres_conversions_majuscules_minuscules_et_prefixage_eventuels_2' */ \
/* n'est pas celui qui est defini ci-apres dans 'gPROCESS_PARAMETRE(...)', mais celui de la */ \
/* fonction 'v $xig/fonct$vv$FON FgPROCESS_PARAMETRE_RECUPERATION_ET_TRANSFORMATION'. Cela */ \
/* fut note le 20051024140750 ; au passage, ils representent tous les deux la meme chose, */ \
/* donc la confusion est, semble-t-il, sans importance. Malgre tout, le 20051025153049, */ \
/* j'ai introduit les postfixes "_1" et "_2" pour les distinguer, cela ameliorera la */ \
/* lisibilite... */ \
\
CALZ_FreCC(format_EGAq____gPROCESS_PARAMETRE_RECUPERATION_ET_TRANSFORMATION); \
Eblock \
end_nouveau_block \
\
Test(EST_VRAI(abr)) \
Bblock \
CALZ_FreCC(debut_de_l_argument_courant); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
CALZ_FreCC(argument_courant); \
Eblock \
/* Recuperation du parametre courant et transformation eventuelle. Ceci a ete introduit le */ \
/* 20030706112345 afin de reduire le code genere par 'gPROCESS_PARAMETRE(...)'. A titre */ \
/* d'exemple, voici les tailles avant et apres concernant 'v $xrv/SysLin_2D.01$K' : */ \
/* */ \
/* SysLin_2D.01$c : 373177 --> 332092 */ \
/* SysLin_2D.01$X : 112929 --> 104744 */ \
/* */ \
/* et pour 'v $xrv/variation.01$K' : */ \
/* */ \
/* variation.01$c : 1076938 --> 935758 */ \
/* variation.01$X : 384471 --> 335356 */ \
/* */ \
/* ce qui n'est pas negligeable... */
#define ENVOI_D_UNE_SEQUENCE_D_ECHAPPEMENT_VT100(sequence_specifique) \
Bblock \
CAL3(Prme4("%c%c%s%c" \
,SEQUENCE_D_ECHAPPEMENT_VT100_DEBUT_1 \
,SEQUENCE_D_ECHAPPEMENT_VT100_DEBUT_2 \
,sequence_specifique \
,SEQUENCE_D_ECHAPPEMENT_VT100_FIN \
) \
); \
Eblock \
/* Envoi d'une sequence d'echappement de type 'VT100' (introduit le 20060610104417). Voir */ \
/* 'v $xtc/InvVideo.01$c' a ce propos... */
#define ALTERNANCE_DES_PARAMETRES_DEBUT \
Bblock \
Test(IL_FAUT(alterner_les_parametres_pour_plus_de_lisibilite)) \
Bblock \
Test(EST_PAIR(NUMERO_UNIQUE_de_l_argument_possible_courant)) \
Bblock \
ENVOI_D_UNE_SEQUENCE_D_ECHAPPEMENT_VT100(sequence_d_echappement_VT100_alternance_des_parametres); \
/* Inversion d'un parametre sur deux (introduit le 20060610102859)... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Debut de l'inversion d'un parametre sur deux (introduit le 20060610112912). */
#define ALTERNANCE_DES_PARAMETRES_FIN \
Bblock \
Test(IL_FAUT(alterner_les_parametres_pour_plus_de_lisibilite)) \
Bblock \
ENVOI_D_UNE_SEQUENCE_D_ECHAPPEMENT_VT100(SEQUENCE_D_ECHAPPEMENT_VT100_INITIALISATION_GENERALE); \
/* Inversion d'un parametre sur deux (introduit le 20060610102859). Cette sequence de */ \
/* reinitialisation est faite systematiquement afin d'eviter d'eventuels problemes... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Debut de l'inversion d'un parametre sur deux (introduit le 20060610112912). */
#define gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT(__ParaTyp,__ParaLon) \
Bblock \
DEFV(CHAR,INIT(POINTERc(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT_1) \
,FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_SUITE_POUR_LES_VECTEURS \
) \
); \
DEFV(CHAR,INIT(POINTERc(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT),CHAINE_UNDEF)); \
EGAp(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT \
,chain_Aconcaten4(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT_1 \
,FORMAT_D_EDITION_DES_TITRES \
,FORMAT_D_EDITION_DES_TYPES_DES_VALEURS_VECTORIELLES \
,"{" \
) \
); \
/* Introduit le 20180318104427 pour economiser la memoire... */ \
\
ALTERNANCE_DES_PARAMETRES_DEBUT; \
/* Inversion d'un parametre sur deux (introduit le 20060610112912)... */ \
\
begin_nouveau_block \
Bblock \
DEFV(CHAR,INIC(POINTERc(format_EGAq_1__gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT) \
,chain_numero_exact(__ParaLon) \
) \
); \
DEFV(CHAR,INIC(POINTERc(format_EGAq_2__gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT),CHAINE_UNDEF)); \
DEFV(CHAR,INIC(POINTERc(format_EGAq_3__gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT),CHAINE_UNDEF)); \
EGAp(format_EGAq_2__gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT \
,chain_Aconcaten3("des " \
,format_EGAq_1__gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT \
," elements=" \
) \
); \
EGAp(format_EGAq_3__gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT \
,chain_Aconcaten2(EN_TETE_DE_LA_LISTE_DES_PREMIERES_VALEURS_D_UN_VECTEUR \
,COND(IFEQ(__ParaLon,ZERO) \
,ccCHAR("(vide)=") \
,COND(IFEQ(__ParaLon,UN) \
,ccCHAR("de l'unique element=") \
,format_EGAq_2__gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT \
) \
) \
) \
); \
\
CAL3(Prme5(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT \
,NOMBRE_DE_CHIFFRES_POUR_EDITER_LES_NUMEROS_UNIQUES_DES_ARGUMENTS_POSSIBLES \
,C_VIDE \
,tabulation_des_valeurs_affectees_aux_titres \
,format_EGAq_3__gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT \
/* Le 20010831094043 a ete introduit l'edition de la longueur courante '__ParaLon' du */ \
/* vecteur... */ \
/* */ \
/* Avant le 20060104162159, on trouvait ici : */ \
/* */ \
/* chain_numero(__ParaLon,TRPU(POSI(LO1X(__ParaLon)))) */ \
/* */ \
,__ParaTyp \
) \
); \
/* Debut de l'edition du vecteur '__ParaVal'. */ \
\
CALZ_FreCC(format_EGAq_3__gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT); \
CALZ_FreCC(format_EGAq_2__gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT); \
CALZ_FreCC(format_EGAq_1__gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT); \
Eblock \
end_nouveau_block \
\
CALZ_FreCC(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT); \
CALZ_FreCC(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT_1); \
Eblock \
/* Debut de l'edition des vecteurs de longueur variable et connue. */
#define gPROCESS_PARAMETRE_EDITION_VECTEUR_N(__ParaTyp,__ParaLon,__ParaFor,__ParaVal) \
Bblock \
DEFV(Int,INIT(premier__ParaVal,PREMIER_ELEMENT_D_UN_FICHIER)); \
DEFV(Int,INIT(dernier__ParaVal \
,LSTX(PREMIER_ELEMENT_D_UN_FICHIER \
,MIN2(__ParaLon \
,editer_la_valeur_des_parametres_d_une_commande_____longueur_maximale_des_vecteurs \
) \
) \
) \
); \
/* Premier et dernier elements du vecteur '__ParaVal' a editer. */ \
\
CALS(FgPROCESS_PARAMETRE_EDITION_VECTEUR_N_DEBUT(__ParaTyp,__ParaLon)); \
/* Debut de l'edition des vecteurs de longueur variable et connue. */ \
\
IDoIn(index__ParaVal,premier__ParaVal,dernier__ParaVal,I) \
/* On notera que '__ParaLon' peut etre nul par defaut ('v $xrv/ARITHMET.11$I __ParaLon') */ \
/* et faire donc que le 'DoIn(...)' qui precede ne soit pas execute et ne provoque donc */ \
/* d'edition de valeurs, d'ou la sortie d'un "{}" vide. */ \
/* */ \
/* Le 20060603175225, 'IDoIn(...)' a remplace 'DoIn(...)'... */ \
Bblock \
CAL3(Prme1(__ParaFor \
,IdTb1(__ParaVal,index__ParaVal,__ParaLon) \
) \
); \
/* Edition de l'element courant du vecteur '__ParaVal'. */ \
\
Test(IFNE(index__ParaVal,dernier__ParaVal)) \
Bblock \
CALS(FPrme0(",")); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
EIDoI \
\
CALS(FgPROCESS_PARAMETRE_EDITION_VECTEUR_N_FIN(__ParaLon,premier__ParaVal,dernier__ParaVal)); \
/* Fin de l'edition des vecteurs de longueur variable et connue. */ \
Eblock \
/* Edition des vecteurs de longueur variable et connue. */
#ifdef gPROCESS_PARAMETRE_EDITION_VECTEUR_N_VERSION_01
# define vgPROCESS_PARAMETRE_EDITION_VECTEUR_N(__ParaTyp,__ParaInd,__ParaFor,__ParaVal) \
Bblock \
gPROCESS_PARAMETRE_EDITION_VECTEUR_N(__ParaTyp,__ParaInd,__ParaFor,__ParaVal); \
Eblock \
/* Edition des vecteurs de longueur variable et connue. */
#Aifdef gPROCESS_PARAMETRE_EDITION_VECTEUR_N_VERSION_01
#Eifdef gPROCESS_PARAMETRE_EDITION_VECTEUR_N_VERSION_01
#ifdef gPROCESS_PARAMETRE_EDITION_VECTEUR_N_VERSION_02
# define vgPROCESS_PARAMETRE_EDITION_VECTEUR_N(__ParaTyp,__ParaInd,__ParaFor,__ParaVal) \
Bblock \
CALS(FgPROCESS_PARAMETRE_EDITION_VECTEUR_N_Float(__ParaTyp,__ParaInd,__ParaFor,__ParaVal)); \
Eblock \
/* Edition des vecteurs de longueur variable et connue. */
#Aifdef gPROCESS_PARAMETRE_EDITION_VECTEUR_N_VERSION_02
#Eifdef gPROCESS_PARAMETRE_EDITION_VECTEUR_N_VERSION_02
#define gPROCESS_PARAMETRE_EDITION_VECTEUR_N_FIN(__ParaLon,premier__ParaVal,dernier__ParaVal) \
Bblock \
Test(IFLT(NBRE(premier__ParaVal,dernier__ParaVal),__ParaLon)) \
/* Cas ou le vecteur '__ParaVal' n'est pas edite en entier (premiers elements seulement...). */ \
Bblock \
Test(IZGT(NBRE(premier__ParaVal,dernier__ParaVal))) \
Bblock \
CALS(FPrme0(",")); \
/* Cas ou au moins le premier element a ete edite... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
CALS(FPrme0("...")); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
CALS(FPrme0("}")); \
/* Fin de l'edition du vecteur '__ParaVal'. */ \
ALTERNANCE_DES_PARAMETRES_FIN; \
/* Inversion d'un parametre sur deux (introduit le 20060610102859). Cette sequence de */ \
/* reinitialisation est faite systematiquement afin d'eviter d'eventuels problemes... */ \
/* */ \
/* ATTENTION : cela doit avoir lieu avant le "\n" qui suit afin d'eviter, par exemple, des */ \
/* problemes avec l'alias 'use' lors de la recherche de parametres ('v $Falias_use ArS'). */ \
CALS(Fsauts_de_lignes(UN)); \
/* Fin de l'edition du vecteur '__ParaVal'. */ \
Eblock \
/* Fin de l'edition des vecteurs de longueur variable et connue. */
#define gPROCESS_PARAMETRE_EDITION_VECTEUR(__ParaTyp,__ParaInd,__ParaFor,__ParaVal) \
Bblock \
DEFV(CHAR,INIT(POINTERc(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR_1) \
,FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_SUITE_POUR_LES_VECTEURS \
) \
); \
DEFV(CHAR,INIT(POINTERc(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR),CHAINE_UNDEF)); \
EGAp(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR \
,chain_Aconcaten11(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR_1 \
,FORMAT_D_EDITION_DES_TITRES \
,FORMAT_D_EDITION_DES_TYPES_DES_VALEURS_VECTORIELLES \
,"{" \
,__ParaFor \
,"," \
,__ParaFor \
,"," \
,__ParaFor \
,",...}" \
,"\n" \
) \
); \
/* Introduit le 20180318104427 pour economiser la memoire... */ \
\
begin_nouveau_block \
Bblock \
DEFV(CHAR,INIC(POINTERc(format_EGAq____gPROCESS_PARAMETRE_EDITION_VECTEUR) \
,chain_Aconcaten2(EN_TETE_DE_LA_LISTE_DES_PREMIERES_VALEURS_D_UN_VECTEUR \
,"des elements (de nombre inconnu)=" \
) \
) \
); \
\
CAL3(Prme8(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR \
/* On notera qu'avant le 20000529170948, il y avait ici : */ \
/* */ \
/* chain_Aconcaten7("%s : {",...) */ \
/* */ \
/* malheureusement, l'espace situe devant "{" disparaissait lors du pre-processing par */ \
/* 'v $xcc/cpp$D/compacte.1$sed', d'ou la nouvelle ecriture avec 'chain_Aconcaten8(...)'. */ \
/* De plus et simultanement, le 20000529170948, ""%s : " a ete remplace par "%s :: " */ \
/* afin de faciliter des traitements automatique de ces editions, car, en effet, la chaine */ \
/* 'FORMAT_D_EDITION_DES_IDENTITES_UNIQUES_SUITE_POUR_LES_VECTEURS' contient "%0*d : " ; */ \
/* ainsi on peut faire la difference ente ":" et "::". */ \
,NOMBRE_DE_CHIFFRES_POUR_EDITER_LES_NUMEROS_UNIQUES_DES_ARGUMENTS_POSSIBLES \
,C_VIDE \
,tabulation_des_valeurs_affectees_aux_titres \
,format_EGAq____gPROCESS_PARAMETRE_EDITION_VECTEUR \
/* Le 20010831094043 a ete introduit l'edition de la longueur courante '__ParaLon' du */ \
/* vecteur qui, malheureusement n'est pas defini ici (cas 'Aifdef' ci-dessus)... */ \
,__ParaTyp \
,IdTb1(__ParaVal,__ParaInd,UNDEF) \
,IdTb1(__ParaVal,__ParaInd,UNDEF) \
,IdTb1(__ParaVal,__ParaInd,UNDEF) \
) \
); \
\
CALZ_FreCC(format_EGAq____gPROCESS_PARAMETRE_EDITION_VECTEUR); \
Eblock \
end_nouveau_block \
\
CALZ_FreCC(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR); \
CALZ_FreCC(format_d_edition_de_gPROCESS_PARAMETRE_EDITION_VECTEUR_1); \
Eblock \
/* Edition des vecteurs de longueur inconnue. */
#ifdef gPROCESS_PARAMETRE_EDITION_VECTEUR_VERSION_01
# define vgPROCESS_PARAMETRE_EDITION_VECTEUR(__ParaTyp,__ParaInd,__ParaFor,__ParaVal) \
Bblock \
gPROCESS_PARAMETRE_EDITION_VECTEUR(__ParaTyp,__ParaInd,__ParaFor,__ParaVal); \
Eblock \
/* Edition des vecteurs de longueur inconnue. */
#Aifdef gPROCESS_PARAMETRE_EDITION_VECTEUR_VERSION_01
#Eifdef gPROCESS_PARAMETRE_EDITION_VECTEUR_VERSION_01
#ifdef gPROCESS_PARAMETRE_EDITION_VECTEUR_VERSION_02
# define vgPROCESS_PARAMETRE_EDITION_VECTEUR(__ParaTyp,__ParaInd,__ParaFor,__ParaVal) \
Bblock \
CALS(FgPROCESS_PARAMETRE_EDITION_VECTEUR_Float(__ParaTyp,__ParaInd,__ParaFor,__ParaVal)); \
Eblock \
/* Edition des vecteurs de longueur inconnue. */
#Aifdef gPROCESS_PARAMETRE_EDITION_VECTEUR_VERSION_02
#Eifdef gPROCESS_PARAMETRE_EDITION_VECTEUR_VERSION_02
#define gPROCESS_PARAMETRE_COMPTAGE(valeur_recherchee_dans_la_liste_des_arguments) \
Bblock \
Test(PRESENT(valeur_recherchee_dans_la_liste_des_arguments)) \
/* ATTENTION, les validations qui suivent n'ont evidemment de sens que si la valeur a */ \
/* ete trouvee dans la liste des arguments... */ \
Bblock \
EGAL(IdTb1(IDENTITE_des_arguments_presents \
,INDX(numero_d_argument_courant,NUMERO_ARGUMENT_COMMANDE) \
,nombre_d_arguments_y_compris_le_nom \
) \
,IDENTITE_de_l_argument_possible_courant \
); \
/* Memorisation de l'identite de l'argument courant. On notera la relativisation de */ \
/* l'identite de 'parametre' par rapport a 'parametre_fictif_IDENTITE_des_arguments' */ \
/* destinee uniquement a eviter le message : */ \
/* */ \
/* illegal combination of pointer and integer */ \
/* */ \
/* au cas ou l'on utilise que 'aIDENTITE(parametre)'... */ \
INCK(IdTb1(compteur_reconnaissance_des_arguments_presents \
,INDX(numero_d_argument_courant,NUMERO_ARGUMENT_COMMANDE) \
,nombre_d_arguments_y_compris_le_nom \
) \
); \
/* Comptage de reconnaissance de l'argument courant... */ \
INCR(nombre_d_arguments_recuperes,I); \
/* Et enfin comptage des arguments recuperes. Autre fois, avant d'introduire 'seqI' et */ \
/* 'seqC', il y avait : */ \
/* */ \
/* INCR(nombre_d_arguments_recuperes */ \
/* ,COND(PRESENT(valeur_recherchee),I,ZERO) */ \
/* ); */ \
/* */ \
/* On notera que 'nombre_d_arguments_recuperes' peut etre utilise pour connaitre l'ordre */ \
/* (a partir de 0) des arguments recuperes (voir 'v $xrv/champs_5.1A$I' qui exploite cela). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Comptage des parametres... */
#define PERMETTRE_LES_ABREVIATIONS_DANS_gPROCESS_PARAMETRE \
VRAI
#define NE_PAS_PERMETTRE_LES_ABREVIATIONS_DANS_gPROCESS_PARAMETRE \
NOTL(PERMETTRE_LES_ABREVIATIONS_DANS_gPROCESS_PARAMETRE)
/* Pour definir l'argument 'abr' de 'gPROCESS_PARAMETRE(...)' introduit le 20030704142017. */
#define DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____PRIMAIRES \
BblockV \
__PLUS1__A__
#define FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____PRIMAIRES \
__MOINS1__A__ \
EblockV
/* Introduit le 20060208122411 par "symetrie" avec ce qui a ete fait le 20060208101231... */
/* */
/* Le passage de {VIDE,VIDE} a {__PLUS1__A__,__MOINS1__A__} a eu lieu le 20061018153006. */
/* Grace a cela, seuls les parametres apparaissant explicitement dans un '$K' sont edites */
/* sous la forme : */
/* */
/* Parametre.1. */
/* */
/* alors que tous ceux qui apparaissent via une procedure seront edites avec un numero */
/* superieur a 1... */
#define DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES \
BblockV \
__PLUS1__A__
#define FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES \
__MOINS1__A__ \
EblockV
/* Introduit le 20060208101231 dans le but de distinguer les appels aux procedures de */
/* type 'GET_ARGUMENT_?(...)' et 'PROCESS_ARGUMENT_?(...)' qui ont lieu directement */
/* (par exemple 'v $xrv/particule.10$K GET_ARGUMENT_C."palette="') et ceux qui ont lieu via */
/* une autre procedure (par exemple 'v $xrv/particule.10$K PROCESS_ARGUMENTS_GEOMETRIQUES'). */
#define CARACTERE_DE_SEPARATION_DES_COUPLES_____NOM_VALEUR_____DES_PARAMETRES \
K_EGAL \
/* Introduit le 20070221101510... */
#define gPROCESS_PARAMETRE_SYNONYME_COURANT(titre_attendu,titre_attendu_unique,premier_caractere_de_____titre_attendu) \
Bblock \
DEFV(Int,INIT(EnTete_de_sauvegardM ## chain_copie_____index_du_premier_caractere_d_une_chaineA \
,chain_copie_____index_du_premier_caractere_d_une_chaineA \
) \
); \
DEFV(CHAR,INIT(EnTete_de_sauvegardM ## chain_copie_____caractere_d_arret_secondaire \
,chain_copie_____caractere_d_arret_secondaire \
) \
); \
/* Sauvegardes (introduites le 20070221101510)... */ \
\
EGAL(chain_copie_____index_du_premier_caractere_d_une_chaineA,premier_caractere_de_____titre_attendu); \
EGAL(chain_copie_____caractere_d_arret_secondaire \
,CARACTERE_DE_SEPARATION_DES_COUPLES_____NOM_VALEUR_____DES_PARAMETRES \
); \
/* Afin de recuperer le titre courant dans la liste eventuelle des synonymes... */ \
\
EGAp(titre_attendu_unique,chain_Acopie(titre_attendu)); \
/* Recuperation du titre attendu unique (introduit le 20070221093034) parmi la liste */ \
/* eventuelle des synonymes... */ \
\
EGAL(chain_copie_____caractere_d_arret_secondaire \
,EnTete_de_sauvegardM ## chain_copie_____caractere_d_arret_secondaire \
); \
EGAL(chain_copie_____index_du_premier_caractere_d_une_chaineA \
,EnTete_de_sauvegardM ## chain_copie_____index_du_premier_caractere_d_une_chaineA \
); \
/* Restaurations (introduites le 20070221101510)... */ \
Eblock \
/* Procedure introduite le 20070228083133 pour extraire le synonyme courant... */
#nodefine liste_des_____titre_attendu_____etendu(parametre,titre_attendu) \
"parametre="titre_attendu
#define liste_des_____titre_attendu_____etendu(parametre,titre_attendu) \
titre_attendu
/* Le 20080321134343, j'ai fait des experiences consistant a tenter d'etendre la liste des */
/* titres attendus avec le nom du parametre et ce a des fins mnemotechniques. Ainsi, par */
/* exemple l'appel suivant : */
/* */
/* GET_ARGUMENT_L("standard=",les_images_sont_standards); */
/* */
/* serait automatiquement remplace par : */
/* */
/* GET_ARGUMENT_L("les_images_sont_standards=""standard=",les_images_sont_standards); */
/* */
/* ce qui serait bien pratique au niveau mnemotechnique, par exemple, lors de l'usage de la */
/* commande 'use'... */
/* */
/* Cela a conduit a la modification 'v $xcc/cpp$Z 20080321134527' car, en effet, le nom du */
/* parametre (dans '"parametre="') se trouve suivi par plusieurs espaces avant le "=". */
/* Au passage, ces espaces viennent de l'appel des procedures ; soit par exemple : */
/* */
/* #define PROCEDURE(parametre) "parametre=" */
/* */
/* L'appel : */
/* */
/* PROCEDURE(x) */
/* */
/* donnera : */
/* */
/* "x=" */
/* */
/* alors que : */
/* */
/* PROCEDURE(x */
/* ) */
/* */
/* \___10___/ */
/* */
/* donnera : */
/* */
/* "x =" */
/* */
/* \__10+1___/ */
/* */
/* soit autant d'espaces non desires qu'il y a en devant ")" (soit ici 10), plus un (qui */
/* correspond certainement au changement de ligne...). */
/* */
/* Provisoirement, le dispositif est inhibe car, en effet, il y a des parametres qui sont, */
/* non pas des variables "simples", mais des elements de structure ou autre (par exemple */
/* 'v $xig/fonct$vv$DEF PREMIER_CARACTERE_ITb0.FORMAT_CHAI_EDITION_____caractere_d_en...'), */
/* or il est choquant d'avoir des parentheses dans une chaine d'introduction d'un parametre, */
/* sachant de plus que '$CSH' n'aime pas beaucoup cela... */
/* */
/* D'ailleurs le 20080323163537, je note un autre probleme (redhibitoire ?). Ainsi, par */
/* exemple : */
/* */
/* GET_ARGUMENT_L("ADD2_SOUS=",FfxxSOUS_____utiliser_FfxADD2_a_la_place_de_FfxSOUS); */
/* GET_ARGUMENT_N("SOUS_SOUS=",FfxxSOUS_____utiliser_FfxADD2_a_la_place_de_FfxSOUS); */
/* */
/* (voir ci-apres 'v $xig/fonct$vv$DEF FfxxSOUS_____utiliser_FfxADD2_a_la_place_de_FfxSOUS') */
/* vont ainsi tous les deux donner grace a 'liste_des_____titre_attendu_____etendu(...)' : */
/* */
/* GET_ARGUMENT_L("FfxxSOUS_____utiliser_FfxADD2_a_la_place_de_FfxSOUS=""ADD2_SOUS=" */
/* ,FfxxSOUS_____utiliser_FfxADD2_a_la_place_de_FfxSOUS */
/* ); */
/* GET_ARGUMENT_N("FfxxSOUS_____utiliser_FfxADD2_a_la_place_de_FfxSOUS=""SOUS_SOUS=" */
/* ,FfxxSOUS_____utiliser_FfxADD2_a_la_place_de_FfxSOUS */
/* ); */
/* */
/* ce qui est evidemment mauvais puisque on est alors en presence d'une meme chaine */
/* ("FfxxSOUS_____utiliser_FfxADD2_a_la_place_de_FfxSOUS=") introduisant deux procedures */
/* ('GET_ARGUMENT_L(...)' et 'GET_ARGUMENT_N(...)') differentes ! */
/* */
/* Finalement, je note le 20080323165548 que tout cela est bien inutile car, en effet, il */
/* existe un dispositif controle par 'IL_FAUT(editer_le_nom_des_parametres_d_une_commande)' */
/* qui fait deja cela tres bien. Je laisse tout ce qui precede, cela pouvant donner des */
/* idees plus tard... */
#define gPROCESS_PARAMETRE__EDITION_PARAMETRES_NON_GENERES(titre_attendu) \
Bblock \
Test(EST_VRAI(c_est_la_derniere_recherche_des_parametres)) \
Bblock \
/* Jusqu'au 20180312135920, il y avait ici : */ \
/* */ \
/* Test(IL_FAUT(editer_la_valeur_des_parametres_d_une_commande)) */ \
/* Bblock */ \
/* */ \
/* mais en fait, on peut vouloir n'editer que les parametres non generes... */ \
Test(IL_FAUT(editer_le_nom_des_parametres_non_generes_d_une_commande)) \
Bblock \
CAL3(Prme5("%s%s : %s%s%s\n" \
,"# " \
,"Parametre(s) non genere(s)" \
,C_QUOTE \
,titre_attendu \
,C_QUOTE \
) \
); \
/* Edition introduite le 20180228101858... */ \
/* */ \
/* Le 20180228130923 a ete introduite a part la chaine d'espaces fin de garantir sa bonne */ \
/* utilisation car, sinon elle risque d'etre "compressee" par 'v $xcc/cpp$Z'... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit le 20180301034510 afin de reduire le volume du code genere... */
#define gPROCESS_PARAMETRE(liste_des_arguments,titre_attendu,parametre,va_defaut,FCon,FCast,sq1,sqI,fC,sqC,sqN,styp,abr,ityp,sqA,sqP) \
/* A compter du 20070221110204, 'titre_attendu' peut etre une liste de synonymes qui */ \
/* s'ecrira : */ \
/* */ \
/* "SYNONYME1=""SYNONYME2=""SYNONYME3=""..." */ \
/* */ \
/* (qui est la forme hautement conseillee car, en effet, elle facilite, par exemple, les */ \
/* recherches, tout en "symetrisant" les differents synonymes) ou encore : */ \
/* */ \
/* "SYNONYME1=SYNONYME2=SYNONYME3=..." */ \
/* */ \
/* qui est plutot deconseillee, puisqu'elle "dissymetrise" les differents synonymes... */ \
/* */ \
/* On notera que cela a conduit a supprimer ci-apres le parametre '"=="' qui etait relatif */ \
/* a 'FPrin_____supprimer_les_K_BLANCs_autour_des_K_EGAL' a cette date. Le 20070226134221 */ \
/* parametre '"=="' fut retabli grace a 'v $xig/fonct$vv$FON 20070226134226'... */ \
/* */ \
/* Les sequences "Anterieure" et "Posterieure" ont ete introduites le 20070305110736 pour */ \
/* permettre le traitement correct de 'GET_PARAMETRE_N(...)' apres l'introduction de la */ \
/* gestion des synonymes... */ \
\
&ifdef NePasGenerer_PARAMETRE____`parametre&&& \
/* Introduit le 20170627150252 afin de pouvoir ne pas generer le parametre de nom */ \
/* 'parametre'... */ \
_____FORCER_UN_CHANGEMENT_DE_LIGNE_EN_PASSE_2_____ \
_____FORCER_UN_CHANGEMENT_DE_LIGNE_EN_PASSE_2_____ \
Bblock \
CALS(FgPROCESS_PARAMETRE__EDITION_PARAMETRES_NON_GENERES(titre_attendu)); \
Eblock \
_____FORCER_UN_CHANGEMENT_DE_LIGNE_EN_PASSE_2_____ \
_____FORCER_UN_CHANGEMENT_DE_LIGNE_EN_PASSE_2_____ \
&Aifdef NePasGenerer_PARAMETRE____`parametre&&& \
Bblock \
DEFV(Int,INIT(premier_caractere_de_____titre_attendu,PREMIER_CARACTERE)); \
DEFV(Int,INIT(compteur_des_synonymes_de_____titre_attendu,ZERO)); \
DEFV(Logical,INIT(c_est_le_premier_____titre_attendu_____dans_liste_titres_synonyme,VRAI)); \
/* Afin d'identifier le premier synonyme de la liste (introduit le 20070330145617). */ \
DEFV(Logical,INIT(tous_____titre_attendu_____ont_ete_recupere_dans_liste_titres_synonymes,FAUX)); \
/* Afin de recuperer tous les synonymes de la liste (introduit le 20070221110204). */ \
DEFV(Logical,INIT(au_moins_un_titre_synonyme_a_ete_reconnu_parmi_la_liste_des_titres_synonymes,FAUX)); \
/* Afin de savoir si au moins un synonyme a ete reconnu (introduit le 20070323154106). */ \
\
EGAp(liste_des_____titre_attendu_____synonymes \
,chain_Acopie(liste_des_____titre_attendu_____etendu(parametre,titre_attendu)) \
); \
/* Liste des titres attendus synonymes (introduit le 20070325172306) afin de pouvoir etre */ \
/* utilise dans 'DETECTION_DE_PRESENCE_D_UN_ARGUMENT_OBLIGATOIRE'. */ \
/* */ \
/* ATTENTION : je note le 20070325181942 que 'liste_des_____titre_attendu_____synonymes' */ \
/* ne peut etre utilise ci-apres a la place de 'titre_attendu' et ce a cause, semble-t-il, */ \
/* de 'v $xcc/cpp$Z w52' qui recherche les parametres doublement definis. Il convient donc */ \
/* de laisser 'titre_attendu' et 'liste_des_____titre_attendu_____synonymes' tels qu'ils */ \
/* sont utilises actuellement... */ \
/* */ \
/* Le 20070330091147 cette chaine est devenue globale afin de simplifier l'implantation */ \
/* de 'grouper_les_synonymes_des_parametres_d_une_commande'... */ \
\
Tant(EST_FAUX(tous_____titre_attendu_____ont_ete_recupere_dans_liste_titres_synonymes)) \
Bblock \
DEFV(CHAR,INIT(POINTERc(titre_attendu_unique_parmi_une_liste_de_titres_synonymes),CHAINE_UNDEF)); \
/* Titre attendu unique (introduit le 20070221093034). */ \
\
INCK(compteur_des_synonymes_de_____titre_attendu); \
/* Comptage des synonymes (introduit le 20070325174643) afin de pouvoir adapter le message */ \
/* edite dans 'DETECTION_DE_PRESENCE_D_UN_ARGUMENT_OBLIGATOIRE'... */ \
\
EGAp(titre_attendu_unique_parmi_une_liste_de_titres_synonymes \
,FgPROCESS_PARAMETRE_SYNONYME_COURANT(liste_des_____titre_attendu_____etendu(parametre,titre_attendu) \
,premier_caractere_de_____titre_attendu \
) \
); \
\
EGAL(premier_caractere_de_____titre_attendu \
,chain_copie_____successeur_de_l_index_du_dernier_caractere_d_une_chaineA \
); \
/* Pour preparer le 'chain_Acopie(...)' eventuel suivant... */ \
\
Test(EST_VRAI(chain_copie_____la_chaineA_a_ete_copiee_jusqu_au_END_OF_CHAIN)) \
Bblock \
EGAL(tous_____titre_attendu_____ont_ete_recupere_dans_liste_titres_synonymes,VRAI); \
/* Tous les synonymes ont apparemment ete recuperes (introduit le 20070221110204...). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
begin_nouveau_block \
Bblock \
BLOC(sqA); \
/* Introduit le 20070305110736... */ \
\
g1PROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu_unique_parmi_une_liste_de_titres_synonymes \
,parametre \
,va_defaut \
,FCon \
,FCast \
,sq1 \
,sqI \
,fC \
,sqC \
,sqN \
,styp \
,abr \
,ityp \
); \
\
BLOC(sqP); \
/* Introduit le 20070305110736... */ \
Eblock \
end_nouveau_block \
\
CALZ_FreCC(titre_attendu_unique_parmi_une_liste_de_titres_synonymes); \
/* Nettoyage... */ \
\
EGAL(c_est_le_premier_____titre_attendu_____dans_liste_titres_synonyme,FAUX); \
/* Systematiquement, on n'est plus sur le premier (et eventuellement seul) synonyme... */ \
Eblock \
ETan \
\
CALZ_FreCC(liste_des_____titre_attendu_____synonymes); \
/* Introduit le 20070325172306... */ \
\
/* Le 20081113173427, j'ai tente d'introduire ici : */ \
/* */ \
/* Test(EST_VRAI(c_est_la_premiere_recherche_des_parametres)) */ \
/* Bblock */ \
/* INCR(nombre_d_arguments_possibles_regroupes_par_classe...,I); */ \
/* Eblock */ \
/* ATes */ \
/* Bblock */ \
/* Eblock */ \
/* ETes */ \
/* */ \
/* Mais, le 20081115105359 j'ai du y renoncer ('v $xig/fonct$vv$FON 20081113173432')... */ \
\
INCR_INDEX_DES_ARGUMENTS_POSSIBLES(numero_de_l_argument_possible_courant__en_tenant________compte_des_synonymes \
,"debordement de la liste des arguments possibles (3)" \
); \
/* Numero de l'argument possible suivant (introduit le 20070820101714)... */ \
Eblock \
&Eifdef NePasGenerer_PARAMETRE____`parametre&&& \
\
/* Procedure de recuperation d'un parametre quelconque avec mise en place prealable de sa */ \
/* valeur par defaut, puis comptage des occurences valides, et enfin, execution d'une */ \
/* sequence specifique d'actions (qui seront en general fonction du parametre...) avec */ \
/* la possibilite de forcer l'execution de 'sqC' au "dernier tour". La procedure */ \
/* intermediaire 'g1PROCESS_PARAMETRE(...)' a ete introduite le 20070221090349 dans le */ \
/* but futur (a cette date...) de simplifier la definition des synonymes. On notera au */ \
/* passage qu'en fait 'g1PROCESS_PARAMETRE(...)' est l'ancienne 'gPROCESS_PARAMETRE(...)'. */ \
/* La gestion des titres synonymes fut finalement introduite le 20070221110204... */
#define g1PROCESS_PARAMETRE(liste_des_arguments,titre_attendu,parametre,va_defaut,FCon,FCast,seq1,seqI,fC,seqC,seqN,styp,abr,ityp) \
/* ATTENTION, le parametre 'valeur_par_defaut' a change de nom le 20010330100201 (en */ \
/* devenant partout 'va_par_defaut') afin de raccourcir la longueur des '#define' qui */ \
/* l'utilisaient, et ce a cause de l'introduction du nouveau parametre 'styp' (qui avec */ \
/* un peu plus de place aurait du s'appeler 'size_type'...). De meme, le 20030704142017 */ \
/* 'va_par_defaut' a change de nom (devenant partout 'va_defaut') pour la meme raison */ \
/* (introduction de l'argument 'abr' ci-dessus...). */ \
/* */ \
/* La signification des quatre sequences est la suivante : */ \
/* */ \
/* 'seq1' : AVANT la toute premiere tentative de recuperation de 'parametre', */ \
/* 'seqI' : APRES chaque tentative de recuperation de 'parametre', qu'elle soit */ \
/* fructueuse ou pas, */ \
/* 'seqC' : APRES chaque recuperation fructueuse de 'parametre', */ \
/* 'seqN' : APRES la toute derniere tentative de recuperation de 'parametre'. */ \
/* */ \
/* sachant que 'seq1' et 'seqN' ont ete introduite ici (et partout ailleurs ou cela etait */ \
/* necessaire...) le 20060214094954... */ \
/* */ \
/* On notera qu'avant le 20070221090349 la procedure ''g1PROCESS_PARAMETRE(...)' s'appelait */ \
/* en fait 'gPROCESS_PARAMETRE(...)'. Ce changement de nom fut destine a simplifier la mise */ \
/* en place de la gestion simplifiee des synonymes... */ \
/* */ \
/* ATTENTION, 'au_moins_un_titre_synonyme_a_ete_reconnu_parmi_la_liste_des_titres_synonymes' */ \
/* fait que 'g1PROCESS_PARAMETRE(...)' doit etre utilise via 'gPROCESS_PARAMETRE(...)' */ \
/* uniquement (introduit le 20070323154106)... */ \
/* */ \
/* Le 20100320104703 fut introduit l'argument 'FCast' destine a caster la fonction de */ \
/* conversion 'FCon' dans un futur plus ou moins lointain... */ \
Bblock \
\
DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
DEFV(Logical,INIT(valeur_recherchee_dans_un_setenv,FAUX)); \
DEFV(Logical,INIT(valeur_recherchee_dans_la_liste_des_arguments,FAUX)); \
/* Afin de savoir si l'on a trouve la valeur cherchee soit dans un 'setenv', soit dans la */ \
/* liste des arguments 'liste_des_arguments'. */ \
\
DEFV(CHAR,INIT(POINTERc(argument_courant_apres_conversions_majuscules_minuscules_et_prefixage_eventuels_1) \
,CHAINE_UNDEF \
) \
); \
/* Argument courant apres les eventuelles conversions majuscules-minuscules et inversement. */ \
DEFV(CHAR,INIT(POINTERc(titre_attendu_apres_conversions_eventuelles_majuscules_minuscules),CHAINE_UNDEF)); \
/* Titre attendu apres les eventuelles conversions majuscules-minuscules et inversement. */ \
\
EGAL(niveau_des_gPROCESS_PARAMETRE,__COMPTEUR__A__); \
/* Introduit le 20060208101231 dans le but de distinguer les appels aux procedures de */ \
/* type 'GET_ARGUMENT_?(...)' et 'PROCESS_ARGUMENT_?(...)' qui ont lieu directement */ \
/* (par exemple 'v $xrv/particule.10$K GET_ARGUMENT_C."palette="') et ceux qui ont lieu via */ \
/* une autre procedure (par exemple 'v $xrv/particule.10$K PROCESS_ARGUMENTS_GEOMETRIQUES'). */ \
\
EGAL(pointeurV_parametre,aIDENTITE(parametre)); \
EGAL(pointeurC_parametre,pointeurV_parametre); \
/* Tout ceci afin de mettre l'identite du parametre dans une unite commune... */ \
/* */ \
/* Le 20040324112253 je remarque un defaut de cette methode qui grace a la liste */ \
/* 'IDENTITE_des_arguments_possibles' permet de detecter les synonymes. En effet, */ \
/* comme c'est le cas avec 'v $xcg/FloatHexa$vv$K nombre_flottant_en_Float' (pour les */ \
/* parametres {"x=","xd=","i2="}, lorsque des variables sont definies avec des types du */ \
/* type 'FloatInt', des composantes differentes de la structure peuvent correspondre a */ \
/* la meme adresse en memoire ; ainsi, pour 'FloatInt', les elements 'VersionFlottante' */ \
/* et 'VersionInt_1' ont necessairement la meme adresse memoire, d'ou la declaration de */ \
/* synonymie des parametres {"x=","xd=","i2="} (pour 'SYSTEME_APC_Linux' ; en ce qui */ \
/* concerne les autres SYSTEMEs, il s'agira de {"x=","xd=","i1="}). On notera qu'a cette */ \
/* date, seul 'v $xcg/FloatHexa$vv$K' semble concerne. Une solution pourrait etre de */ \
/* memoriser pour chaque 'parametre' l'adresse de 'FCon(...)' utilisee... */ \
/* Le 20040324131607, je note que cette solution n'est pas la bonne a cause des deux */ \
/* fonctions 'FconversionL(...)' et 'FconversionN(...)' qui sont destinees a declarer des */ \
/* "synonymes complementaires -logiquement-" et qui sont evidemment deux fonctions */ \
/* differentes et donc d'adresses differentes. La solution consistant a memoriser la */ \
/* taille du type (parametre 'styp' de 'gPROCESS_PARAMETRE(...)') n'est pas bonne non plus */ \
/* car plusieurs types ont la meme taille. En fait, il conviendrait peut-etre d'ajouter */ \
/* une information actuellement manquante... */ \
\
CALS(FgPROCESS_PARAMETRE_DEBUT(titre_attendu,styp,SIZE_GENERAL(parametre),ityp)); \
/* Gestion de l'identite des parametres destinee principalement a identifier les synonymes, */ \
/* puis edition eventuelle du titre des "Parametres" apres que la variable */ \
/* 'NUMERO_UNIQUE_de_l_argument_possible_courant' ait ete mise a jour et enfin validation */ \
/* eventuelle du type du parametre courant... */ \
\
gPROCESS_PARAMETRE_ENTREE_PAR_setenv(titre_attendu,parametre,va_defaut,FCon); \
/* Entree eventuelle des parametres via des 'setenv'... */ \
\
EGAp(titre_attendu_apres_conversions_eventuelles_majuscules_minuscules \
,chain_Acopie_avec_conversions_possibles_majuscules_minuscules_pour_un_titre_attendu(titre_attendu) \
); \
/* Titre attendu apres les eventuelles conversions majuscules-minuscules et inversement */ \
/* (introduit le 20010621143912). */ \
/* */ \
/* ATTENTION : cet 'EGAL(...)' est utilise dans 'v $xcc/cpp$Z TiTrE_AtTeNdU' afin de */ \
/* detecter les parametres multiplement definis. En effet, l'ensemble de ces 'EGAL(...)'s */ \
/* dans un '$K' donne l'ensemble des 'titre_attendu's qui y sont definis... */ \
/* */ \
/* Optimise avec 'v $xig/fonct$vv$FON 20221030171351' le 20221030171346, ce qui reduit les */ \
/* '$c's et les '$X's (ainsi '$xcg/ADD2.01$X' est passe de 1389944 a 1381992 sur '$LACT1B" */ \
/* et '$xrv/load_image$c de 3252384 a 3196709...). */ \
\
EGAL(argument_courant_apres_conversions_majuscules_minuscules_et_prefixage_eventuels_1 \
,FgPROCESS_PARAMETRE_RECUPERATION_ET_TRANSFORMATION(liste_des_arguments,numero_d_argument_courant,abr) \
); \
\
_____SEQ_EFFACABLE_01_gPROCESS_PARAMETRE_(Test(EST_VRAI(c_est_la_premiere_recherche_des_parametres)) \
Bblock \
BLOC(seq1); \
/* Execution inconditionnelle, avant la premiere tentative de recuperation du parametre */ \
/* (introduit le 20060214094954). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
)_SEQ_EFFACABLE_01_gPROCESS_PARAMETRE_____ \
\
/* ATTENTION : depuis l'introduction de 'format_EGAq____...' et jusqu'au 20180326211416, */ \
/* il y avait ici : */ \
/* */ \
/* begin_nouveau_block */ \
/* Bblock */ \
/* DEFV(CHAR,INIC(POINTERc(format_EGAq____g1PROCESS_PARAMETRE) */ \
/* (...) */ \
/* ); */ \
/* */ \
/* mais cela perturbait 'v $xcc/cpp$Z 20060203140334' puisqu'alors les lignes contenant */ \
/* une 'FconversionL/(...)' ne contenait pas au debut un "{". D'ou ce deplacement... */ \
\
begin_nouveau_block \
Bblock \
DEFV(CHAR,INIC(POINTERc(format_EGAq____g1PROCESS_PARAMETRE) \
,chain_Aconcaten2 \
(COND(EST_FAUX(l_argument_possible_courant_est_un_synonyme_d_argument_anterieur) \
,ccCHAR(NOM_DES_VALEURS_PREMIER_SYNONYME(parametre)) \
,ccCHAR(C_VIDE) \
) \
,NOM_DES_VALEURS_SYNONYMES_SUIVANTS \
) \
) \
); \
\
begin_nouveau_block \
Bblock \
/* A cause de 'v $xcc/cpp$Z 20060203140334', il est imperatif d'imbriquer deux */ \
/* 'begin_nouveau_block's afin que les lignes contenant une 'Fconversion?/(...)' */ \
/* contiennent au debut un "{"... */ \
EGAL(parametre \
,FCast \
(FCon(argument_courant_apres_conversions_majuscules_minuscules_et_prefixage_eventuels_1 \
,titre_attendu_apres_conversions_eventuelles_majuscules_minuscules \
,va_defaut \
,Fconversion_EditeValeur(c_est_le_premier_____titre_attendu_____dans_liste_titres_synonyme) \
/* Mis sous cette forme "compacte" le 20221029160723 afin de reduire la longueur des '$c's */ \
/* et des '$X's (ainsi '$xcg/ADD2.01$X' est passe de 1410176 a 1389944 sur '$LACT1B" et */ \
/* '$xrv/load_image$c de 3390549 a 3252384...). */ \
,COND(EST_VRAI(Fconversion_NomEventuelValeur()) \
/* Mis sous cette forme "compacte" le 20221029160723 afin de reduire la longueur des '$c's */ \
/* et des '$X's (ainsi '$xcg/ADD2.01$X' est passe de 1410176 a 1389944 sur '$LACT1B" et */ \
/* '$xrv/load_image$c de 3390549 a 3252384...). */ \
,format_EGAq____g1PROCESS_PARAMETRE \
,ccCHAR(C_VIDE) \
) \
/* Edition eventuelle du nom du parametre encadre par des quadruples '[...]'. Ceci est du */ \
/* au fait que '$xcp/cpp$X' introduit des espaces au bout de la chaine "parametre" ; ceci */ \
/* permet de les eliminer facilement ('v $xcc/cpp$Z BlancParametres', ce dernier etant */ \
/* aussi responsable de la mise en place de "vv ':parametre:'")... */ \
,INDICATEUR_DE_TYPE_____A_R \
/* La chaine 'INDICATEUR_DE_TYPE_____A_R' a ete introduite le 20060310095832 suite a la */ \
/* modification 'v $xig/fonct$vv$FON 20060310093722' relative a l'introduction du nouvel */ \
/* argument 'A_R' des fonctions 'Fconversion?(...)'. */ \
/* */ \
/* On notera que cet indicateur est en fait gere par 'v $xcc/cpp$Z Indicateur_____A_R'... */ \
) \
) \
); \
Eblock \
end_nouveau_block \
/* A cause de 'v $xcc/cpp$Z 20060203140334', il est imperatif d'imbriquer deux */ \
/* 'begin_nouveau_block's afin que les lignes contenant une 'Fconversion?/(...)' */ \
/* contiennent au debut un "{"... */ \
\
CALZ_FreCC(format_EGAq____g1PROCESS_PARAMETRE); \
/* ATTENTION : depuis l'introduction de 'format_EGAq____...' la liberation de */ \
/* 'format_EGAq____g1PROCESS_PARAMETRE' a du etre mise ici et ce a cause de */ \
/* 'v $xcc/cpp$Z 20060203140334' puisqu'alors les lignes contenant une 'FconversionL/(...)' */ \
/* ne contenait pas au debut un "{". D'ou cette localisation... */ \
Eblock \
end_nouveau_block \
/* On notera que l'on pourrait etendre cette notion en transmettant une partie des */ \
/* parametres d'une commande via des variables 'setenv'. Il suffirait donc d'ajouter */ \
/* ici un code du type : */ \
/* */ \
/* FCon(Gvar(titre_attendu),...) */ \
/* */ \
/* malheureusement l'impossiblite de definir des variables 'setenv' dont le nom se */ \
/* termine par un signe "=" ('v $FCshrc PROCESS_PARAMETRE') fait que cela n'est pas */ \
/* implemente (provisoirement ?) le 19980417162204. Mais, le 19980420092917, j'avais une */ \
/* solution satisfaisante, d'ou le code qui precede... */ \
\
/* ATTENTION : depuis l'introduction de 'format_EGAq____...' et jusqu'au 20180326211416, */ \
/* il y avait ici : */ \
/* */ \
/* Eblock */ \
/* end_nouveau_block */ \
/* */ \
/* mais cela perturbait 'v $xcc/cpp$Z 20060203140334' puisqu'alors les lignes contenant */ \
/* une 'Fconversion?(...)' ne contenait pas au debut un "{". D'ou ce deplacement... */ \
\
EGAL(valeur_recherchee_dans_la_liste_des_arguments,valeur_recherchee); \
/* Memorisation du compte-rendu... */ \
\
CALZ_FreCC(argument_courant_apres_conversions_majuscules_minuscules_et_prefixage_eventuels_1); \
/* Le 20051024130450, je note que ce 'FreCC(...)' serait le responsable du probleme decrit */ \
/* dans 'v $xig/fonct$vv$FON 20051019113924'. Mais a cette date, je ne comprends pas la */ \
/* cause du probleme. En tout cas, en le supprimant ou en le rendant conditionnel (afin */ \
/* de ne pas trop toucher au code), le probleme disparait (ou reapparait a volonte lors */ \
/* d'une implementation conditionnelle) ; a titre d'exemple, j'ai utilise : */ \
/* */ \
/* IFEQ(tabulation_des_valeurs_affectees_aux_titres */ \
/* ,TABULATION_DES_VALEURS_AFFECTEES_AUX_TITRES */ \
/* ) */ \
/* */ \
/* ce qui permettait d'activer ou de desactiver le 'FreCC(...)' via "TabulationParametres=". */ \
CALZ_FreCC(titre_attendu_apres_conversions_eventuelles_majuscules_minuscules); \
/* Nettoyages (introduits le 20030705121308). */ \
\
Test(IFOU(PRESENT(valeur_recherchee_dans_un_setenv) \
,PRESENT(valeur_recherchee_dans_la_liste_des_arguments) \
) \
) \
/* Le test de 'valeur_recherchee_dans_un_setenv' a ete introduit le 20080918131207 car, */ \
/* en effet, il manquait... */ \
Bblock \
EGAL(au_moins_un_titre_synonyme_a_ete_reconnu_parmi_la_liste_des_titres_synonymes,VRAI); \
/* Introduit le 20070323154106... */ \
INCR(ITb1(UTILISATION_des_arguments_possibles \
,INDX(numero_de_l_argument_possible_courant__en_tenant________compte_des_synonymes \
,PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
) \
) \
,I \
); \
/* Comptage d'utilisation (ou "reference") de l'argument possible courant (introduit */ \
/* le 20070820113014). */ \
/* */ \
/* C'est 'numero_de_l_argument_possible_courant__en_tenant________compte_des_synonymes' */ \
/* qui indexe et non pas 'NUMERO_de_l_argument_possible_courant' car, en effet, ce dernier */ \
/* n'est incremente que si 'EST_VRAI(c_est_la_derniere_recherche_des_parametres' */ \
/* semble-t-il... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
BLOC(seqI); \
/* Execution inconditionnelle, apres recuperation du parametre, d'une sequence specifique */ \
/* de post-traitement. Cette execution a donc lieu meme si le parametre n'est pas recupere. */ \
\
_____SEQ_EFFACABLE_01_gPROCESS_PARAMETRE_(Test(I3OU(PRESENT(valeur_recherchee_dans_un_setenv) \
,PRESENT(valeur_recherchee_dans_la_liste_des_arguments) \
,I3ET(EST_VRAI(c_est_la_derniere_recherche_des_parametres) \
,IFET(ABSENT(valeur_recherchee_dans_un_setenv) \
,ABSENT(valeur_recherchee_dans_la_liste_des_arguments) \
) \
,EST_VRAI(fC) \
) \
) \
) \
/* La derniere condition liee a 'fC' a ete introduite le 20000207110651. Elle est expliquee */ \
/* dans 'v $xrv/ARITHMET.11$I 20000207110651'. */ \
Bblock \
BLOC(seqC); \
/* Execution conditionnelle, apres recuperation du parametre, d'une sequence specifique */ \
/* de post-traitement. Cette execution n'a donc lieu que si le parametre a ete recupere. */ \
/* ATTENTION, dans le cas ou la valeur a ete trouvee dans un 'setenv', le fonctionnement */ \
/* de 'BLOC(seqC)' peut etre incorrect si par malheur cette sequence utilise des */ \
/* parametres non encore introduits ; c'est par exemple le cas des lectures de fichiers */ \
/* telle celle de 'v $xrv/permute.11$K PROCESS_ARGUMENT_C' ou le nombre d'elements des */ \
/* fichiers ne peut etre defini en tant qu'argument preliminaire car, en effet, l'argument */ \
/* 'setenv=VRAI' doit etre le premier ('NUMERO_PREMIER_ARGUMENT') ; la seule solution dans */ \
/* ce cas est que ce nombre (appele ici "ne=") soit lui-aussi une variable d'environnement */ \
/* (definie par 'setenv'). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
)_SEQ_EFFACABLE_01_gPROCESS_PARAMETRE_____ \
/* Le dispositif 'SEQ_EFFACABLE_01_gPROCESS_PARAMETRE' a ete introduit le */ \
/* 20000704165110 ; il a permis un gain appreciable dans la taille des fichiers '$c' */ \
/* (ainsi, par exemple, '$xrv/variation.01$c' est passe de 458626 a 428991 octets...). */ \
/* En effet, la plupart du temps, la sequence 'seqC' est vide ; il est alors */ \
/* evident que le 'Test(...)' devient inutile. La forme a changee le 20000719120627 par */ \
/* suppression d'un caractere ":" qui precedait puis suivait la chaine correspondante. */ \
/* En effet, cela perturbait le fonctionnement de 'v $xcc/cpp$Z Mode_cpp_sub'... */ \
\
_____SEQ_EFFACABLE_01_gPROCESS_PARAMETRE_(Test(EST_VRAI(c_est_la_derniere_recherche_des_parametres)) \
Bblock \
BLOC(seqN); \
/* Execution inconditionnelle, apres la derniere tentative de recuperation du parametre */ \
/* (introduit le 20060214094954). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
)_SEQ_EFFACABLE_01_gPROCESS_PARAMETRE_____ \
\
&ifdef __ParaVal&&& \
/* On notera que le 20000719161303, toutes les structures : */ \
/* */ \
/* &DIRECTIVE SYMBOLE& */ \
/* */ \
/* ont ete remplacees par : */ \
/* */ \
/* &DIRECTIVE SYMBOLE&&& */ \
/* */ \
/* a cause de 'v $xcc/cpp$D/PASSE_4.Par1$sub PASSE_4' car, en effet, pour ce fichier, */ \
/* etant donne que '$xcp/substitue.01$X' fait des recherches a cheval sur plusieurs lignes, */ \
/* il traitait par exemple des structures du type : */ \
/* */ \
/* &define SYMBOLE */ \
/* (...) */ \
/* &define SYMBOLE */ \
/* */ \
/* en manipulant tout ce qui se trouvait entre les deux caracteres "&". Enfin, on ne peut */ \
/* utiliser '&&' (et donc il faut prendre '&&&') a cause de l'operateur '&&' du langage C... */ \
Test(IFET(IL_FAUT(editer_la_valeur_des_parametres_d_une_commande) \
,EST_VRAI(c_est_la_derniere_recherche_des_parametres) \
) \
) \
Bblock \
\
& ifdef __ParaTyp&&& \
\
& ifdef __ParaFor&&& \
\
& ifdef __ParaInd&&& \
\
& ifdef __ParaLon&&& \
/* On notera que '__ParaLon' peut etre nul par defaut ('v $xrv/ARITHMET.11$I __ParaLon') */ \
/* et faire donc que le 'DoIn(...)' qui va suivre ne soit pas execute et ne provoque donc */ \
/* d'edition de valeurs, d'ou la sortie d'un "{}" vide. */ \
\
vgPROCESS_PARAMETRE_EDITION_VECTEUR_N(__ParaTyp,__ParaLon,__ParaFor,__ParaVal); \
/* Edition des vecteurs de longueur variable et connue. */ \
/* */ \
/* ATTENTION : l'argument '__ParaVal' doit etre le dernier de la liste au cas ou '__ParaTyp' */ \
/* ne serait pas 'TYPE_FORMAT_FLOT', ce qui aurait pour consequence de decaler la liste des */ \
/* arguments. Dans ce cas un message d'erreur sera edite et il est alors suggerer de revenir */ \
/* a 'gPROCESS_PARAMETRE_EDITION_VECTEUR_N_VERSION_01', solution qui n'est pas typee... */ \
\
& undef __ParaLon&&& \
\
& Aifdef __ParaLon&&& \
vgPROCESS_PARAMETRE_EDITION_VECTEUR(__ParaTyp,__ParaInd,__ParaFor,__ParaVal); \
/* Edition des vecteurs de longueur inconnue. */ \
/* */ \
/* ATTENTION : l'argument '__ParaVal' doit etre le dernier de la liste au cas ou '__ParaTyp' */ \
/* ne serait pas 'TYPE_FORMAT_FLOT', ce qui aurait pour consequence de decaler la liste des */ \
/* arguments. Dans ce cas un message d'erreur sera edite et il est alors suggerer de revenir */ \
/* a 'gPROCESS_PARAMETRE_EDITION_VECTEUR_VERSION_01', solution qui n'est pas typee... */ \
& Eifdef __ParaLon&&& \
\
& undef __ParaInd&&& \
\
& Aifdef __ParaInd&&& \
PRINT_ERREUR("une utilisation anormale des variables '__Para...' est faite (1 : 'Ind')"); \
& Eifdef __ParaInd&&& \
\
& undef __ParaFor&&& \
\
& Aifdef __ParaFor&&& \
PRINT_ERREUR("une utilisation anormale des variables '__Para...' est faite (2 : 'For')"); \
& Eifdef __ParaFor&&& \
\
& undef __ParaTyp&&& \
\
& Aifdef __ParaTyp&&& \
PRINT_ERREUR("une utilisation anormale des variables '__Para...' est faite (3 : 'Typ')"); \
& Eifdef __ParaTyp&&& \
\
/* Edition d'une valeur complementaire definie par {__ParaFor,__ParaVal,__ParaInd}, triplet */ \
/* (puis quadruplet...) defini ailleurs (apres l'appel a 'Fload_fichier_formatte_Float(...)' */ \
/* en general). Il s'agit en general d'un vecteur qui est le contenu en memoire d'un fichier */ \
/* dont le nom est en cours de traitement tres certainement. Ce dispositif a ete ajoute le */ \
/* 20000125095156, car il est fort utile ; il a ete complete le 20000201164705 par */ \
/* '__ParaTyp' (d'ou l'appellation "quadruplet"). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
& undef __ParaVal&&& \
\
&Aifdef __ParaVal&&& \
&Eifdef __ParaVal&&& \
\
CALS(FgPROCESS_PARAMETRE_COMPTAGE(valeur_recherchee_dans_la_liste_des_arguments)); \
/* Comptage des parametres... */ \
\
INCR_INDEX_DES_ARGUMENTS_POSSIBLES(numero_de_l_argument_possible_courant__en_ne_tenant_pas_compte_des_synonymes \
,"debordement de la liste des arguments possibles (4)" \
); \
/* Numero de l'argument possible suivant (introduit le 20070820101714)... */ \
\
FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
Eblock \
/* Procedure de recuperation d'un parametre quelconque avec mise en place prealable de sa */ \
/* valeur par defaut, puis comptage des occurences valides, et enfin, execution d'une */ \
/* sequence specifique d'actions (qui seront en general fonction du parametre...) avec */ \
/* la possibilite de forcer l'execution de 'seqC' au "dernier tour" (introduit le */ \
/* 20000207110651). */ \
/* */ \
/* A la fin de 202210, des modifications importantes ont ete mises en oeuvre concernant */ \
/* cette procedure 'g1PROCESS_PARAMETRE(...)' et destinees a reduire la taille des '$c's */ \
/* et des '$X's generes : */ \
/* */ \
/* v '$xil/defi_c1$vv$DEF 20221028181016' */ \
/* */ \
/* v '$xig/fonct$vv$DEF 20221029160723' */ \
/* v '$xig/fonct$vv$DEF 20221030171346' */ \
/* */ \
/* v '$xig/fonct$vv$FON 20221028135041' */ \
/* v '$xig/fonct$vv$FON 20221028173819' */ \
/* v '$xig/fonct$vv$FON 20221028182436' */ \
/* v '$xig/fonct$vv$FON 20221029160630' */ \
/* v '$xig/fonct$vv$FON 20221030171351' */ \
/* v '$xig/fonct$vv$FON 20221101101020' */ \
/* v '$xig/fonct$vv$FON 20221101102938' */ \
/* */ \
/* Ainsi, le 20221031101214 je note sur '$LACT1B' que la taille de '$xrv/particule.10$X' */ \
/* est passee de 2862760 a 2727784 octets, soit un gain de 134976 octets (soit ~5%)... */ \
/* En ce qui concerne la taille de '$xcg/MOYE.01$X' (plus petite que ''$xrv/particule.10$X') */ \
/* est passee de 1458600 a 1381992 octets, soit un gain de 76608 octets (soit ~5%)... ) */ \
/* */ \
/* Le 20221101103441, la taille de '$xrv/particule.10$X' est passee a 2645912 octets, */ \
/* soit au total un gain de 216848 octets (soit ~8%) et celle de '$xcg/MOYE.01$X' est */ \
/* passee a 1365856 octets, soit au total un gain de 92744 octets (soit ~6%)... */ \
/* */ \
/* On consultera avec profit 'v $xig/$Fnota .xcc.RecompileAll.Z.20221101111630' pour */ \
/* voir l'ensemble des gains sur '$CMAP28' (ex "republique")... */
#define PROCESS_PARAMETRE(liste_des_arguments,titre_attendu,parametre,va_defaut,FCon,FCast,seq1,seqI,seqC,seqN,styp,ityp,seqA,seqP) \
/* Les sequences "Anterieure" et "Posterieure" ont ete introduites le 20070305110736 pour */ \
/* permettre le traitement correct de 'GET_PARAMETRE_N(...)' apres l'introduction de la */ \
/* gestion des synonymes... */ \
/* */ \
/* La signification des six sequences est la suivante : */ \
/* */ \
/* 'seq1' : AVANT la toute premiere tentative de recuperation de 'parametre', */ \
/* 'seqA' : AVANT chaque tentative de recuperation de 'parametre', qu'elle soit */ \
/* fructueuse ou pas, */ \
/* 'seqP' : APRES chaque tentative de recuperation de 'parametre', qu'elle soit */ \
/* fructueuse ou pas, */ \
/* 'seqI' : APRES chaque tentative de recuperation de 'parametre', qu'elle soit */ \
/* fructueuse ou pas, */ \
/* 'seqC' : APRES chaque recuperation fructueuse de 'parametre', */ \
/* 'seqN' : APRES la toute derniere tentative de recuperation de 'parametre'. */ \
/* */ \
/* On notera donc, semble-t-il, la redondance entre 'seqP' et 'seqI'... */ \
Bblock \
gPROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre \
,va_defaut \
,FCon \
,FCast \
,seq1 \
,seqI \
,NE_PAS_FORCER_sequenceC_DANS_gPROCESS_PARAMETRE_LORS_DE_LA_DERNIERE_RECHERCHE \
,seqC \
,seqN \
,styp \
,NE_PAS_PERMETTRE_LES_ABREVIATIONS_DANS_gPROCESS_PARAMETRE \
,ityp \
,seqA \
,seqP \
); \
Eblock \
/* Procedure de recuperation d'un parametre quelconque avec mise en place prealable de sa */ \
/* valeur par defaut, puis comptage des occurences valides, et enfin, execution d'une */ \
/* sequence specifique d'actions (qui seront en general fonction du parametre...). */ \
/* */ \
/* Le 20030704142017, les abreviations ont ete interdites dans la definition de */ \
/* de 'PROCESS_PARAMETRE(...)' et autorisees pour 'PROCESF_ARGUMENT_C(...)' uniquement... */
#define GET_PARAMETRE(liste_des_arguments,titre_attendu,parametre,va_defaut,FCon,FCast,styp,ityp) \
Bblock \
PROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre \
,va_defaut \
,FCon \
,FCast \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
,styp \
,ityp \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
/* Procedure de recuperation d'un parametre quelconque avec mise en place prealable de sa */ \
/* valeur par defaut, puis comptage des occurences valides. */
#define NE_PAS_VALIDER_UN_styp \
ZERO \
/* Afin de ne pas faire certaines validations de 'styp_?' ; on choisit une valeur negative */ \
/* qui est donc impossible pour une taille quelconque... */ \
/* */ \
/* Le 20111112092959, la valeur negative anterieure 'NEGA(UNITE)' a ete remplace par une */ \
/* valeur tout aussi impossible ('ZERO'). Cela fut rendu necessaire brutalement sur */ \
/* '$LACT19' a cette date, en etant lie visiblement a un probleme de conversion entre 'Int' */ \
/* et 'vrai_Int_de_base'. Le parametre 'NE_PAS_VALIDER_UN_styp' avait alors la valeur */ \
/* 4294967295 qui n'etait donc pas negative. Cela doit etre du a un "upgrade" du systeme */ \
/* entre la derniere recompilation ('v $Dhistory/LACT19$D/20111102142038 20111031153918') */ \
/* et le 20111112092959 ('v $Dhistory/LACT19$D/20111102165540.root apt-get.upgrade' tres */ \
/* certainement...). */
#define styp_K \
size_CHAR
#define styp_C \
NE_PAS_VALIDER_UN_styp
#define styp_L \
size_Logical
#define styp_N \
styp_L
#define styp_I \
size_Int
#define styp_F \
size_Float
#define styp_P \
size_p
/* Definitions destinees a limiter la longueur des appels a 'PROCESS_PARAMETRE(...)' et a */
/* 'GET_PARAMETRE(...)'. */
#define ityp_K \
SUCC(ZERO)
#define ityp_C \
SUCC(ityp_K)
#define ityp_L \
SUCC(ityp_C)
#define ityp_N \
NEUT(ityp_L)
#define ityp_I \
SUCC(ityp_N)
#define ityp_F \
SUCC(ityp_I)
#define ityp_P \
SUCC(ityp_F)
/* Definitions destinees a connaitre de facon sure le type d'un parametre (cela fut */
/* introduit le 20061123174709 pour 'v $xig/fonct$vv$FON ITYP_des_arguments_possibles'). */
/* */
/* ATTENTION : on notera que 'ityp_L' et 'ityp_N' sont evidemment identiques... */
#define GET_PARAMETRE_K(liste_des_arguments,titre_attendu,parametre_K,valeur_K_par_defaut) \
Bblock \
GET_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_K \
,valeur_K_par_defaut \
,FconversionK \
,NEUT \
,styp_K \
,ityp_K \
); \
Eblock \
/* Recuperation d'un parametre "CHAR" ("caractere unique"). */
#define GET_PARAMETRE_C(liste_des_arguments,titre_attendu,parametre_C,valeur_C_par_defaut) \
Bblock \
GET_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_C \
,valeur_C_par_defaut \
,FconversionC \
,NEUT \
,styp_C \
,ityp_C \
); \
Eblock \
/* Recuperation d'un parametre "CHAR" ("chaine de caracteres"). */
#define GET_PARAMETRE_L(liste_des_arguments,titre_attendu,parametre_L,valeur_L_par_defaut) \
Bblock \
GET_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_L \
,valeur_L_par_defaut \
,FconversionL \
,NEUT \
,styp_L \
,ityp_L \
); \
Eblock \
/* Recuperation d'un parametre "Logical". */
#define GET_PARAMETRE_N(liste_des_arguments,titre_attendu,parametre_N,valeur_N_par_defaut) \
Bblock \
PROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_N \
,valeur_N_par_defaut_inversee \
,FconversionN \
,NEUT \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
,styp_N \
,ityp_N \
,BLOC(DEFV(Logical,INIT(valeur_N_par_defaut_inversee,NOTL(valeur_N_par_defaut))); \
EGAL(parametre_N,valeur_N_par_defaut_inversee); \
) \
,BLOC(EGAL(parametre_N,NOTL(parametre_N)); \
) \
); \
/* 'PROCESS_PARAMETRE(...)' a remplace 'GET_PARAMETRE(...)' le 20070305110736 afin de */ \
/* permettre la gestion correcte de 'valeur_N_par_defaut_inversee', un probleme lie a */ \
/* la gestion des synonymes etant apparu a cette occasion. En effet, la "manoeuvre" */ \
/* effectuee sur 'valeur_N_par_defaut' (c'est-a-dire le 'NOTL(...)') doit etre effectuee */ \
/* individuellement pour chaque parametre synonyme et non pas globalement. Cela s'est */ \
/* vu a cette date avec 'v $xcg/ShufBytes.01$K GET_ARGUMENT_N..inverse=.' qui faisait */ \
/* que l'indicateur 'c_est_l_operation_directe' etait 'VRAI' alors que la valeur 'FAUX' */ \
/* etait demandee dans 'v $Falias_fdecrypte decrypter=VRAI' (et donc inversee via */ \
/* 'GET_ARGUMENT_N(...)') sur '$CMAP28'... */ \
\
/* Le 20081113173427, j'ai tente d'introduire ici : */ \
/* */ \
/* Test(EST_VRAI(c_est_la_premiere_recherche_des_parametres)) */ \
/* Bblock */ \
/* DECR(nombre_d_arguments_possibles_regroupes_par_classe...,I); */ \
/* Eblock */ \
/* ATes */ \
/* Bblock */ \
/* Eblock */ \
/* ETes */ \
/* */ \
/* Mais, le 20081115105359 j'ai du y renoncer ('v $xig/fonct$vv$FON 20081113173432')... */ \
Eblock \
/* Recuperation d'un parametre "Logical" inverse (ou "Negate") introduit le 20020710092802. */ \
/* */ \
/* Avant le 20030213155839, la programmation etait: */ \
/* */ \
/* Bblock */ \
/* DEFV(Logical,INIT(parametre_N,NOTL(valeur_L_par_defaut))); */ \
/* GET_PARAMETRE_L(liste_des_arguments */ \
/* ,titre_attendu */ \
/* ,parametre_N */ \
/* ,NOTL(valeur_L_par_defaut) */ \
/* ); */ \
/* EGAL(parametre_L,NOTL(parametre_N)); */ \
/* Eblock */ \
/* */ \
/* Cette solution avait un gros inconvenient : le 'parametre_N' etait local et donc */ \
/* considere comme unique lors de la detection des synonymes. D'ou cette nouvelle solution */ \
/* qui a demande l'introduction de 'valeur_N_par_defaut_inversee' du aux cas ou les deux */ \
/* parametres 'parametre_N' et 'valeur_N_par_defaut' (comme c'est le cas dans la definition */ \
/* de 'GET_ARGUMENT_N(...)'). */
#define GET_PARAMETRE_I(liste_des_arguments,titre_attendu,parametre_I,valeur_I_par_defaut) \
Bblock \
GET_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_I \
,valeur_I_par_defaut \
,FconversionI \
,NEUT \
,styp_I \
,ityp_I \
); \
Eblock \
/* Recuperation d'un parametre "Int". */
#define GET_PARAMETRE_X(liste_des_arguments,titre_attendu,parametre_X,valeur_X_par_defaut) \
Bblock \
GET_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_X \
,valeur_X_par_defaut \
,FconversionX \
,NEUT \
,styp_I \
,ityp_I \
); \
Eblock \
/* Recuperation d'un parametre "Int" a editer en hexa-decimal (cela fut introduit le */ \
/* 20070420190059). */
#define GET_PARAMETRE_F(liste_des_arguments,titre_attendu,parametre_F,valeur_F_par_defaut) \
Bblock \
GET_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_F \
,valeur_F_par_defaut \
,FconversionF \
,NEUT \
,styp_F \
,ityp_F \
); \
Eblock \
/* Recuperation d'un parametre "Float". */
#define GET_PARAMETRE_P(liste_des_arguments,titre_attendu,parametre_P,valeur_P_par_defaut) \
Bblock \
GET_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_P \
,valeur_P_par_defaut \
,FconversionP \
,NEUT \
,styp_P \
,ityp_P \
); \
Eblock \
/* Recuperation d'un parametre "genere_p". */
#define PROKESS_PARAMETRE_K(liste_des_arguments,titre_attendu,parametre_K,valeur_K_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_K \
,valeur_K_par_defaut \
,FconversionK \
,NEUT \
,seq1 \
,seqI \
,seqC \
,seqN \
,styp_K \
,ityp_K \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "CHAR" ("caractere unique") avec execution d'un */ \
/* post-traitement. */
#define PROKESS_PARAMETRE_C(liste_des_arguments,titre_attendu,parametre_C,valeur_C_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_C \
,valeur_C_par_defaut \
,FconversionC \
,NEUT \
,seq1 \
,seqI \
,seqC \
,seqN \
,styp_C \
,ityp_C \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "CHAR" ("chaine de caracteres") avec execution d'un */ \
/* post-traitement. */
#define PROKESS_PARAMETRE_L(liste_des_arguments,titre_attendu,parametre_L,valeur_L_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_L \
,valeur_L_par_defaut \
,FconversionL \
,NEUT \
,seq1 \
,seqI \
,seqC \
,seqN \
,styp_L \
,ityp_L \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "Logical" avec execution d'un post-traitement. */
#define PROKESS_PARAMETRE_N(liste_des_arguments,titre_attendu,parametre_N,valeur_N_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_N \
,valeur_N_par_defaut_inversee \
,FconversionN \
,NEUT \
,seq1 \
,seqI \
,seqC \
,seqN \
,styp_N \
,ityp_N \
,BLOC(DEFV(Logical,INIT(valeur_N_par_defaut_inversee,NOTL(valeur_N_par_defaut))); \
EGAL(parametre_N,valeur_N_par_defaut_inversee); \
) \
,BLOC(EGAL(parametre_N,NOTL(parametre_N)); \
) \
); \
Eblock \
/* Recuperation d'un parametre "Logical" inverse (ou "Negate") avec execution d'un */ \
/* post-traitement introduit le 20020710092802. */ \
/* */ \
/* Avant le 20051216140825, la programmation etait: */ \
/* */ \
/* Bblock */ \
/* DEFV(Logical,INIT(parametre_N,NOTL(valeur_L_par_defaut))); */ \
/* PROCESS_PARAMETRE_L(liste_des_arguments */ \
/* ,titre_attendu */ \
/* ,parametre_N */ \
/* ,NOTL(valeur_L_par_defaut) */ \
/* ,seq1 */ \
/* ,seqI */ \
/* ,seqC */ \
/* ,seqN */ \
/* ); */ \
/* EGAL(parametre_L,NOTL(parametre_N)); */ \
/* Eblock */ \
/* */ \
/* Cette solution avait un gros inconvenient : le 'parametre_N' etait local et donc */ \
/* considere comme unique lors de la detection des synonymes. D'ou cette nouvelle solution */ \
/* qui a demande l'introduction de 'valeur_N_par_defaut_inversee' du aux cas ou les deux */ \
/* parametres 'parametre_N' et 'valeur_N_par_defaut' (comme c'est le cas dans la definition */ \
/* de 'GET_PARAMETRE_N(...)'). */
#define PROKESS_PARAMETRE_I(liste_des_arguments,titre_attendu,parametre_I,valeur_I_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_I \
,valeur_I_par_defaut \
,FconversionI \
,NEUT \
,seq1 \
,seqI \
,seqC \
,seqN \
,styp_I \
,ityp_I \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "Int" avec execution d'un post-traitement. */
#define PROKESS_PARAMETRE_J(liste_des_arguments,titre_attendu,parametre_J,valeur_J_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_J \
,valeur_J_par_defaut \
,FconversionJ \
,NEUT \
,seq1 \
,seqI \
,seqC \
,seqN \
,styp_I \
,ityp_I \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "Int" avec execution d'un post-traitement (introduit le */ \
/* 20111213132424). */
#define PROKESS_PARAMETRE_X(liste_des_arguments,titre_attendu,parametre_X,valeur_X_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_X \
,valeur_X_par_defaut \
,FconversionX \
,NEUT \
,seq1 \
,seqI \
,seqC \
,seqN \
,styp_I \
,ityp_I \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "Int" avec execution d'un post-traitement avec edition */ \
/* hexa-decimale (introduit le 20070421093557). */
#define PROKESS_PARAMETRE_Y(liste_des_arguments,titre_attendu,parametre_Y,valeur_Y_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_Y \
,valeur_Y_par_defaut \
,FconversionY \
,NEUT \
,seq1 \
,seqI \
,seqC \
,seqN \
,styp_I \
,ityp_I \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "Int" avec execution d'un post-traitement avec edition */ \
/* hexa-decimale (introduit le 20111213132424). */
#define PROKESS_PARAMETRE_F(liste_des_arguments,titre_attendu,parametre_F,valeur_F_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_F \
,valeur_F_par_defaut \
,FconversionF \
,NEUT \
,seq1 \
,seqI \
,seqC \
,seqN \
,styp_F \
,ityp_F \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "Float" avec execution d'un post-traitement. */
#define PROKESS_PARAMETRE_P(liste_des_arguments,titre_attendu,parametre_P,valeur_P_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROCESS_PARAMETRE(liste_des_arguments \
,titre_attendu \
,parametre_P \
,valeur_P_par_defaut \
,FconversionP \
,NEUT \
,seq1 \
,seqI \
,seqC \
,seqN \
,styp_P \
,ityp_P \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "genere_p" avec execution d'un post-traitement. */
#define PROCESS_PARAMETRE_K(liste_des_arguments,titre_attendu,parametre_K,valeur_K_par_defaut,seqI,seqC) \
Bblock \
PROKESS_PARAMETRE_K(liste_des_arguments \
,titre_attendu \
,parametre_K \
,valeur_K_par_defaut \
,BLOC(VIDE;) \
,seqI \
,seqC \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "CHAR" ("caractere unique") avec execution d'un */ \
/* post-traitement. */
#define PROCESS_PARAMETRE_C(liste_des_arguments,titre_attendu,parametre_C,valeur_C_par_defaut,seqI,seqC) \
Bblock \
PROKESS_PARAMETRE_C(liste_des_arguments \
,titre_attendu \
,parametre_C \
,valeur_C_par_defaut \
,BLOC(VIDE;) \
,seqI \
,seqC \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "CHAR" ("chaine de caracteres") avec execution d'un */ \
/* post-traitement. */
#define PROCESS_PARAMETRE_L(liste_des_arguments,titre_attendu,parametre_L,valeur_L_par_defaut,seqI,seqC) \
Bblock \
PROKESS_PARAMETRE_L(liste_des_arguments \
,titre_attendu \
,parametre_L \
,valeur_L_par_defaut \
,BLOC(VIDE;) \
,seqI \
,seqC \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "Logical" avec execution d'un post-traitement. */
#define PROCESS_PARAMETRE_N(liste_des_arguments,titre_attendu,parametre_N,valeur_N_par_defaut,seqI,seqC) \
Bblock \
PROKESS_PARAMETRE_N(liste_des_arguments \
,titre_attendu \
,parametre_N \
,valeur_N_par_defaut \
,BLOC(VIDE;) \
,seqI \
,seqC \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "Logical" inverse (ou "Negate") avec execution d'un */ \
/* post-traitement introduit le 20020710092802. */
#define PROCESS_PARAMETRE_I(liste_des_arguments,titre_attendu,parametre_I,valeur_I_par_defaut,seqI,seqC) \
Bblock \
PROKESS_PARAMETRE_I(liste_des_arguments \
,titre_attendu \
,parametre_I \
,valeur_I_par_defaut \
,BLOC(VIDE;) \
,seqI \
,seqC \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "Int" avec execution d'un post-traitement. */
#define PROCESS_PARAMETRE_J(liste_des_arguments,titre_attendu,parametre_J,valeur_J_par_defaut,seqI,seqC) \
Bblock \
PROKESS_PARAMETRE_J(liste_des_arguments \
,titre_attendu \
,parametre_J \
,valeur_J_par_defaut \
,BLOC(VIDE;) \
,seqI \
,seqC \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "Int" avec execution d'un post-traitement (introduit le */ \
/* 20111213132424). */
#define PROCESS_PARAMETRE_X(liste_des_arguments,titre_attendu,parametre_X,valeur_X_par_defaut,seqI,seqC) \
Bblock \
PROKESS_PARAMETRE_X(liste_des_arguments \
,titre_attendu \
,parametre_X \
,valeur_X_par_defaut \
,BLOC(VIDE;) \
,seqI \
,seqC \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "Int" avec execution d'un post-traitement avec edition */ \
/* hexa-decimale (introduit le 20070421093557). */
#define PROCESS_PARAMETRE_Y(liste_des_arguments,titre_attendu,parametre_Y,valeur_Y_par_defaut,seqI,seqC) \
Bblock \
PROKESS_PARAMETRE_Y(liste_des_arguments \
,titre_attendu \
,parametre_Y \
,valeur_Y_par_defaut \
,BLOC(VIDE;) \
,seqI \
,seqC \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "Int" avec execution d'un post-traitement avec edition */ \
/* hexa-decimale (introduit le 20111213132424). */
#define PROCESS_PARAMETRE_F(liste_des_arguments,titre_attendu,parametre_F,valeur_F_par_defaut,seqI,seqC) \
Bblock \
PROKESS_PARAMETRE_F(liste_des_arguments \
,titre_attendu \
,parametre_F \
,valeur_F_par_defaut \
,BLOC(VIDE;) \
,seqI \
,seqC \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "Float" avec execution d'un post-traitement. */
#define PROCESS_PARAMETRE_P(liste_des_arguments,titre_attendu,parametre_P,valeur_P_par_defaut,seqI,seqC) \
Bblock \
PROKESS_PARAMETRE_P(liste_des_arguments \
,titre_attendu \
,parametre_P \
,valeur_P_par_defaut \
,BLOC(VIDE;) \
,seqI \
,seqC \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un parametre "genere_p" avec execution d'un post-traitement. */
#define gINITIALISATION_DE_LA_LISTE_DES_UTILISATIONS_DES_ARGUMENTS_POSSIBLES \
Bblock \
DEFV(Int,INIT(index_d_initialisation_de_UTILISATION_des_arguments_possibles,UNDEF)); \
\
DoIn(index_d_initialisation_de_UTILISATION_des_arguments_possibles \
,PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
,LSTX(PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
,NOMBRE_MAXIMAL_DE_NUMEROS_UNIQUES_DES_ARGUMENTS_POSSIBLES \
) \
,I \
) \
Bblock \
CLIR(ITb1(UTILISATION_des_arguments_possibles \
,INDX(index_d_initialisation_de_UTILISATION_des_arguments_possibles \
,PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
) \
) \
); \
Eblock \
EDoI \
Eblock \
/* Procedure permettant d'initialiser 'UTILISATION_des_arguments_possibles'. Elle fut */ \
/* introduite le 20070821091849 pour le probleme 'v $xcc/cpp$Z 20070820203242'... */
#define gPARCOURS_DE_LA_LISTE_DES_ARGUMENTS(nombre_effectif_d_arguments_gPARCOURS,liste_de_traitement) \
Bblock \
CALS(FgINITIALISATION_DE_LA_LISTE_DES_UTILISATIONS_DES_ARGUMENTS_POSSIBLES()); \
/* Initialisation du dispositif de detection de l'utilisation (ou "reference") des */ \
/* arguments possibles (introduit le 20070820113014). On notera que cela a donc lieu */ \
/* a chaque fois que l'on rentre dans 'gPARCOURS_DE_LA_LISTE_DES_ARGUMENTS(...)' or, par */ \
/* exemple 'GET_ARGUMENTSi(...)', via 'GET_PARAMETRES(...)' execute deux fois de suite */ \
/* 'PARCOURS_DE_LA_LISTE_DES_ARGUMENTS(...)' pour 'liste_de_recuperation_1', puis pour */ \
/* 'liste_de_recuperation_2'. Les cumuls dans 'UTILISATION_des_arguments_possibles' sont */ \
/* donc "locaux" a une occurence de 'gPARCOURS_DE_LA_LISTE_DES_ARGUMENTS(...)' et non pas */ \
/* globaux au '$K' courant. Cela a ete note le 20070820164448... */ \
\
EGAL(numero_d_argument_courant,NUMERO_ARGUMENT_COMMANDE); \
/* (re-)initialisation du numero de l'argument courant. */ \
\
Komp(compteur_des_arguments,nombre_effectif_d_arguments_gPARCOURS) \
Bblock \
EGAL(numero_de_l_argument_possible_courant__en_ne_tenant_pas_compte_des_synonymes \
,PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
); \
EGAL(numero_de_l_argument_possible_courant__en_tenant________compte_des_synonymes \
,PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
); \
/* Numero de l'argument possible courant (introduit le 20070820101714) sans tenir compte */ \
/* des synonymes, puis en en tenant compte (le premier doit donc etre superieur ou egal au */ \
/* second...). */ \
/* */ \
/* ATTENTION : on notera le 20070820161759 qu'a chaque fois que l'on rentre ici, ces deux */ \
/* numeros sont reinitialises. On verra aussi ce qui est dit ci-dessus et qui concerne */ \
/* la (re-)initialisation de 'UTILISATION_des_arguments_possibles'... */ \
\
BLOC(liste_de_traitement); \
/* Traitement specifique de chaque argument... */ \
\
Test(IFLT(numero_de_l_argument_possible_courant__en_ne_tenant_pas_compte_des_synonymes \
,numero_de_l_argument_possible_courant__en_tenant________compte_des_synonymes \
) \
) \
Bblock \
PRINT_ERREUR("le decompte des arguments possibles est incorrect"); \
CAL1(Prer3("(il y a %d arguments possibles differents et %d (>%d) si les synonymes sont regroupes)\n" \
,numero_de_l_argument_possible_courant__en_ne_tenant_pas_compte_des_synonymes \
,numero_de_l_argument_possible_courant__en_tenant________compte_des_synonymes \
,numero_de_l_argument_possible_courant__en_ne_tenant_pas_compte_des_synonymes \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
INCR(numero_d_argument_courant,I); \
/* Passage a l'argument suivant (s'il existe)... */ \
Eblock \
EKom \
Eblock \
/* Boucle de parcours de l'ensemble des arguments effectifs (c'est-a-dire en excluant le */ \
/* nom de la commande elle-meme...) et execution d'un traitement pour chaque argument... */ \
/* */ \
/* Il s'agit ici de la boucle "fondamentale". Chaque argument d'appel d'un '$X' (cette */ \
/* liste pouvant etre vide) est compare successivement a tous les arguments possibles, */ \
/* dont la liste correspond a 'liste_de_traitement'. Il y a donc en quelque sorte deux */ \
/* boucles imbriquees : */ \
/* */ \
/* Bouc(ListeArgumentsAppel) */ \
/* Bblock */ \
/* Bouc(ListeTousArgumentsPossibles) */ \
/* Bblock */ \
/* (...) */ \
/* Eblock */ \
/* EBou */ \
/* Eblock */ \
/* EBou */ \
/* */ \
/* On notera que ci-apres 'c_est_la_derniere_recherche_des_parametres' concerne donc la */ \
/* recuperation du dernier argument d'appel : */ \
/* */ \
/* Commande$X Argument1 Argument2 (...) ArgumentN */ \
/* --------- */ \
/* */ \
/* avec : */ \
/* */ \
/* ListeArgumentsAppel={Argument1,Argument2,...,ArgumentN} */ \
/* */ \
/* cette liste pouvant etre vide... */
#define PARCOURS_DE_LA_LISTE_DES_ARGUMENTS(nombre_effectif_d_arguments_PARCOURS,liste_de_recuperation) \
Bblock \
gPARCOURS_DE_LA_LISTE_DES_ARGUMENTS(nombre_effectif_d_arguments_PARCOURS \
,BLOC(EGAL(c_est_la_premiere_recherche_des_parametres \
,EST_VRAI(IFEQ(compteur_des_arguments \
,PREMIERE_ITERATION_D_UN_Komp \
) \
) \
); \
/* Ceci fut introduit "preventivement" le 20060213120055... */ \
EGAL(c_est_la_derniere_recherche_des_parametres \
,EST_VRAI(IFEQ(compteur_des_arguments \
,nombre_effectif_d_arguments_PARCOURS \
) \
) \
); \
/* Et ce afin d'editer eventuellement la valeur reellement utilisee pour les parametres */ \
/* d'une commande... */ \
\
BLOC(liste_de_recuperation); \
/* Recuperation de la liste de parametres... */ \
/* */ \
/* ATTENTION, il est tres important de mettre 'liste_de_recuperation' apres l'entree de */ \
/* '$formatI' car, en effet, certaines valeurs initiales de parametres peuvent en dependre */ \
/* via 'GIT_ARGUMENT_?(...)'... */ \
) \
); \
Eblock \
/* Boucle de parcours de l'ensemble des arguments effectifs (c'est-a-dire en excluant le */ \
/* nom de la commande elle-meme...) et recuperation de chacun d'eux... */
@ifdef PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES
@ define EXECUTER_LE_listverSO \
FAUX
@ define MESSAGE_PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES \
"Les LIBRAIRIES DYNAMIQUES '$SO' de '$xb' ne peuvent pas etre utilisees avec ce programme."
/* Jusqu'au 20030217155308, le message etait : */
/* */
/* Les librairies dynamiques '$SO' de '$xb' ne sont pas utilisables. */
/* */
@Aifdef PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES
@ define EXECUTER_LE_listverSO \
VRAI
@ define MESSAGE_PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES \
"Les LIBRAIRIES DYNAMIQUES '$SO' de '$xb' peuvent etre utilisees avec ce programme, si le contexte le permet."
/* Jusqu'au 20030217155308, le message etait : */
/* */
/* Les librairies dynamiques '$SO' de '$xb' sont peut-etre utilisables. */
/* */
@Eifdef PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES
@define EXECUTER_LE_listenvSO \
EXECUTER_LE_listverSO
/* Definition introduite le 20091114113908... */
@ifdef PRAGMA_CL_____MODULE_NON_OPTIMISABLE
@ define MESSAGE_PRAGMA_CL_____MODULE_NON_OPTIMISABLE \
"L'OPTIMISATION n'est pas possible avec ce programme."
/* Jusqu'au 20030217155308, le message etait : */
/* */
/* Programme non optimise. */
/* */
@Aifdef PRAGMA_CL_____MODULE_NON_OPTIMISABLE
@ define MESSAGE_PRAGMA_CL_____MODULE_NON_OPTIMISABLE \
"L'OPTIMISATION est possible avec ce programme, mais, en fonction du contexte, peut ne pas etre faite."
/* Jusqu'au 20030217155308, le message etait : */
/* */
/* Programme peut-etre optimise. */
/* */
@Eifdef PRAGMA_CL_____MODULE_NON_OPTIMISABLE
/* Jusqu'au 20050102163032, se trouvaient ici les definitions : */
/* */
/* LANCEMENT_D_UNE_COMMANDE_SOUS_CSH */
/* PERMETTRE_UN_USAGE_NORMAL_DE_Mor */
/* */
/* qui ont ete deplacees a cette date dans 'v $xil/defi_c1$vv$DEF 20050102162501'... */
#ifdef PRAGMA_CPP_____AUTORISER_LE_GooF
# define EDITER_L_ETAT_DU_MODE_GooF \
Bblock \
CALS(FPrme0("Le mode 'GooF' est activable sans prejuger du mode 'GooF' des librairies utilisees.\n\n")); \
Eblock \
/* Le mot "autorise" a ete remplace par "activable" le 20051130094632... */
#Aifdef PRAGMA_CPP_____AUTORISER_LE_GooF
# define EDITER_L_ETAT_DU_MODE_GooF \
Bblock \
CALS(FPrme0("Le mode 'GooF' est inhibe sans prejuger du mode 'GooF' des librairies utilisees.\n\n")); \
Eblock
#Eifdef PRAGMA_CPP_____AUTORISER_LE_GooF
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R O C E D U R E G E N E R A L E ' GET_PARAMETRES(...) ' : */
/* */
/*************************************************************************************************************************************/
#define GET_PARAMETRES_____tester_la_double_definition_des_parametres(nombre_d_arguments_y_compris_le_nom,La) \
Bblock \
Test(IL_FAUT(tester_la_double_definition_des_parametres)) \
Bblock \
gPARCOURS_DE_LA_LISTE_DES_ARGUMENTS(nombre_effectif_d_arguments \
,BLOC(Test(IFET(IFNE(numero_d_argument_courant,NUMERO_ARGUMENT_COMMANDE) \
,IFNE(IdTb1(IDENTITE_des_arguments_presents \
,INDX(numero_d_argument_courant \
,NUMERO_ARGUMENT_COMMANDE \
) \
,nombre_d_arguments_y_compris_le_nom \
) \
,ADRESSE_NON_ENCORE_DEFINIE \
) \
) \
) \
Bblock \
/* 'numero_d_argument_courant' donne en permanence le numero de l'argument courant. */ \
DEFV(Int,INIT(numero_d_argument_avant \
,NUMERO_ARGUMENT_COMMANDE \
) \
); \
/* 'numero_d_argument_avant' donnera, lorsque le test suivant sera VRAI, le numero d'un */ \
/* argument precedant l'argument courant dans la liste des arguments 'La'. */ \
Komp(compteur_des_arguments_avant,nombre_effectif_d_arguments) \
Bblock \
Test(I3ET(IFNE(numero_d_argument_avant \
,NUMERO_ARGUMENT_COMMANDE \
) \
,IFNE(IdTb1(IDENTITE_des_arguments_presents \
,INDX(numero_d_argument_avant \
,NUMERO_ARGUMENT_COMMANDE \
) \
,nombre_d_arguments_y_compris_le_nom \
) \
,ADRESSE_NON_ENCORE_DEFINIE \
) \
,IFLT(numero_d_argument_avant \
,numero_d_argument_courant \
) \
) \
) \
Bblock \
/* Cas ou l'on est en presence d'un argument valide precedant l'argument courant. */ \
Test(IFEQ(IdTb1(IDENTITE_des_arguments_presents \
,INDX(numero_d_argument_courant \
,NUMERO_ARGUMENT_COMMANDE \
) \
,nombre_d_arguments_y_compris_le_nom \
) \
,IdTb1(IDENTITE_des_arguments_presents \
,INDX(numero_d_argument_avant \
,NUMERO_ARGUMENT_COMMANDE \
) \
,nombre_d_arguments_y_compris_le_nom \
) \
) \
) \
Bblock \
/* Cas ou un argument precedant l'argument courant et ce dernier modifient le meme */ \
/* parametre, meme si les "titres" sont differents (cas des synonymes du type "imageR=" */ \
/* et "R=") : */ \
PRINT_ATTENTION("risque de double definition"); \
/* On notera qu'il y a un grave danger avec une double definition uniquement si les */ \
/* valeurs introduites different. Dans le contraire c'est juste quelque peu illogique */ \
/* (et en general une erreur...). */ \
CAL1(Prer2("avec les parametres '%s' et '%s'\n" \
,ITb1(La \
,INDX(numero_d_argument_avant \
,NUMERO_ARGUMENT_COMMANDE \
) \
) \
,ITb1(La \
,INDX(numero_d_argument_courant \
,NUMERO_ARGUMENT_COMMANDE \
) \
) \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
INCR(numero_d_argument_avant,I); \
/* Passage a l'argument suivant (s'il existe)... */ \
Eblock \
EKom \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define GET_PARAMETRES_____editer_les_differentes_variables_d_environnement_utiles \
Bblock \
Test(IL_FAUT(editer_les_differentes_variables_d_environnement_utiles)) \
/* Test (et sequence suivante) introduit le 20091114113908... */ \
Bblock \
CALS(Fsauts_de_lignes(DEUX)); \
CAL3(Prme2("%s%s" \
,"Variables d'environnement de la commande courante, certaines pouvant ne pas etre utilisees :\n" \
,"------------------------------------------------------------------------------------------\n" \
) \
); \
CALS(Fsauts_de_lignes(DEUX)); \
\
CALS(FPrme0("PAS DE VARIABLES D'ENVIRONNEMENT RECENSEES POUR CE PROGRAMME")); \
/* ATTENTION, ce message peut etre modifie dynamiquement par 'v $xcc/cpp$Z PasDeVariables'. */ \
\
Test(EST_VRAI(editer_les_differentes_variables_d_environnement_utiles_dans_les_librairies_dynamiques)) \
Bblock \
CAL3(Prme1("\n%s",MESSAGE_PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES)); \
\
Test(EST_VRAI(EXECUTER_LE_listenvSO)) \
Bblock \
CALS(Fsauts_de_lignes(UN)); \
CALS(FPrme0("Pour l'ENSEMBLE des LIBRAIRIES DYNAMIQUES '$SO' de '$xb', ")); \
CALS(FPrme0("la commande 'listenvSO' donne :")); \
/* ATTENTION : la commande 'listenvSO' examine l'ensemble des librairies dynamiques, alors */ \
/* que 'PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES*' ne concerne que les librairies */ \
/* dynamiques de '$xb'... */ \
CALS(Fsauts_de_lignes(UN)); \
\
EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_CSH("'listenvSO $NEXIST'"); \
/* ATTENTION, l'appel de '$CSH' provoque l'interpretation de '$FCshrc' (via '$Fcshrc'), */ \
/* d'ou un certain "delai" avant l'edition des librairies dynamiques... */ \
\
CALS(Fsauts_de_lignes(DEUX)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define GET_PARAMETRES_____editer_les_differentes_versions_du_programme \
Bblock \
Test(IL_FAUT(editer_les_differentes_versions_du_programme)) \
Bblock \
CALS(Fsauts_de_lignes(UN)); \
\
Test(PAS_D_ERREUR(Ftest_fichier(nom_de_la_commande_courante \
,NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS \
) \
) \
) \
/* On notera qu'a priori, on ne sait pas si 'nom_de_la_commande_courante' donne un nom */ \
/* relatif ou absolu, ce qui explique que ce test puisse etre faux alors qu'evidemment la */ \
/* commande existe, puisque l'on est en train de l'executer... */ \
Bblock \
DEFV(Int,INIT(taille_de_la_composante_statique_de_la_commande_courante,UNDEF)); \
CALS(Fsize_fichier(nom_de_la_commande_courante \
,ADRESSE(taille_de_la_composante_statique_de_la_commande_courante) \
,EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS \
) \
); \
/* Determination de la taille de la composante "statique" de la commande courante... */ \
\
CAL3(Prme4("%s%d%s%s" \
,"Taille de la commande courante (composante 'statique') : " \
,taille_de_la_composante_statique_de_la_commande_courante \
," octets\n" \
,"------------------------------------------------------\n" \
) \
); \
/* Ceci a ete introduit le 20061010095148... */ \
Eblock \
ATes \
Bblock \
PRINT_ATTENTION("la taille d'une commande n'est editable qu'a partir de son directory ou en absolu"); \
Eblock \
ETes \
\
CALS(Fsauts_de_lignes(DEUX)); \
CAL3(Prme2("%s%s" \
,"Versions de la commande courante, certaines pouvant ne pas etre utilisees :\n" \
,"-------------------------------------------------------------------------\n" \
) \
); \
CALS(Fsauts_de_lignes(DEUX)); \
\
CAL3(Prme1("\n%s",MESSAGE_PRAGMA_CL_____MODULE_NON_OPTIMISABLE)); \
CALS(Fsauts_de_lignes(UN)); \
\
EDITER_L_ETAT_DU_MODE_GooF; \
/* Ceci a ete introduit le 20040421102109... */ \
\
CALS(FPrme0("PAS DE VERSIONS RECENSEES POUR CE PROGRAMME")); \
/* ATTENTION, ce message peut etre modifie dynamiquement par 'v $xcc/cpp$Z PasDeVersions' ; */ \
/* d'autre part il convient de noter que si des "VERSION"s sont editees, elles ne */ \
/* concernent que le programme lui-meme et non pas les librairies de '$xb' qu'il utilise... */ \
\
Test(EST_VRAI(editer_les_differentes_versions_du_programme_dans_les_librairies_dynamiques)) \
Bblock \
Test(EST_VRAI(EXECUTER_LE_listverSO)) \
/* Ce test a ete introduit le 20051211074854... */ \
Bblock \
PRINT_ATTENTION("les 'VERSION's des librairies dynamiques '$SO' de '$xb' peuvent etre differentes"); \
CALS(Fsauts_de_lignes(UN)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
CAL3(Prme1("\n%s",MESSAGE_PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES)); \
\
Test(EST_VRAI(EXECUTER_LE_listverSO)) \
/* Ce test a ete introduit le 20051211074854... */ \
Bblock \
CALS(Fsauts_de_lignes(UN)); \
CALS(FPrme0("Pour l'ENSEMBLE des LIBRAIRIES DYNAMIQUES '$SO' de '$xb', ")); \
CALS(FPrme0("la commande 'listverSO' donne :")); \
/* ATTENTION : la commande 'listverSO' examine l'ensemble des librairies dynamiques, alors */ \
/* que 'PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES*' ne concerne que les librairies */ \
/* dynamiques de '$xb'... */ \
CALS(Fsauts_de_lignes(UN)); \
\
EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_CSH("'listverSO $NEXIST'"); \
/* ATTENTION, l'appel de '$CSH' provoque l'interpretation de '$FCshrc' (via '$Fcshrc'), */ \
/* d'ou un certain "delai" avant l'edition des librairies dynamiques... */ \
/* */ \
/* Le 20031005190503 un argument a ete introduit pour 'listverSO' depuis la modification */ \
/* 'v $xE/.alias.2$vv$Y 20031005114000'. Cela a contraint a mettre la commande 'listverSO' */ \
/* et son argument entre quotes afin que ce dernier soit pris en compte. A la date du */ \
/* 20031005190503, la valeur choisie pour l'argument est '$NEXIST' afin de ne sortir que */ \
/* les VERSIONs essentielles (la valeur '$EXIST' permettant la sortie exhaustive...). */ \
\
CALS(Fsauts_de_lignes(DEUX)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
/* Edition de quelques messages relatifs aux PRAGMAs. On notera qu'etant donne la structure */ \
/* de ceux-ci, les editions precedentes ne font qu'indiquer des comportements generaux. */ \
/* Les cas specifiques : */ \
/* */ \
/* PRAGMA_CL_____MODULE_NON_OPTIMISABLE_$SYSTEME */ \
/* PRAGMA_CL_____MODULE_NON_OPTIMISABLE_$sHOTE */ \
/* */ \
/* et : */ \
/* */ \
/* PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES_$SYSTEME */ \
/* PRAGMA_CL_____PAS_DE_LIBRAIRIES_DYNAMIQUES_$sHOTE */ \
/* */ \
/* ne peuvent etre traites ici simplement et exhaustivement... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define GET_PARAMETRES_____editer_la_liste_des_librairies_dynamiques_utilisees \
Bblock \
Test(IL_FAUT(editer_la_liste_des_librairies_dynamiques_utilisees)) \
Bblock \
CALS(Fsauts_de_lignes(UN)); \
CAL3(Prme2("%s%s" \
,"Listes des librairies dynamiques utilisees :\n" \
,"------------------------------------------\n" \
) \
); \
CALS(Fsauts_de_lignes(DEUX)); \
\
CALS(FPrme0("Pour l'ENSEMBLE des LIBRAIRIES DYNAMIQUES '$SO' de '$xb', la commande 'LibDynam' donne :")); \
\
CALS(Fsauts_de_lignes(DEUX)); \
\
EXECUTION_D_UNE_COMMANDE_AVEC_ARGUMENTS_SOUS_CSH(chain_Aconcaten5("LibDynam" \
,C_BLANC \
,NOM_DE_LA_COMMANDE \
,C_BLANC \
,"$EXIST" \
) \
); \
/* ATTENTION, l'appel de '$CSH' provoque l'interpretation de '$FCshrc' (via '$Fcshrc'). */ \
/* */ \
/* Je note le 20221111110731 que cela permet de savoir si lorsqu'une librairie est modifiee */ \
/* un '$X' doit etre recompile. Ainsi : */ \
/* */ \
/* $xcg/ADD2.01$X ---> */ \
/* libc.so.6 */ \
/* libm.so.6 */ \
/* ==> doit etre recompile... */ \
/* */ \
/* */ \
/* $xcg/ADD3.01$X ---> */ \
/* $xbg/allocation$SO */ \
/* $xbg/common$SO */ \
/* $xbg/fonction$SO */ \
/* $xbmf/trigoc$SO */ \
/* */ \
/* libc.so.6 */ \
/* libm.so.6 */ \
/* ==> n'a pas a etre recompile... */ \
/* */ \
/* */ \
/* Le 20221111123806 fut ajoutee l'edition de suggestions concernant une eventuelle */ \
/* recompilation de cette commande... */ \
/* */ \
CALS(Fsauts_de_lignes(DEUX)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define GET_PARAMETRES_____editer_les_differents_bugs_reconnus \
Bblock \
Test(IL_FAUT(editer_les_differents_bugs_reconnus)) \
Bblock \
CALS(Fsauts_de_lignes(UN)); \
CAL3(Prme2("%s%s" \
,"Bugs reconnus (certains pouvant ne pas etre rencontres par la commande courante \n" \
,"--------------------------------------------------------------------------------\n" \
) \
); \
CALS(Fsauts_de_lignes(DEUX)); \
\
CALS(FPrme0("PAS DE BUGS RECENSES POUR CE PROGRAMME")); \
/* ATTENTION, ce message peut etre modifie dynamiquement par 'v $xcc/cpp$Z PasDeBugs' ; */ \
/* d'autre part il convient de noter que si des "BUG"s sont edites, ils ne */ \
/* concernent que le programme lui-meme et non pas les librairies de '$xb' qu'il utilise... */ \
/* Ceci a ete introduit le 20030303133123. */ \
PRINT_ATTENTION("les 'BUG's des librairies dynamiques '$SO' de '$xb' peuvent etre differents"); \
CALS(Fsauts_de_lignes(UN)); \
CALS(FPrme0("Pour l'ENSEMBLE des LIBRAIRIES DYNAMIQUES '$SO' de '$xb', la commande 'listbugSO' donne :")); \
\
CALS(Fsauts_de_lignes(UN)); \
EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_CSH("listbugSO"); \
/* ATTENTION, l'appel de '$CSH' provoque l'interpretation de '$FCshrc' (via '$Fcshrc'). */ \
CALS(Fsauts_de_lignes(DEUX)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define GET_PARAMETRES_____editer_les_differents_includes_du_programme \
Bblock \
Test(IL_FAUT(editer_les_differents_includes_du_programme)) \
Bblock \
CAL3(Prme2("%s%s" \
,"\n\nPrincipaux includes de la commande courante :\n" \
,"-------------------------------------------\n" \
) \
); \
/* Versions : */ \
/* */ \
/* 20000713113601 : seuls sont edites les includes '$EXT', */ \
/* 20000718114444 : tous les includes sont edites sauf {$ARG,$DEF,$PASSE_5}, */ \
/* */ \
/* ('v $xcc/cpp$Z 20000713113601'). */ \
CALS(Fsauts_de_lignes(DEUX)); \
\
CALS(FPrme0("PAS D'INCLUDES RECENSES POUR CE PROGRAMME")); \
/* ATTENTION, ce message peut etre modifie dynamiquement par 'v $xcc/cpp$Z PasDIncludes'. */ \
\
CALS(Fsauts_de_lignes(DEUX)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define GET_PARAMETRES_____permettre_l_acces_au_source_du_programme \
Bblock \
Test(IL_FAUT(permettre_l_acces_au_source_du_programme)) \
Bblock \
Test(IL_FAUT(autoriser_l_acces_au_source_du_programme)) \
/* ATTENTION : 'autoriser_l_acces_au_source_du_programme' est une fausse variable introduite */ \
/* le 20050110155508 destinee a bloquer l'acces au source lorsque celui-ci est crypte grace */ \
/* a 'v $xcc/cpp$Z autoriser_l_acces_au_source_du_programme' ; elle prend alors la valeur */ \
/* '$NEXIST' ou '$EXIST' suivant que le source '$K' est ou n'est pas crypte... */ \
Bblock \
DEFV(CHAR,INIC(POINTERc(format_EGAq____GET_PARAMETRES) \
,chain_Aconcaten5(Gvar("VI") \
,C_BLANC \
,HOME_DIRECTORY \
,cSEPARATEUR_DES_PATHS \
,PROGRAMME_COURANT_RELATIF_A_x \
) \
) \
); \
\
EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(format_EGAq____GET_PARAMETRES); \
/* Execution de la commande utile a l'acces au source du programme. On notera l'utilisation */ \
/* de '$x/PROGRAMME_COURANT_RELATIF_A_x' afin que les programmes de type "bootstrappables" */ \
/* (dans '$xcp') aient des sources '$c' qui soient independants des implementations... */ \
/* */ \
/* ATTENTION : on notera le 20050110154220 que ce source peut apparaitre "brouille" dans */ \
/* le cas ou le programme est crypte ('v $xcg/ShufBytes.01$K'). Je ne sais pas tres bien */ \
/* quoi faire pour eviter cela ; au moins cela montre que le fichier est crypte. La */ \
/* solution est apparue le 20050110155508 avec 'autoriser_l_acces_au_source_du_programme'. */ \
\
CALZ_FreCC(format_EGAq____GET_PARAMETRES); \
Eblock \
ATes \
Bblock \
PRINT_ATTENTION("ce source est crypte, il est donc inaccessible"); \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define GET_PARAMETRES_____permettre_l_acces_a_la_liste_des_fonctions_referencees \
Bblock \
Test(IL_FAUT(permettre_l_acces_a_la_liste_des_fonctions_referencees_par_le_programme)) \
Bblock \
DEFV(CHAR,INIC(POINTERc(liste_fonctions_referencees_par_le_programme) \
,chain_Aconcaten3(HOME_DIRECTORY \
,cSEPARATEUR_DES_PATHS \
,LISTE_FONCTIONS_PROGRAMME_COURANT_RELATIF_A_x \
) \
) \
); \
\
Test(PAS_D_ERREUR(Ftest_fichier(liste_fonctions_referencees_par_le_programme \
,NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS \
) \
) \
) \
Bblock \
DEFV(CHAR,INIC(POINTERc(format_EGAq____GET_PARAMETRES) \
,chain_Aconcaten3(Gvar("VI") \
,C_BLANC \
,liste_fonctions_referencees_par_le_programme \
) \
) \
); \
\
EXECUTION_D_UNE_SUITE_DE_COMMANDES_SOUS_SH(format_EGAq____GET_PARAMETRES); \
/* Execution de la commande utile a l'acces a liste des fonctions referencees par le */ \
/* programme (introduit le 20120626104316). */ \
\
CALZ_FreCC(format_EGAq____GET_PARAMETRES); \
Eblock \
ATes \
Bblock \
PRINT_ATTENTION("la liste '$MAP' de toutes les fonctions referencees par cette commande n'existe plus"); \
/* ATTENTION : on notera que depuis le 'v $xcc/cpp$Z 20120625125712' les fichiers '$MAP' */ \
/* n'existent plus, sauf pour le librairies de '$xb'... */ \
/* */ \
/* Aux environs du 'v $xcc/cpp$Z 20170410100311' ils ont ete retablis et regeneres pour */ \
/* tous les '$K's ('v $Dhistory/LACT1A$D/20170410083214 20170409213235') directement, sans */ \
/* passer par 'v $xcc/cpp$Z .xcc.LFonctionR.vv.Z'... */ \
Eblock \
ETes \
\
CALZ_FreCC(liste_fonctions_referencees_par_le_programme); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define GET_PARAMETRES_____editer_le_NOM_SYNTHETIQUE_de_la_commande_courante \
Bblock \
Test(IL_FAUT(editer_le_NOM_SYNTHETIQUE_de_la_commande_courante)) \
Bblock \
CALS(Fsauts_de_lignes(UN)); \
CAL3(Prme2("%s%s" \
,"Nom 'synthetique' de la commande courante puis en-tete des variables d'environnement :\n" \
,"------------------------------------------------------------------------------------\n" \
) \
); \
CALS(Fsauts_de_lignes(DEUX)); \
/* Par "symetrie" avec les autres editions, le 20060613165004, il y a eu passage de "\n" */ \
/* a "\n\n"... */ \
\
CAL3(Prme1("%s\n",NOM_SYNTHETIQUE_DU_FICHIER_COURANT)); \
CAL3(Prme1("%s\n",EN_TETE_DE_titre_attendu_LORS_DES_ENTREES_VIA_DES_SETENV)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define GET_PARAMETRES_____editer_le_NOM_ABSOLU_DU_SOURCE_c_de_la_commande_courante \
Bblock \
Test(IL_FAUT(editer_le_NOM_ABSOLU_DU_SOURCE_c_de_la_commande_courante)) \
Bblock \
CALS(Fsauts_de_lignes(UN)); \
CAL3(Prme2("%s%s" \
,"Nom absolu du source '$c' de la commande courante :\n" \
,"-------------------------------------------------\n" \
) \
); \
CALS(Fsauts_de_lignes(DEUX)); \
CAL3(Prme1("%s\n",FICHIER_COURANT_ABSOLU)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit le 20240104111119... */
#define GET_PARAMETRES_____VALIDATION_DES_CLASSES_DE_SYNONYMES_D_ARGUMENTS \
Bblock \
Test(IZGT(nombre_d_arguments_non_compris_le_nom)) \
/* En effet, 'NUMERO_UNIQUE_maximal_de_l_argument_possible_courant' n'a une valeur */ \
/* significative que si il y a au moins un argument. Alors, dans ces conditions, la */ \
/* procedure 'gPARCOURS_DE_LA_LISTE_DES_ARGUMENTS(...)' est executee et les differentes */ \
/* variables ('NUMERO_UNIQUE_maximal_de_l_argument_possible_courant' en particulier) */ \
/* sont evaluees... */ \
Bblock \
DEFV(Positive,INIT(validation_de_____nombre_d_arguments_possibles_regroupes_par_classe_de_synonymes \
,NBRE(PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
,NUMERO_UNIQUE_maximal_de_l_argument_possible_courant \
) \
) \
); \
\
Test(IFNE(nombre_d_arguments_possibles_regroupes_par_classe_de_synonymes \
,validation_de_____nombre_d_arguments_possibles_regroupes_par_classe_de_synonymes \
) \
) \
/* Test introduit le 20081117092814... */ \
Bblock \
PRINT_ERREUR("le calcul du nombre maximal d'arguments regroupes en classe de synonymes est mauvais"); \
CAL1(Prer2("(ce nombre maximal vaut %d alors qu'il devrait valoir %d)\n" \
,nombre_d_arguments_possibles_regroupes_par_classe_de_synonymes \
,validation_de_____nombre_d_arguments_possibles_regroupes_par_classe_de_synonymes \
) \
); \
/* Notons que 'nombre_d_arguments_possibles_regroupes_par_classe_de_synonymes' est */ \
/* calcule via 'v $xcc/cpp$Z NoMbRe_PaRaMeTrEs...CA..fichier_ListePc....WCl' (rappel */ \
/* fait le 20201013111746 suite a 'v $xrs/surfaces.13$I 20201012170616'). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* A cause de 'v $xi/INCLUDES_min$I VALIDATION_DES_CLASSES_DE_SYNONYMES_D_ARGUMENTS' */ \
/* cette procedure fut introduite le 20210924120633... */
#define GET_PARAMETRES_____lister_les_parametres_non_parfaitement_reconnus \
Bblock \
Test(IFET(IL_FAUT(lister_les_parametres_non_parfaitement_reconnus) \
,IFNE(nombre_d_arguments_recuperes,PRED(nombre_effectif_d_arguments)) \
) \
) \
/* Le 'PRED(...)' est destine au fait que le 1996062700 le nom de la commande a ete */ \
/* reintroduit dans la liste des arguments explores afin de lutter contre le probleme */ \
/* des commandes sans arguments utilisant 'VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(...)'. */ \
/* */ \
/* Le 20150530100009 a ete introduite la possibilite d'inhiber la sortie des messages */ \
/* suivants.... */ \
Bblock \
PRINT_ERREUR("un ou plusieurs arguments non reconnus sont presents dans cet appel"); \
CAL1(Prer4("(il y avait %d %s, dont %d %s)\n" \
,nombre_d_arguments_non_compris_le_nom \
,PLURIEL_S("argument",nombre_d_arguments_non_compris_le_nom) \
,nombre_d_arguments_recuperes \
,PLURIEL_S("reconnu",nombre_d_arguments_recuperes) \
) \
); \
PRINT_ERREUR("ou bien, des caracteres parasites se trouvent apres les valeurs d'arguments reconnus"); \
/* Ceci fut introduit le 20051114160351... */ \
PRINT_ERREUR("ou plus rare, un ou plusieurs noms d'arguments sont doublement definis dans cette commande"); \
/* Au passage, cela n'est plus tellement possible a cause d'un nouveau dispositif */ \
/* introduit dans 'v $xcc/cpp$Z 20050623092735' et qui detecte a la compilation */ \
/* l'integralite des eventuelles doubles definitions d'options, mais on ne sait jamais... */ \
PRINT_ERREUR("ou enfin, les valeurs de certains arguments ne respectent pas leur format et/ou leurs bornes"); \
/* Ceci fut introduit le 20051117110846... */ \
\
Test(EST_VRAI(IL_PEUT_Y_AVOIR_CONFUSION_ENTRE_DEUX_COMMANDES_DE_MEME_NOM_DANS_xcg_ET_xci)) \
/* L'indicateur 'IL_PEUT_Y_AVOIR_CONFUSION_ENTRE_DEUX_COMMANDES_DE_MEME_NOM_DANS_xcg_ET_xci' */ \
/* n'existe pas reellement et est uniquement destine a inhiber ou a autoriser la sequence */ \
/* suivante via 'v $xcc/cpp$Z IL_PEUT_Y_AVOIR_CONFUSION_ENTRE_DEUX_COMMANDES_DE_MEME_NOM.'. */ \
/* Ceci a ete introduit le 20050905163907 a cause des programmes suivants (a cette date) : */ \
/* */ \
/* COHX.01$K */ \
/* COSX.01$K */ \
/* RACX.01$K */ \
/* SIHX.01$K */ \
/* SINX.01$K */ \
/* TAHX.01$K */ \
/* TANX.01$K */ \
/* XY_RT$K */ \
/* scale$K */ \
/* */ \
/* qui existent simultanement dans '$xcg' et dans '$xci'. On notera au passage qu'il existe */ \
/* pour l'un d'eux un dispositif specifique ('v $xcg/scale$K 20020606141416'). */ \
/* */ \
/* On notera enfin que l'on ne teste que '$xcg' et '$xci' parce qu'ils sont declares dans */ \
/* '$PATH'. Ce n'est pas le cas, par exemple, de '$xrv' qui n'est donc pas teste... Ainsi, */ \
/* seuls les directories de '$PATH' sont testes ; pour ceux qui ne figurent pas dans */ \
/* '$PATH' ils ne sont pas testes, mais cela est sans importance car il n'est pas possible */ \
/* d'appeler une commande hors de son directory d'appartenance si son nom n'est pas absolu, */ \
/* il n'y a donc pas du tout les memes risques de confusion qu'avec les commandes qui */ \
/* appartiennent aux directories figurant dans '$PATH'... */ \
Bblock \
Test(IFET(PAS_D_ERREUR(Ftest_fichier("NOM_DE_LA_COMMANDE_DANS_xcg" \
,NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS \
) \
) \
,PAS_D_ERREUR(Ftest_fichier("NOM_DE_LA_COMMANDE_DANS_xci" \
,NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DES_FICHIERS \
) \
) \
) \
) \
/* Ainsi, a compter du 20050906091714, l'existence de deux '$X' de meme nom figurant a la */ \
/* fois dans '$xcg' et dans '$xci' est teste dynamiquement. On notera que les symboles */ \
/* 'NOM_DE_LA_COMMANDE_DANS_xcg' et 'NOM_DE_LA_COMMANDE_DANS_xci' n'existent pas reellement */ \
/* et que leur valeur est define par 'v $xcc/cpp$Z NOM_DE_LA_COMMANDE_DANS_xc.'. */ \
Bblock \
PRINT_ERREUR("ou encore, il y a CONFUSION entre deux '$X' de meme nom dans '$xcg' et dans '$xci'"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
CAL1(Prer0("\n")); \
CAL1(Prer0("\n")); \
\
CAL1(Prer1("Pour la commande '%s', ont ete reconnus (ou pas...) les arguments :\n\n",NOM_DE_LA_COMMANDE)); \
gPARCOURS_DE_LA_LISTE_DES_ARGUMENTS(nombre_effectif_d_arguments \
,BLOC(Test(IFNE(numero_d_argument_courant,NUMERO_ARGUMENT_COMMANDE)) \
Bblock \
CAL1(Prer2("%d fois : %s\n" \
,IdTb1(compteur_reconnaissance_des_arguments_presents \
,INDX(numero_d_argument_courant \
,NUMERO_ARGUMENT_COMMANDE \
) \
,nombre_d_arguments_y_compris_le_nom \
) \
,ITb1(arguments \
,INDX(numero_d_argument_courant \
,NUMERO_ARGUMENT_COMMANDE \
) \
) \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
) \
); \
/* ATTENTION, autrefois, il y avait : */ \
/* */ \
/* CAL1(Prer3("%0*d fois : %s\n" */ \
/* ,TRPU(INTE(LO1X(_____BEAUCOUP))) */ \
/* ,IdTb1(compteur_reconnaissance_des_arguments_presents */ \
/* ,INDX(numero_d_argument_courant */ \
/* ,NUMERO_ARGUMENT_COMMANDE */ \
/* ) */ \
/* ,nombre_d_arguments_y_compris_le_nom */ \
/* ) */ \
/* ,ITb1(arguments */ \
/* ,INDX(numero_d_argument_courant */ \
/* ,NUMERO_ARGUMENT_COMMANDE */ \
/* ) */ \
/* ) */ \
/* ) */ \
/* ); */ \
/* */ \
/* mais en fait, il est evident qu'un argument ne peut etre reconnu que 0 (c'est-a-dire */ \
/* non reconnu) ou 1 (c'est-a-dire reconnu) fois. En consequence de quoi, le format "%d" */ \
/* est suffisant pour garantir une bonne tabulation... */ \
CAL1(Prer0("\n")); \
\
CODE_ERROR(ERREUR33); \
/* Introduit le 20110224105948... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define GET_PARAMETRES_____editer_les_commandes_avant_execution \
Bblock \
Test(IL_FAUT(editer_les_commandes_avant_execution)) \
Bblock \
DEFV(CHAR,INIC(POINTERc(commande_primaire_courante),CHAINE_UNDEF)); \
RECONSTITUTION_DE_LA_COMMANDE_COURANTE(commande_primaire_courante); \
/* Reconstitution de la commande courante... */ \
CALS(Fsauts_de_lignes(UN)); \
CAL3(Prme2("%s%s" \
,"Edition des commandes et de leurs parametres avant execution :\n" \
,"------------------------------------------------------------\n" \
) \
); \
CALS(Fsauts_de_lignes(DEUX)); \
\
CAL3(Prme1("CommandePrimaire=%s\n",commande_primaire_courante)); \
/* Edition de la commande courante (dite "primaire"...) avant son execution. */ \
CALZ_FreCC(commande_primaire_courante); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define GET_PARAMETRES_____lister_tous_les_messages_possibles \
Bblock \
Test(IL_FAUT(lister_tous_les_messages_possibles)) \
Bblock \
CALS(Fsauts_de_lignes(UN)); \
CAL3(Prme2("%s%s" \
,"Liste des messages recuperables de type '...nom=...valeur...' editables par cette commande :\n" \
,"------------------------------------------------------------------------------------------\n" \
) \
); \
CALS(Fsauts_de_lignes(UN)); \
/* Par "symetrie" avec les autres editions, le 20060613165004, il y a eu passage de "\n\n" */ \
/* a "\n"... */ \
/* */ \
/* Le 20090803163803, furent introduits les '...'s car, en effet, sont recuperes en */ \
/* fait ici tous les messages qui contiennent "...=...%...". Cela correspond a beaucoup */ \
/* de choses et donne par exemple "2-soit d'utiliser l'option 'ValiderAxes=%s' pour..." */ \
/* qui n'est pas d'une grande utilite... */ \
\
G_LISTER_TOUS_LES_MESSAGES_POSSIBLES(); \
/* ATTENTION, ceci n'est pas l'appel a une fonction, mais uniquement un code destine */ \
/* a 'v $xcc/cpp$Z G_LISTER_TOUS_LES_MESSAGES_POSSIBLES' afin qu'il mette en place le */ \
/* code d'edition de tous les messages possibles... */ \
\
CAL1(Prer0("\n")); \
CAL2(Prin0("\n")); \
CALS(FPrme0("\n")); \
/* "Fermeture" de la liste de la plupart des messages. ATTENTION, etant donne que les */ \
/* messages ci-dessus peuvent utiliser indifferement 'Prer?(...)', 'Prin?(...)' et */ \
/* 'Prme?(...)', il faut utiliser ces trois directives pour "fermer" et ainsi etre sur */ \
/* d'avoir un "\n" en fin du fichier de liste... */ \
/* */ \
/* Le 20050126102747 les appels 'CAL3\(Prer0(...))' et 'CAL3\(Prin0(...))' ont ete remplaces */ \
/* respectivement par 'CAL1\(Prer0(...))' et 'CAL2\(Prin0(...))'. Cela correspond a la */ \
/* definition des procedures 'CALi(...)' mais est-ce correct par rapport aux commentaires */ \
/* precedents ? */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define GET_PARAMETRES_____ne_rien_faire_et_sortir_immediatement \
Bblock \
Test(IL_FAUT(ne_rien_faire_et_sortir_immediatement)) \
Bblock \
ABORT_Commande; \
/* Cette possibilite a ete introduite le 20061110090803 afin de permettre de tester qu'un */ \
/* certain '$X' peut s'executer et qu'en particulier il est compatible avec les '$SO' dont */ \
/* il a besoin... */ \
/* */ \
/* On notera qu'evidemment, aucun message n'est emis, contrairement a ce qui est fait */ \
/* ci-apres, par exemple, si 'IL_FAUT(editer_la_valeur_des_parametres_d_une_commande)'... */ \
/* */ \
/* Le 20180316110607, 'ABORT_Commande' a remplace 'Exit(OK);'... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define GET_PARAMETRES_____forcer_l_execution_malgre_les_editions_demandees \
Bblock \
Test(IL_NE_FAUT_PAS(forcer_l_execution_malgre_les_editions_demandees)) \
/* Introduit le 20170604111437... */ \
Bblock \
Test(IFOU(IL_FAUT(editer_tout_ce_est_utile_concernant_le_fonctionnement_et_l_utilisation) \
,I3OU(I6OU(IL_FAUT(editer_la_valeur_des_parametres_d_une_commande) \
,IL_FAUT(editer_les_differentes_variables_d_environnement_utiles) \
,IL_FAUT(editer_le_nom_des_parametres_non_generes_d_une_commande) \
,IL_FAUT(editer_le_NOM_SYNTHETIQUE_de_la_commande_courante) \
,IL_FAUT(editer_le_NOM_ABSOLU_DU_SOURCE_c_de_la_commande_courante) \
,IL_FAUT(lister_tous_les_messages_possibles) \
) \
,I6OU(IL_FAUT(permettre_l_acces_au_source_du_programme) \
,IL_FAUT(permettre_l_acces_a_la_liste_des_fonctions_referencees_par_le_programme) \
,IL_FAUT(editer_les_differentes_versions_du_programme) \
,IL_FAUT(editer_les_differentes_versions_du_programme_dans_les_librairies_dynamiques) \
,IL_FAUT(editer_la_liste_des_librairies_dynamiques_utilisees) \
,IL_FAUT(editer_les_differents_includes_du_programme) \
) \
,IL_FAUT(editer_les_differents_bugs_reconnus) \
) \
) \
) \
/* Le test de 'editer_tout_ce_est_utile_concernant_le_fonctionnement_et_l_utilisation' a */ \
/* ete introduit le 20091027135802... */ \
/* */ \
/* Le test de 'editer_les_differentes_versions_du_programme_dans_les_librairies_dynamiques' */ \
/* a ete introduit le 20111009110606 car, en effet, il manquait... */ \
/* */ \
/* Le test de 'editer_la_liste_des_librairies_dynamiques_utilisees' a ete introduit le */ \
/* 20220824180116... */ \
Bblock \
CAL1(Prer0("\n\n")); \
PRINT_ATTENTION("l'une des options demandees provoque l'arret immediat de cette commande"); \
\
Test(IL_FAUT(PRINT_ATTENTION_____editer_les_messages)) \
/* Ce test a ete introduit le 20020520114922 a cause de l'usage qui est fait de l'argument */ \
/* "ATTENTION=FAUX" dans l'alias 'v $xE/.alias.2$vv$Y alias.....use'. */ \
Bblock \
CAL1(Prer0("(a savoir ")); \
CAL1(Prer1("'All=%s'",C_VRAI____)); \
CAL1(Prer0(", ")); \
CAL1(Prer1("'Bugs=%s'",C_VRAI____)); \
CAL1(Prer0(", ")); \
CAL1(Prer1("'Includes=%s'",C_VRAI____)); \
CAL1(Prer0(", ")); \
CAL1(Prer1("'ListeFonctions=%s'",C_VRAI____)); \
CAL1(Prer0(", ")); \
CAL1(Prer1("'ListerMessages=%s'",C_VRAI____)); \
CAL1(Prer0(", ")); \
CAL1(Prer1("'NomSynthetique=%s'",C_VRAI____)); \
CAL1(Prer0(", ")); \
CAL1(Prer1("'NomAbsoluSource=%s'",C_VRAI____)); \
CAL1(Prer0(", ")); \
CAL1(Prer1("'Parametres=%s'",C_VRAI____)); \
CAL1(Prer0(", ")); \
CAL1(Prer1("'ParametresNonGeneres=%s'",C_VRAI____)); \
CAL1(Prer0(", ")); \
CAL1(Prer1("'Setenv=%s'",C_VRAI____)); \
CAL1(Prer0(", ")); \
CAL1(Prer1("'SourceProgramme=%s'",C_VRAI____)); \
CAL1(Prer0(", ")); \
CAL1(Prer1("'Versions=%s'",C_VRAI____)); \
CAL1(Prer0(", ")); \
CAL1(Prer1("'VersionsSO=%s'",C_VRAI____)); \
CAL1(Prer0(" ou enfin ")); \
CAL1(Prer2("'LibrairiesDynamiques=%s''LibDyn=%s'",C_VRAI____,C_VRAI____)); \
/* Le 20060316174102 furent introduits les 'C_VRAI____'s... */ \
/* */ \
/* L'argument "All=" a ete introduit le 20091027121953... */ \
/* */ \
/* L'argument "VersionsSO=" a ete introduit le 20111009111159... */ \
/* */ \
/* L'argument "LibDynam=" a ete introduit le 20220824182311... */ \
CAL1(Prer0(")\n")); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
ABORT_Commande; \
/* Lorsque l'edition des parametres est demandee, on sort immediatement afin d'eviter de */ \
/* "faire des degats" ; en effet, en general, dans ce cas rien n'a ete defini, et alors */ \
/* on peut etre amene a creer, par exemple, des fichiers, alors qu'en fait il ne faut pas */ \
/* evidemment. Cela a ete ajoute le 19971107160014. Cela a ete etendu le 19971107160607 */ \
/* a l'acces aux VERSIONs ainsi qu'a celui du source du programme. */ \
/* */ \
/* Le 20180316110607, 'ABORT_Commande' a remplace 'Exit(OK);'... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit sous cette forme le 20221112114434... */
#define ACTIONS_DIVERSES_APRES_TOUTES_LES_ENTREES_DE_PARAMETRES_______GET_PARAMETRES_1 \
Bblock \
GET_PARAMETRES_____editer_les_differentes_variables_d_environnement_utiles; \
/* Introduit sous cette forme le 20221112114434... */ \
/* */ \
/* Cette procedure ne peut etre une fonction dans 'v $xig/fonct$vv$FON' car, en effet, */ \
/* elle demande des donnees locales aux '$K's (et evidemment aux '$c's) des '$X's... */ \
\
GET_PARAMETRES_____editer_les_differentes_versions_du_programme; \
/* Introduit sous cette forme le 20221112114434... */ \
/* */ \
/* Cette procedure ne peut etre une fonction dans 'v $xig/fonct$vv$FON' car, en effet, */ \
/* elle demande des donnees locales aux '$K's (et evidemment aux '$c's) des '$X's... */ \
\
GET_PARAMETRES_____editer_les_differents_includes_du_programme; \
/* Introduit sous cette forme le 20221112114434... */ \
/* */ \
/* Cette procedure ne peut etre une fonction dans 'v $xig/fonct$vv$FON' car, en effet, */ \
/* elle demande des donnees locales aux '$K's (et evidemment aux '$c's) des '$X's... */ \
\
GET_PARAMETRES_____lister_tous_les_messages_possibles; \
/* Introduit sous cette forme le 20221112114434... */ \
/* */ \
/* Cette procedure ne peut etre une fonction dans 'v $xig/fonct$vv$FON' car, en effet, */ \
/* elle demande des donnees locales aux '$K's (et evidemment aux '$c's) des '$X's... */ \
\
GET_PARAMETRES_____editer_le_NOM_SYNTHETIQUE_de_la_commande_courante; \
/* Introduit sous cette forme le 20221112114434... */ \
/* */ \
/* Cette procedure ne peut etre une fonction dans 'v $xig/fonct$vv$FON' car, en effet, */ \
/* elle demande des donnees locales aux '$K's (et evidemment aux '$c's) des '$X's... */ \
\
GET_PARAMETRES_____editer_le_NOM_ABSOLU_DU_SOURCE_c_de_la_commande_courante; \
/* Introduit sous cette forme le 20221112114434... */ \
/* */ \
/* Cette procedure ne peut etre une fonction dans 'v $xig/fonct$vv$FON' car, en effet, */ \
/* elle demande des donnees locales aux '$K's (et evidemment aux '$c's) des '$X's... */ \
Eblock \
/* Introduit sous cette forme le 20221113171642... */
#define ACTIONS_DIVERSES_APRES_TOUTES_LES_ENTREES_DE_PARAMETRES_______GET_PARAMETRES_2 \
Bblock \
Eblock \
/* Introduit sous cette forme le 20221113171642 et modifie le 20221113180928... */
#define ACTIONS_DIVERSES_APRES_TOUTES_LES_ENTREES_DE_PARAMETRES_____FgGET_PARAMETRES \
Bblock \
CALS(FgGET_PARAMETRES_____editer_la_liste_des_librairies_dynamiques_utilisees()); \
/* Introduit sous cette forme le 20221112114434... */ \
\
CALS(FgGET_PARAMETRES_____permettre_l_acces_a_la_liste_des_fonctions_referencees()); \
/* Introduit sous cette forme le 20221112114434 et comme fonction le 20221112135642... */ \
\
CALS(FgGET_PARAMETRES_____editer_les_differents_bugs_reconnus()); \
/* Introduit sous cette forme le 20221112114434 et comme fonction le 20221112135642... */ \
\
CALS(FgGET_PARAMETRES_____permettre_l_acces_au_source_du_programme()); \
/* Introduit sous cette forme le 20221112114434 et comme fonction le 20221112135642... */ \
\
CALS(FgGET_PARAMETRES_____VALIDATION_DES_CLASSES_DE_SYNONYMES_D_ARGUMENTS()); \
/* Mis sous cette forme le 20210924120633... */ \
\
CALS(FgGET_PARAMETRES_____editer_les_commandes_avant_execution()); \
/* Introduit sous cette forme le 20221112114434... */ \
\
CALS(FgGET_PARAMETRES_____lister_les_parametres_non_parfaitement_reconnus()); \
/* Introduit sous cette forme le 20221112114434 et mis ici le 20221115134128... */ \
\
CALS(FgGET_PARAMETRES_____forcer_l_execution_malgre_les_editions_demandees()); \
/* Introduit sous cette forme le 20221112114434 et mis ici le 20221115134128... */ \
\
CALS(FgGET_PARAMETRES_____ne_rien_faire_et_sortir_immediatement()); \
/* Introduit sous cette forme le 20221112114434 et mis ici le 20221115134128... */ \
Eblock \
/* Introduit sous cette forme le 20221113171642... */
#define GET_PARAMETRES(nombre_d_arguments_y_compris_le_nom,La,liste_de_recuperation_1,action_intermediaire,liste_de_recuperation_2) \
/* Ou 'La' designe 'liste_des_arguments'... */ \
Bblock \
\
__NEW_LINE__ \
%mdefine FICHIER_DE_BASE_ABSOLU_x FICHIER_COURANT_ABSOLU_x \
__NEW_LINE__ \
/* Introduit le 20190809094118 pour 'GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(...)' */ \
/* afin qu'elle puisse editer le nom du '$c' de base (a la racine des 'include's...). On */ \
/* notera le 'mdefine' (et non pas un 'define') et ce au cas ou il y aurait plusieurs appels */ \
/* a 'GET_PARAMETRES(...)'. On rappelle que lorsque l'on execute 'GET_PARAMETRES(...)' on */ \
/* est necessairement a la racine des 'include's et ainsi 'FICHIER_COURANT_ABSOLU_x' a la */ \
/* bonne valeur... */ \
/* */ \
/* On notera le 20190809105456 que 'FICHIER_DE_BASE_ABSOLU_x' n'est pas defini pour les */ \
/* librairies puisque les '$K's correspondant n'utilisent pas 'GET_PARAMETRES(...)' et */ \
/* ainsi, 'NOM_DE_LA_COMMANDE (utilise par 'v $xig/fonct$vv$FON BASIQUE____Prer' en */ \
/* particulier) ne peut etre, malheureusement, remplace par 'FICHIER_DE_BASE_ABSOLU_x' */ \
/* (dont l'avantage est d'etre un nom absolu, alors que 'NOM_DE_LA_COMMANDE' est relatif */ \
/* ou absolu, suivant la nature de l'appel du '$X' correspondant...). */ \
\
/* Le 20221113114530, 'nombre_d_arguments_non_compris_le_nom' est devenue une variable */ \
/* globale definie dans 'v $xil/defi_c1$vv$DEF 20221113114253'... */ \
\
EGAL(nombre_effectif_d_arguments,nombre_d_arguments_y_compris_le_nom); \
/* Nombre effectifs d'arguments. */ \
EGAL(nombre_d_arguments_recuperes,ZERO); \
/* Afin de comptabiliser les arguments corrects recuperes. La mise a 0 a ete rajoutee le */ \
/* 20000801165648 car elle manquait et rendait incorrect la "re-rentree" dans le 'Main(...)' */ \
/* faite par 'v $xiii/files$FON Iload_image_avec_redimensionnement_eventuel'... */ \
\
cpMalo(IDENTITE_des_arguments_presents \
,bMUL(nombre_d_arguments_y_compris_le_nom,size_PointerInt) \
,GET_PARAMETRES_____compteur_des_cpMalo \
); \
/* Liste d'identite des arguments presents. */ \
ciMalo(compteur_reconnaissance_des_arguments_presents \
,bMUL(nombre_d_arguments_y_compris_le_nom,size_Int) \
,GET_PARAMETRES_____compteur_des_ciMalo \
); \
/* Compteur de reconnaissance de chacun des arguments presents. */ \
\
EGAL(pointeurV_parametre_fictif_IDENTITE_des_arguments,aIDENTITE(parametre_fictif_IDENTITE_des_arguments)); \
EGAL(pointeurC_parametre_fictif_IDENTITE_des_arguments,pointeurV_parametre_fictif_IDENTITE_des_arguments); \
/* Parametre fictif destine uniquement a simplifier la gestion du vecteur */ \
/* 'IDENTITE_des_arguments_presents' et ses deux pointeurs, le premier non type */ \
/* et le second nous amenant dans l'unite de base (celle des caracteres...). */ \
\
/* ATTENTION, jusqu'au 19970217132121, on trouvait ici : */ \
/* */ \
/* EGAL(nom_de_la_commande_courante,chain_Acopie(NOM_DE_LA_COMMANDE)); */ \
/* */ \
/* mais, malheureusement, de nombreux programmes peuvent editer des messages d'erreur */ \
/* avant de passer dans 'GET_PARAMETRES(...)' ('v $xrr/N_corps.11$K'). Cette initialisation */ \
/* est faite dorenavant dans 'BCommande(...)'. */ \
\
gPARCOURS_DE_LA_LISTE_DES_ARGUMENTS(nombre_effectif_d_arguments \
,BLOC(EGAL(IdTb1(IDENTITE_des_arguments_presents \
,INDX(numero_d_argument_courant,NUMERO_ARGUMENT_COMMANDE) \
,nombre_d_arguments_y_compris_le_nom \
) \
,ADRESSE_NON_ENCORE_DEFINIE \
); \
/* Initialisation de la liste des arguments presents... */ \
CLIR(IdTb1(compteur_reconnaissance_des_arguments_presents \
,INDX(numero_d_argument_courant,NUMERO_ARGUMENT_COMMANDE) \
,nombre_d_arguments_y_compris_le_nom \
) \
); \
/* Initialisation du detecteur de reconnaissance des arguments... */ \
) \
); \
\
PARCOURS_DE_LA_LISTE_DES_ARGUMENTS(nombre_effectif_d_arguments \
,BLOC(BLOC(liste_de_recuperation_1); \
/* Premieres definitions... */ \
) \
); \
\
BLOC(action_intermediaire); \
/* Execution d'une certaine action entre les deux listes... */ \
\
PARCOURS_DE_LA_LISTE_DES_ARGUMENTS(nombre_effectif_d_arguments \
,BLOC(BLOC(liste_de_recuperation_2); \
/* Autres definitions eventuellement... */ \
) \
); \
\
GET_PARAMETRES_____tester_la_double_definition_des_parametres(nombre_d_arguments_y_compris_le_nom,La); \
/* Introduit sous cette forme le 20221112114434... */ \
\
ACTIONS_DIVERSES_APRES_TOUTES_LES_ENTREES_DE_PARAMETRES_______GET_PARAMETRES_1; \
/* Introduit sous cette forme le 20221112114434... */ \
\
ACTIONS_DIVERSES_APRES_TOUTES_LES_ENTREES_DE_PARAMETRES_____FgGET_PARAMETRES; \
/* Introduit sous cette forme le 20221112114434... */ \
/* */ \
/* ATTENTION : il faut en premier '__GET_PARAMETRES' et en second 'FgGET_PARAMETRES' et */ \
/* ce a cause des tests 'v $xig/fonct$vv$DEF 20221113175029' qui doivent editer en */ \
/* quelque sorte un separateur entre '__GET_PARAMETRES' et 'FgGET_PARAMETRES'... */ \
\
ACTIONS_DIVERSES_APRES_TOUTES_LES_ENTREES_DE_PARAMETRES_______GET_PARAMETRES_2; \
/* Introduit sous cette forme le 20221113180928 et doit evidemment etre en dernier */ \
/* puisqu'elle provoque la sortie immediate, mais ce n'est plus le cas a compter du */ \
/* 20221115134128... */ \
\
CALZ_FreII(compteur_reconnaissance_des_arguments_presents); \
CALZ_FrePP(IDENTITE_des_arguments_presents); \
/* Liberation des vecteurs relatifs a la reconnaissance des arguments presents... */ \
Eblock \
/* Procedure de recuperation d'une liste de parametres. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R O C E D U R E S ' GIT_ARGUMENT_?(...) ' : */
/* */
/*************************************************************************************************************************************/
#define VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(parametre,non_encore_defini_1,non_encore_defini_2,va_defaut) \
COND(IFET(EST_VRAI(c_est_la_derniere_recherche_des_parametres) \
,IFOU(IFEQ(parametre,non_encore_defini_1) \
,IFEQ(parametre,non_encore_defini_2) \
) \
) \
,va_defaut \
,parametre \
) \
/* Procedure permettant de forcer 'va_defaut' pour 'parametre' si il possede la */ \
/* valeur 'non_encore_defini', mais uniquement lors de la derniere recherche de parametres. */ \
/* Ceci est necessaire au cas ou un certain parametre doit etre initialise via, par exemple, */ \
/* '_____?NORMALISE_OX(...)' car, en effet, cela n'a de sens qu'apres que '$formatI' ait ete */ \
/* interprete (si '$formatI' est presente bien entendu...). */ \
/* */ \
/* ATTENTION, utiliser 'VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(...)' et donc les differentes */ \
/* procedures qui l'utilisent (par exemple 'GIT_ARGUMENT_I(...)') implique la presence */ \
/* d'au moins un argument d'appel pour la commande si l'on veut que les initialisations */ \
/* correspondantes soient faites. C'est pourquoi, le 1996062700 a ete reintroduit le nom */ \
/* de la commande dans la liste des arguments explores... */ \
/* */ \
/* ATTENTION, je note le 20070819113024 que 'VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(...)' */ \
/* ne fonctionne bien que si 'non_encore_defini' est une valeur qui ne peut etre demandee */ \
/* pour 'parametre'. Cela explique donc que 'VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(...)' ne */ \
/* peut etre utilisee avec, par exemple, 'GIT_ARGUMENT_L(...)' pour laquelle 'LUNDEF' vaut */ \
/* en fait 'VRAI' qui est donc une valeur possible (et frequente). C'est donc le cas de : */ \
/* */ \
/* GIT_ARGUMENT_C(...) */ \
/* GIT_ARGUMENT_K(...) */ \
/* GIT_ARGUMENT_L(...) */ \
/* GIT_ARGUMENT_N(...) */ \
/* GIT_ARGUMENT_P(...) */ \
/* */ \
/* qui a la date du 20070819130744 ne sont pas utilisees (ni dans '$xc', ni dans '$xr', ni */ \
/* dans '$xt') en fait. C'est pourquoi, a la date du 20070819132949 et du 20070819135021, */ \
/* je les desactive provisoirement (?) via '#nydefine'... */ \
/* */ \
/* Mais, meme pour les autres procedures, 'VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(...)' n'est */ \
/* pas fiable a 100%. Par exemple avec 'GIT_ARGUMENT_I(...)', la valeur 'UNDEF', bien que */ \
/* peu probable, n'est pas impossible... */ \
/* */ \
/* Le 20101020105725, l'argument 'non_encore_defini' a ete dedouble en */ \
/* {non_encore_defini_1,non_encore_defini_2} afin de prendre en compte, en particulier, */ \
/* les valeurs 'FLOT__UNDEF' et 'FLOT__NIVEAU_UNDEF'. Cela s'est vu a cette date lors de */ \
/* la generation de 'v $xiac/VONK.52$R16' qui fut dans un premier temps quasiment invisible. */ \
/* Cela etait du a la variable 'v $xrv/champs_5.26$I niveau_du_champ_NOIR_et_BLANC' qui */ \
/* etait initialise avec 'FLOT__NIVEAU_UNDEF' (qui vaut 'NOIR') et non pas avec */ \
/* 'FLOT__UNDEF' que testait 'v $xrv/champs_5.1A$I NIVEAU_DU_CHAMP_NOIR_et_BLANC'... */ \
/* Evidemment s'il n'y a qu'une seule valeur 'non_encore_defini' a tester, les deux */ \
/* aguments 'non_encore_defini_1' et 'non_encore_defini_2' devront etre egaux... */
#nydefine GIT_ARGUMENT_K(titre_attendu,parametre_K,valeur_K_par_defaut) \
Bblock \
GET_PARAMETRE_K(arguments \
,titre_attendu \
,parametre_K \
,valeur_K_par_defaut \
); \
Eblock \
/* Recuperation d'un argument "caractere" avec initialisation systematique. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* GIT_ARGUMENT_K("titre1=",variable,initialisation); */ \
/* GIT_ARGUMENT_K("titre2=",variable,initialisation); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */ \
/* */ \
/* ATTENTION : je note le 20070819113024 que l'on ne peut pas utiliser ici la procedure */ \
/* 'VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(...)' car, en effet, 'K_UNDEF' est une valeur */ \
/* possible (et probable) de 'parametre_K'... */
#nydefine GIT_ARGUMENT_C(titre_attendu,parametre_C,valeur_C_par_defaut) \
Bblock \
GET_PARAMETRE_C(arguments \
,titre_attendu \
,parametre_C \
,valeur_C_par_defaut \
); \
Eblock \
/* Recuperation d'un argument "chaine de caracteres" avec initialisation systematique. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* GIT_ARGUMENT_C("titre1=",variable,initialisation); */ \
/* GIT_ARGUMENT_C("titre2=",variable,initialisation); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */ \
/* */ \
/* ATTENTION : je note le 20070819113024 que je ne sais par si l'on peut utiliser ici la */ \
/* procedure 'VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(...)' car, en effet, je ne sais pas a */ \
/* priori qu'elle est la valeur de type "UNDEF" de 'parametre_C'... */
#nydefine GIT_ARGUMENT_L(titre_attendu,parametre_L,valeur_L_par_defaut) \
Bblock \
GET_PARAMETRE_L(arguments \
,titre_attendu \
,parametre_L \
,valeur_L_par_defaut \
); \
Eblock \
/* Recuperation d'un argument "Logical" avec initialisation systematique. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* GIT_ARGUMENT_L("titre1=",variable,initialisation); */ \
/* GIT_ARGUMENT_L("titre2=",variable,initialisation); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */ \
/* */ \
/* ATTENTION : je note le 20070819113024 que l'on ne peut pas utiliser ici la procedure */ \
/* 'VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(...)' car, en effet, 'LUNDEF' est une valeur */ \
/* possible (et probable) de 'parametre_L'... */
#nydefine GIT_ARGUMENT_N(titre_attendu,parametre_N,valeur_N_par_defaut) \
Bblock \
GET_PARAMETRE_N(arguments \
,titre_attendu \
,parametre_N \
,valeur_N_par_defaut \
); \
Eblock \
/* Recuperation d'un argument "Logical" inverse (ou "Negate") avec initialisation */ \
/* systematique. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* GIT_ARGUMENT_N("titre1=",variable,initialisation); */ \
/* GIT_ARGUMENT_N("titre2=",variable,initialisation); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */ \
/* */ \
/* ATTENTION : je note le 20070819113024 que l'on ne peut pas utiliser ici la procedure */ \
/* 'VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(...)' car, en effet, 'LUNDEF' est une valeur */ \
/* possible (et probable) de 'parametre_N'... */
#define GIT_ARGUMENT_I(titre_attendu,parametre_I,valeur_I_par_defaut) \
Bblock \
Test(IFOU(IZEQ(UNDEF),IZEQ(UNDEF))) \
/* Test introduit le 20101025135756 car, en effet, si 'UNDEF' a une valeur nulle, il */ \
/* devient impossible de savoir si une variable n'est pas encore definie ou bien si elle */ \
/* a ete initialisee (a la compilation ou bien en tant qu'argument d'un '$K'...) avec une */ \
/* valeur nulle ! */ \
/* */ \
/* Le double test de 'UNDEF' n'est pas accidentelle : elle est la pour rappeler son double */ \
/* usage dans 'VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(...)' ci-apres. */ \
/* */ \
/* On notera le 20101025141341 que ce test peut etre un peu "lourd", eventuellement repete */ \
/* plusieurs fois dans un '$K' et redondant avec celui de 'v $xcp/Konstantes$K UNDEF'... */ \
Bblock \
PRINT_ATTENTION("les constantes indefinies entieres ne doivent pas etre nulles"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
GET_PARAMETRE_I(arguments \
,titre_attendu \
,parametre_I \
,VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(parametre_I,UNDEF,UNDEF,valeur_I_par_defaut) \
); \
Eblock \
/* Recuperation d'un argument "Int" avec initialisation eventuelle si la variable etait */ \
/* a l'etat 'UNDEF', mais uniquement lors de la derniere recherche de parametres. */ \
/* */ \
/* Le 20101025113324, je suis passe de {UNDEF,NIVEAU_UNDEF} a 'UNDEF' ce qui correspond */ \
/* en fait a la situation anterieure au 20101020105725. En effet, tester 'NIVEAU_UNDEF' */ \
/* est, me semble-t-il, un peu dangeureux car sa valeur est nulle ; il ne pouurait donc */ \
/* pas etre distingue d'une valeur nulle introduite en tant qu'argument d'un '$K'... */
#define GIT_ARGUMENT_F(titre_attendu,parametre_F,valeur_F_par_defaut) \
Bblock \
Test(IFOU(IZEQ(FLOT__UNDEF),IZEQ(FLOT__NIVEAU_UNDEF))) \
/* Test introduit le 20101025135756 car, en effet, si '*_UNDEF' ont une valeur nulle, il */ \
/* devient impossible de savoir si une variable n'est pas encore definie ou bien si elle */ \
/* a ete initialisee (a la compilation ou bien en tant qu'argument d'un '$K'...) avec une */ \
/* valeur nulle ! */ \
/* */ \
/* On notera le 20101025141341 que ce test peut etre un peu "lourd", eventuellement repete */ \
/* plusieurs fois dans un '$K' et redondant avec celui de 'v $xcp/Konstantes$K UNDEF'... */ \
Bblock \
PRINT_ATTENTION("les constantes indefinies flottantes ne doivent pas etre nulles"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
GET_PARAMETRE_F(arguments \
,titre_attendu \
,parametre_F \
,VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(parametre_F,FLOT__UNDEF,FLOT__NIVEAU_UNDEF,valeur_F_par_defaut) \
); \
Eblock \
/* Recuperation d'un argument "Float" avec initialisation eventuelle si la variable etait */ \
/* a l'etat 'FLOT__UNDEF', mais uniquement lors de la derniere recherche de parametres. */ \
/* */ \
/* Le 20101025114210, l'introduction de {FLOT__UNDEF,FLOT__NIVEAU_UNDEF} le 20101020105725 */ \
/* me parait dangereuse car, en effet, a cette date 'FLOT__NIVEAU_UNDEF' a une valeur nulle */ \
/* que l'on ne pourra donc distinguer d'une valeur nulle introduite en tant qu'argument */ \
/* d'un '$K', d'ou la modification 'v $xiiD/definit.1$DEF 20101025114454' consistant a */ \
/* changer la valeur de 'FLOT__NIVEAU_UNDEF' (egale dorenavant a 'FLOT__UNDEF'...). */
#nydefine GIT_ARGUMENT_P(titre_attendu,parametre_P,valeur_P_par_defaut) \
Bblock \
GET_PARAMETRE_P(arguments \
,titre_attendu \
,parametre_P \
,valeur_P_par_defaut \
); \
Eblock \
/* Recuperation d'un argument "genere_p" avec initialisation systematique. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* GIT_ARGUMENT_P("titre1=",variable,initialisation); */ \
/* GIT_ARGUMENT_P("titre2=",variable,initialisation); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */ \
/* */ \
/* ATTENTION : je note le 20070819135021 que l'on ne peut pas utiliser ici la procedure */ \
/* 'VALEUR_PAR_DEFAUT_POUR_GIT_ARGUMENT(...)' car, en effet, 'NIVEAU_UNDEF' est une valeur */ \
/* possible (et probable) de 'parametre_N'... */
#define PROKISS_ARGUMENT_K(titre_attendu,parametre_K,valeur_K_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_K(arguments,titre_attendu,parametre_K,valeur_K_par_defaut,seq1,seqI,seqC,seqN); \
Eblock \
/* Recuperation d'un argument "caractere" avec initialisation et post-traitement. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* PROCISS_ARGUMENT_K("titre1=",variable,initialisation,seq1,seqI,seqC,seqN); */ \
/* PROCISS_ARGUMENT_K("titre2=",variable,initialisation,seq1,seqI,seqC,seqN); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */
#define PROKISS_ARGUMENT_C(titre_attendu,parametre_C,valeur_C_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_C(arguments,titre_attendu,parametre_C,valeur_C_par_defaut,seq1,seqI,seqC,seqN); \
Eblock \
/* Recuperation d'un argument "chaine de caracteres" avec initialisation et post-traitement. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* PROCISS_ARGUMENT_C("titre1=",variable,initialisation,seq1,seqI,seqC,seqN); */ \
/* PROCISS_ARGUMENT_C("titre2=",variable,initialisation,seq1,seqI,seqC,seqN); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */
#define PROKISS_ARGUMENT_L(titre_attendu,parametre_L,valeur_L_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_L(arguments,titre_attendu,parametre_L,valeur_L_par_defaut,seq1,seqI,seqC,seqN); \
Eblock \
/* Recuperation d'un argument "Logical" avec initialisation et post-traitement. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* PROCISS_ARGUMENT_L("titre1=",variable,initialisation,seq1,seqI,seqC,seqN); */ \
/* PROCISS_ARGUMENT_L("titre2=",variable,initialisation,seq1,seqI,seqC,seqN); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */
#define PROKISS_ARGUMENT_N(titre_attendu,parametre_N,valeur_N_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_N(arguments,titre_attendu,parametre_N,valeur_N_par_defaut,seq1,seqI,seqC,seqN); \
Eblock \
/* Recuperation d'un argument "Logical" inverse (ou "Negate") avec initialisation et */ \
/* post-traitement. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* PROCISS_ARGUMENT_N("titre1=",variable,initialisation,seq1,seqI,seqC,seqN); */ \
/* PROCISS_ARGUMENT_N("titre2=",variable,initialisation,seq1,seqI,seqC,seqN); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */
#define PROKISS_ARGUMENT_I(titre_attendu,parametre_I,valeur_I_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_I(arguments \
,titre_attendu \
,parametre_I \
,COND(IFET(EST_VRAI(le_format_des_images_a_ete_defini) \
,IFEQ(parametre_I,UNDEF) \
) \
,valeur_I_par_defaut \
,parametre_I \
) \
,seq1 \
,seqI \
,seqC \
,seqN \
); \
Eblock \
/* Recuperation d'un argument "Int" avec initialisation et post-traitement. */ \
/* */ \
/* L'initialisation n'a lieu que si la variable etait a l'etat 'UNDEF' et seulement */ \
/* apres la definition du format des images, puisqu'en effet, cette definition peut etre */ \
/* une fonction de ce meme format... */
#define PROKISS_ARGUMENT_X(titre_attendu,parametre_X,valeur_X_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_X(arguments \
,titre_attendu \
,parametre_X \
,COND(IFET(EST_VRAI(le_format_des_images_a_ete_defini) \
,IFEQ(parametre_X,UNDEF) \
) \
,valeur_X_par_defaut \
,parametre_X \
) \
,seq1 \
,seqI \
,seqC \
,seqN \
); \
Eblock \
/* Recuperation d'un argument "Int" avec initialisation et post-traitement avec edition */ \
/* hexa-decimale (introduit le 20070421093557). */ \
/* */ \
/* L'initialisation n'a lieu que si la variable etait a l'etat 'UNDEF' et seulement */ \
/* apres la definition du format des images, puisqu'en effet, cette definition peut etre */ \
/* une fonction de ce meme format... */
#define PROKISS_ARGUMENT_F(titre_attendu,parametre_F,valeur_F_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_F(arguments \
,titre_attendu \
,parametre_F \
,COND(IFET(EST_VRAI(le_format_des_images_a_ete_defini) \
,IFEQ(parametre_F,FLOT__UNDEF) \
) \
,valeur_F_par_defaut \
,parametre_F \
) \
,seq1 \
,seqI \
,seqC \
,seqN \
); \
Eblock \
/* Recuperation d'un argument "Float" avec initialisation et post-traitement. */ \
/* */ \
/* L'initialisation n'a lieu que si la variable etait a l'etat 'FLOT__UNDEF' et seulement */ \
/* apres la definition du format des images, puisqu'en effet, cette definition peut etre */ \
/* une fonction de ce meme format... */
#define PROKISS_ARGUMENT_P(titre_attendu,parametre_P,valeur_P_par_defaut,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_P(arguments,titre_attendu,parametre_P,valeur_P_par_defaut,seq1,seqI,seqC,seqN); \
Eblock \
/* Recuperation d'un argument "genere_p" avec initialisation et post-traitement. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* PROCISS_ARGUMENT_P("titre1=",variable,initialisation,seq1,seqI,seqC,seqN); */ \
/* PROCISS_ARGUMENT_P("titre2=",variable,initialisation,seq1,seqI,seqC,seqN); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */
#define PROCISS_ARGUMENT_K(titre_attendu,parametre_K,valeur_K_par_defaut,sequenceI,sequenceC) \
Bblock \
PROCESS_PARAMETRE_K(arguments,titre_attendu,parametre_K,valeur_K_par_defaut,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "caractere" avec initialisation et post-traitement. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* PROCISS_ARGUMENT_K("titre1=",variable,initialisation,sequenceI,sequenceC); */ \
/* PROCISS_ARGUMENT_K("titre2=",variable,initialisation,sequenceI,sequenceC); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */
#define PROCISS_ARGUMENT_C(titre_attendu,parametre_C,valeur_C_par_defaut,sequenceI,sequenceC) \
Bblock \
PROCESS_PARAMETRE_C(arguments,titre_attendu,parametre_C,valeur_C_par_defaut,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "chaine de caracteres" avec initialisation et post-traitement. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* PROCISS_ARGUMENT_C("titre1=",variable,initialisation,sequenceI,sequenceC); */ \
/* PROCISS_ARGUMENT_C("titre2=",variable,initialisation,sequenceI,sequenceC); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */
#define PROCISS_ARGUMENT_L(titre_attendu,parametre_L,valeur_L_par_defaut,sequenceI,sequenceC) \
Bblock \
PROCESS_PARAMETRE_L(arguments,titre_attendu,parametre_L,valeur_L_par_defaut,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "Logical" avec initialisation et post-traitement. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* PROCISS_ARGUMENT_L("titre1=",variable,initialisation,sequenceI,sequenceC); */ \
/* PROCISS_ARGUMENT_L("titre2=",variable,initialisation,sequenceI,sequenceC); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */
#define PROCISS_ARGUMENT_N(titre_attendu,parametre_N,valeur_N_par_defaut,sequenceI,sequenceC) \
Bblock \
PROCESS_PARAMETRE_N(arguments,titre_attendu,parametre_N,valeur_N_par_defaut,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "Logical" inverse (ou "Negate") avec initialisation et */ \
/* post-traitement. ATTENTION, ecrire : */ \
/* */ \
/* PROCISS_ARGUMENT_N("titre1=",variable,initialisation,sequenceI,sequenceC); */ \
/* PROCISS_ARGUMENT_N("titre2=",variable,initialisation,sequenceI,sequenceC); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */
#define PROCISS_ARGUMENT_I(titre_attendu,parametre_I,valeur_I_par_defaut,sequenceI,sequenceC) \
Bblock \
PROCESS_PARAMETRE_I(arguments \
,titre_attendu \
,parametre_I \
,COND(IFET(EST_VRAI(le_format_des_images_a_ete_defini) \
,IFEQ(parametre_I,UNDEF) \
) \
,valeur_I_par_defaut \
,parametre_I \
) \
,sequenceI \
,sequenceC \
); \
Eblock \
/* Recuperation d'un argument "Int" avec initialisation et post-traitement. */ \
/* */ \
/* L'initialisation n'a lieu que si la variable etait a l'etat 'UNDEF' et seulement */ \
/* apres la definition du format des images, puisqu'en effet, cette definition peut etre */ \
/* une fonction de ce meme format... */
#define PROCISS_ARGUMENT_X(titre_attendu,parametre_X,valeur_X_par_defaut,sequenceI,sequenceC) \
Bblock \
PROCESS_PARAMETRE_X(arguments \
,titre_attendu \
,parametre_X \
,COND(IFET(EST_VRAI(le_format_des_images_a_ete_defini) \
,IFEQ(parametre_X,UNDEF) \
) \
,valeur_X_par_defaut \
,parametre_X \
) \
,sequenceI \
,sequenceC \
); \
Eblock \
/* Recuperation d'un argument "Int" avec initialisation et post-traitement avec edition */ \
/* hexa-decimale (introduit le 20070421093557). */ \
/* */ \
/* L'initialisation n'a lieu que si la variable etait a l'etat 'UNDEF' et seulement */ \
/* apres la definition du format des images, puisqu'en effet, cette definition peut etre */ \
/* une fonction de ce meme format... */
#define PROCISS_ARGUMENT_F(titre_attendu,parametre_F,valeur_F_par_defaut,sequenceI,sequenceC) \
Bblock \
PROCESS_PARAMETRE_F(arguments \
,titre_attendu \
,parametre_F \
,COND(IFET(EST_VRAI(le_format_des_images_a_ete_defini) \
,IFEQ(parametre_F,FLOT__UNDEF) \
) \
,valeur_F_par_defaut \
,parametre_F \
) \
,sequenceI \
,sequenceC \
); \
Eblock \
/* Recuperation d'un argument "Float" avec initialisation et post-traitement. */ \
/* */ \
/* L'initialisation n'a lieu que si la variable etait a l'etat 'FLOT__UNDEF' et seulement */ \
/* apres la definition du format des images, puisqu'en effet, cette definition peut etre */ \
/* une fonction de ce meme format... */
#define PROCISS_ARGUMENT_P(titre_attendu,parametre_P,valeur_P_par_defaut,sequenceI,sequenceC) \
Bblock \
PROCESS_PARAMETRE_P(arguments,titre_attendu,parametre_P,valeur_P_par_defaut,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "genere_p" avec initialisation et post-traitement. */ \
/* */ \
/* ATTENTION, ecrire : */ \
/* */ \
/* PROCISS_ARGUMENT_P("titre1=",variable,initialisation,sequenceI,sequenceC); */ \
/* PROCISS_ARGUMENT_P("titre2=",variable,initialisation,sequenceI,sequenceC); */ \
/* */ \
/* conduit a perdre la valeur entree si elle l'a ete par "titre1=...". */
#define GET_ARGUMENT_K(titre_attendu,parametre_K) \
Bblock \
INCK(GET_ARGUMENT_K_____Pcompteur_DAppel); \
\
GET_PARAMETRE_K(arguments,titre_attendu,parametre_K,parametre_K); \
Eblock \
/* Recuperation d'un argument "caractere". */
#define GET_ARGUMENT_C(titre_attendu,parametre_C) \
Bblock \
INCK(GET_ARGUMENT_C_____Pcompteur_DAppel); \
\
GET_PARAMETRE_C(arguments,titre_attendu,parametre_C,parametre_C); \
Eblock \
/* Recuperation d'un argument "chaine de caracteres". */
#define GET_ARGUMENT_L(titre_attendu,parametre_L) \
Bblock \
INCK(GET_ARGUMENT_L_____Pcompteur_DAppel); \
\
GET_PARAMETRE_L(arguments,titre_attendu,parametre_L,parametre_L); \
Eblock \
/* Recuperation d'un argument "Logical". */
#define GET_ARGUMENT_M(titre_attendu,parametre_M) \
Bblock \
BSaveVariable(Logical,parametre_M); \
/* Gestion du caractere "non modifiable" de cet argument fictif (le 20021207100111). */ \
\
INCK(GET_ARGUMENT_M_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_L(titre_attendu \
,parametre_M \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
PRINT_ATTENTION("l'argument '" ## titre_attendu ## "' est fictif et donc non modifiable"); \
Eblock \
) \
); \
\
ESaveVariable(Logical,parametre_M); \
Eblock \
/* Recuperation d'un argument "Logical" non modifiable (introduit le 20111213080346). */
#define GET_ARGUMENT_N(titre_attendu,parametre_N) \
Bblock \
INCK(GET_ARGUMENT_N_____Pcompteur_DAppel); \
\
GET_PARAMETRE_N(arguments,titre_attendu,parametre_N,parametre_N); \
Eblock \
/* Recuperation d'un argument "Logical" inverse (ou "Negate"), voir par exemple un usage */ \
/* dans 'v $xci/disk_video_P$K utiliser_le_mode_PAL_BETA_FRAME_NUMBER_MODE'. */
#define GET_ARGUMENT_I(titre_attendu,parametre_I) \
Bblock \
INCK(GET_ARGUMENT_I_____Pcompteur_DAppel); \
\
GET_PARAMETRE_I(arguments,titre_attendu,parametre_I,parametre_I); \
Eblock \
/* Recuperation d'un argument "Int". */
#define GET_ARGUMENT_E(titre_attendu,parametre_E) \
Bblock \
BSaveVariable(Float,parametre_E); \
/* Gestion du caractere "non modifiable" de 'parametre_E' (introduit le 20021207102525). */ \
\
INCK(GET_ARGUMENT_E_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_I(titre_attendu \
,parametre_E \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
PRINT_ATTENTION("l'argument '" ## titre_attendu ## "' est fictif et donc non modifiable"); \
Eblock \
) \
); \
\
ESaveVariable(Float,parametre_E); \
Eblock \
/* Recuperation d'un argument "Int" non modifiable (introduit le 20111213080346). */
#define GET_ARGUMENT_J(titre_attendu,parametre_J) \
Bblock \
BSaveVariable(Int,parametre_J); \
/* Gestion du caractere "non modifiable" de 'parametre_J' (introduit le 20021207102525). */ \
\
INCK(GET_ARGUMENT_J_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_J(titre_attendu \
,parametre_J \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
PRINT_ATTENTION("l'argument '" ## titre_attendu ## "' est fictif et donc non modifiable"); \
Eblock \
) \
); \
\
ESaveVariable(Int,parametre_J); \
Eblock \
/* Recuperation d'un argument "Int" non modifiable... */
#define GET_ARGUMENT_X(titre_attendu,parametre_X) \
Bblock \
INCK(GET_ARGUMENT_X_____Pcompteur_DAppel); \
\
GET_PARAMETRE_X(arguments,titre_attendu,parametre_X,parametre_X); \
Eblock \
/* Recuperation d'un argument "Int" a editer en hexa-decimal (cela fut introduit le */ \
/* 20070420190059 pour 'v $xcg/parallele.01$K GET_ARGUMENT_X'). */
#define GET_ARGUMENT_Y(titre_attendu,parametre_Y) \
Bblock \
BSaveVariable(Int,parametre_Y); \
\
INCK(GET_ARGUMENT_Y_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_Y(titre_attendu \
,parametre_Y \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
PRINT_ATTENTION("l'argument '" ## titre_attendu ## "' est fictif et donc non modifiable"); \
Eblock \
) \
); \
\
ESaveVariable(Int,parametre_Y); \
Eblock \
/* Recuperation d'un argument "Int" non modifiable et a editer en hexa-decimal (ceci */
/* fut introduit le 20070420191651 pour 'v $xcp/substitue.01$K'). */
#define GET_ARGUMENT_F(titre_attendu,parametre_F) \
Bblock \
INCK(GET_ARGUMENT_F_____Pcompteur_DAppel); \
\
GET_PARAMETRE_F(arguments,titre_attendu,parametre_F,parametre_F); \
Eblock \
/* Recuperation d'un argument "Float". */
#define GET_ARGUMENT_G(titre_attendu,parametre_G) \
Bblock \
BSaveVariable(Float,parametre_G); \
/* Gestion du caractere "non modifiable" de 'parametre_G' (introduit le 20021207102525). */ \
\
INCK(GET_ARGUMENT_G_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_F(titre_attendu \
,parametre_G \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
PRINT_ATTENTION("l'argument '" ## titre_attendu ## "' est fictif et donc non modifiable"); \
Eblock \
) \
); \
\
ESaveVariable(Float,parametre_G); \
Eblock \
/* Recuperation d'un argument "Float" non modifiable... */
#define GET_ARGUMENT_P(titre_attendu,parametre_P) \
Bblock \
INCK(GET_ARGUMENT_P_____Pcompteur_DAppel); \
\
GET_PARAMETRE_P(arguments,titre_attendu,parametre_P,parametre_P); \
Eblock \
/* Recuperation d'un argument "genere_p". */
#define VALEUR_INITIALE_DE___COMPTEUR__B__ \
__COMPTEUR__B__ \
/* Introduit le 20190905082754 pour 'GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(...)'. */
#define NIVEAU_MAXIMAL_D_IMBRICATION____DES_GET_ARGUMENTSn_x \
DIX
#define NIVEAU_MINIMAL_D_IMBRICATION____DES_GET_ARGUMENTSn_x \
DEUX
#define CHAINE_DE_TABULATION____DES_GET_ARGUMENTSn_x \
C_VIDE
/* Valeur arbitraire introduite le 20190904092406 qui correspond au niveau maximal */
/* d'imbrication des procedures 'GET_ARGUMENTSn_x(...)'. Elle correspond en fait a */
/* 'GET_ARGUMENTSa_L(...)' et a 'GET_ARGUMENTSa_N(...)'. Le niveau minimal correspond */
/* evidemment au premier niveau d'imbrication et par exemple a ''GET_ARGUMENTS2_L(...)'... */
%define GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(procedure,titre_attendu,condition,format_1,param_1,format_2,param_2,Get_n_1) \
/* Le 20190808131930, la procedure 'GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(...)' */ \
/* est passee de '$PASSE_1' a '$PASSE_4' afin de simplifier les choses. En effet, avant */ \
/* date, on trouvait ci-apres, par exemple pour la definition de 'GET_ARGUMENTS2_K(...)' : */ \
/* date, on trouvait par exemple ci-apres : */ \
/* */ \
/* #define GET_ARGUMENTS2_K(titre_attendu,parametre_K1,parametre_K2) \ */ \
/* Bblock \ */ \
/* &define nom_du_GET_ARGUMENTSn_x __MACRO__&&& \ */ \
/* GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(titre_attendu \ */ \
/* (...) \ */ \
/* Eblock */ \
/* */ \
/* En effet, il etait alors impossible de donner '__MACRO__' en argument de cette procedure */ \
/* 'GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(...)' car etant definie en '$PASSE_1', */ \
/* la valeur de '__MACRO__' etait 'GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x' et non */ \
/* pas 'GET_ARGUMENTS2_K'... */ \
Bblock \
Test(TOUJOURS_VRAI) \
/* Introduit le 20190807080656 au cas ou on souhaiterait supprimer facilement ce test... */ \
Bblock \
Test(EST_VRAI(c_est_la_premiere_recherche_des_parametres)) \
Bblock \
Test(condition) \
Bblock \
CAL3(Prme1("Dans '%s', ",FICHIER_DE_BASE_ABSOLU_x)); \
/* Depuis le passage de '$PASSE_1' a '$PASSE_4' l'edition suivante : */ \
/* */ \
/* CAL3(Prme1("Dans '%s', ",FICHIER_COURANT_ABSOLU_x)); \ */ \
/* */ \
/* donnait "$x/includes/generales/fonct.vv.def", d'ou le nouvel argument 'file' pour */ \
/* transmettre un 'FICHIER_COURANT_ABSOLU_x' correct. Cela semble venir de la "chaine" */ \
/* des definitions : */ \
/* */ \
/* FICHIER_COURANT_ABSOLU_x */ \
/* | */ \
/* -------> FICHIER_COURANT_RELATIF */ \
/* | */ \
/* -------> __FILER__ */ \
/* */ \
/* Mais en fait, les experiences du 20190808173648 montrent que cela semble beaucoup */ \
/* plus complique que cela et du certainement a une forte imbrication des procedures. */ \
/* N'oublions pas, par exemple, que 'GET_ARGUMENTS2_F(...)' est appelee en general via */ \
/* 'GET_ARGUMENTSi(...)'. */ \
/* */ \
/* On notera a cette date qu'utiliser : */ \
/* */ \
/* chain_Aconcaten3(CURRENT_DIRECTORY,cSEPARATEUR_DES_PATHS,NOM_DE_LA_COMMANDE) */ \
/* */ \
/* a la place de 'file' n'est pas la solution car, en effet, d'une part 'NOM_DE_LA_COMMANDE' */ \
/* peut etre relatif ou absolu et d'autre part, 'CURRENT_DIRECTORY' n'est pas necessairement */ \
/* le directory d'appartenance de cette commande... */ \
/* */ \
/* En fait, le 20190809094118, j'ai compris : la variable '__FILER__' est "dynamique" et */ \
/* contient donc en permanence le 'include' courant. Cela a donc conduit a l'introduction */ \
/* de 'FICHIER_DE_BASE_ABSOLU_x' qui est defini dans 'GET_PARAMETRES(...)' et donc dans */ \
/* l'include de base et en '$PASSE_3' afin de ne pas etre mal substitue en '$PASSE_1'. */ \
/* L'argument 'file' devenu inutile a donc evidemment disparu... */ \
/* */ \
/* On notera que j'ai essaye de faire aux environs du 20190809094118 : */ \
/* */ \
/* BSaveModifyVariable(Logical,Prme_____editer_les_messages_d_en_tete,VRAI); */ \
/* CAL3(Prme1("Dans '%s', ",FICHIER_DE_BASE_ABSOLU_x)); */ \
/* ESaveModifyVariable(Logical,Prme_____editer_les_messages_d_en_tete); */ \
/* */ \
/* mais, malheureusement 'NOM_COMMANDE' qui est alors edite n'est pas necessairement */ \
/* absolu, tout dependu du mode d'appel du '$X' correspondant. Et tout cela avant de */ \
/* trouver la solution universelle : celle de :FICHIER_DE_BASE_ABSOLU_x'... */ \
\
Test(IFGT(SOUS(`_COMPTEUR__B_` \
,VALEUR_INITIALE_DE___COMPTEUR__B__ \
) \
,SOUS(NIVEAU_MAXIMAL_D_IMBRICATION____DES_GET_ARGUMENTSn_x \
,NIVEAU_MINIMAL_D_IMBRICATION____DES_GET_ARGUMENTSn_x \
) \
) \
) \
Bblock \
PRINT_ATTENTION("augmenter le niveau maximal d'imbrication des 'GET_ARGUMENTSn_x(...)'s."); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
CAL3(Prme5("le '%*s(...)%*s' relatif a '%s' " \
,ADD2(chain_Xtaille(procedure),`_COMPTEUR__B_`) \
,procedure \
,SOUS(SOUS(SOUS(NIVEAU_MAXIMAL_D_IMBRICATION____DES_GET_ARGUMENTSn_x \
,NIVEAU_MINIMAL_D_IMBRICATION____DES_GET_ARGUMENTSn_x \
) \
,chain_Xtaille(CHAINE_DE_TABULATION____DES_GET_ARGUMENTSn_x) \
) \
,`_COMPTEUR__B_` \
) \
,CHAINE_DE_TABULATION____DES_GET_ARGUMENTSn_x \
,titre_attendu \
) \
); \
/* Avant la modification du 20190808131930, il y avait ci-dessus : */ \
/* */ \
/* CAL3(Prme2("le '%s(...)' relatif a '%s' ",nom_du_GET_ARGUMENTSn_x,titre_attendu)); \ */ \
/* */ \
/* On notera la tabulation introduite le 20190831122149 qui permet de mettre en evidence */ \
/* les imbrications des procedures 'GET_ARGUMENTSn_x(...)', par exemple, sous la forme : */ \
/* */ \
/* 'GET_ARGUMENTS4_F(...) ' */ \
/* ' GET_ARGUMENTS3_F(...) ' */ \
/* ' GET_ARGUMENTS2_F(...) ' */ \
/* */ \
/* (je n'ai rien trouve de mieux, tout en etant simple...). */ \
/* */ \
/* On notera au passage qu'il n'est pas possible de mieux optimiser le nombre d'espaces */ \
/* qui precedent la deuxieme '$K_QS' car on ne peut pas connaitre le niveau d'imbrication */ \
/* de la premiere 'GET_ARGUMENTSn_x(...)' appelee (par exemple 'GET_ARGUMENTS4_F(...)'). */ \
/* J'ai essaye d'utiliser '`_COMPTEUR__B_`' mais cela ne marche pas : il faudrait en fait */ \
/* un decompteur qui serait initialise a 4 dans cet exemple, or cela ne pourrait se faire */ \
/* qu'a l'exterieur de 'GET_ARGUMENTS4_F(...)' puisque cette procedure pouvant etre */ \
/* elle-meme referencee par une eventuelle 'GET_ARGUMENTS5_F(...)' il est impossible */ \
/* d'y initailiser un compteur a 4... */ \
/* */ \
/* On notera que l'on ne peut pas utiliser directement '__COMPTEUR__B__' car, en effet, */ \
/* la valeur du compteur serait substitue en '$PASSE_1', alors que nous sommes ici en */ \
/* '$PASSE_3' et alors la valeur du compteur ne refleterait pas les imbrications en */ \
/* ayant toujours la meme valeur (0). On bloque donc la substitution en '$PASSE_1' grace */ \
/* a l'operateur de concatenation '$S_UNDERSCORE' qui est gere en '$PASSE_2' et donc */ \
/* entre '$PASSE_1' et '$PASSE_3'... */ \
/* */ \
/* On notera aussi que '`_COMPTEUR__B_`' est utilise avant {`_PLUS1__B_`,`_MOINS1__B_`} */ \
/* ce qui permet d'avoir au cours des imbrications la suite {0,1,2,...} et donc 0 pour */ \
/* la premiere... */ \
CALS(FPrme0("gere des arguments de valeurs par defaut differentes : ")); \
CAL3(Prme6(chain_Aconcaten5("{%c",format_1,"%c # %c",format_2,"%c}.\n") \
,K_QUOTE,param_1,K_QUOTE \
,K_QUOTE,param_2,K_QUOTE \
) \
); \
/* Dans ce cas, il est important de separer ce 'GET_ARGUMENTSn_x(...)' en autant de */ \
/* 'GET_ARGUMENT_x(...)'s que necessaire et ce afin de permettre en particulier une */ \
/* edition pertinente des valeurs par defaut des parametres ("Parametres=VRAI"). En */ \
/* contrepartie, on perd ainsi un peu en facilite d'usage puisque l'on sera alors dans */ \
/* l'obligation de definir deux (voire plus) parametres fonctionnellement voisins, mais */ \
/* differents lors de l'appel de ce '$X'... */ \
/* */ \
/* On notera l'usage de 'CAL3(Prme?(...))' ci-dessus (et non pas 'PRINT_ERREUR(...)' et */ \
/* 'CAL1(Prer?(...))') afin d'etre compatible avec 'v $xig/fonct$vv$FON CAL3(Prme9(format_' */ \
/* et ce via la commande 'use' en particulier... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
`_PLUS1__B_` \
/* Introduit le 20190831115344 afin de mettre en evidence les imbrications des */ \
/* 'GET_ARGUMENTSn_x(...)'. */ \
/* */ \
/* Comme pour '__COMPTEUR__B__' on ne peut pas utiliser directement '__PLUS1__B__'... */ \
\
BLOC(Get_n_1); \
/* Execution du GET_ARGUMENTSn_x(...)' de niveau inferieur (introduit le 20190831110352 */ \
/* sous cette forme...). */ \
\
/* Avant la modification du 20190808131930, il y avait ici : */ \
/* */ \
/* &undef nom_du_GET_ARGUMENTSn_x&&& \ */ \
/* */ \
\
`_MOINS1__B_` \
/* Introduit le 20190831115344 afin de mettre en evidence les imbrications des */ \
/* 'GET_ARGUMENTSn_x(...)'. */ \
/* */ \
/* Comme pour '__COMPTEUR__B__' on ne peut pas utiliser directement '__MOINS1__B__'... */ \
\
Eblock \
/* Validation de l'usage des 'GET_ARGUMENTS?_?(...)'. Ceci fut introduit le 20190806132343 */ \
/* suite au probleme decrit dans 'v $xci/jeu_vie.01$K 20190806104105'... */
#define GESTION_DE_L_IMBRICATION_FORMAT_UNIVERSEL(introduction,format_d_edition) \
chain_Aconcaten3(introduction,"=",format_d_edition)
#define GESTION_DE_L_IMBRICATION_FORMAT_K(introduction) \
GESTION_DE_L_IMBRICATION_FORMAT_UNIVERSEL(introduction,FORMAT_CHAR_EDITION)
#define GESTION_DE_L_IMBRICATION_FORMAT_C(introduction) \
GESTION_DE_L_IMBRICATION_FORMAT_UNIVERSEL(introduction,FORMAT_CHAI_EDITION)
#define GESTION_DE_L_IMBRICATION_FORMAT_L(introduction) \
GESTION_DE_L_IMBRICATION_FORMAT_UNIVERSEL(introduction,FORMAT_LOGI_EDITION)
#define GESTION_DE_L_IMBRICATION_FORMAT_N(introduction) \
GESTION_DE_L_IMBRICATION_FORMAT_UNIVERSEL(introduction,FORMAT_NOGI_EDITION)
#define GESTION_DE_L_IMBRICATION_FORMAT_P(introduction) \
GESTION_DE_L_IMBRICATION_FORMAT_UNIVERSEL(introduction,FORMAT_INTE_EDITION)
#define GESTION_DE_L_IMBRICATION_FORMAT_I(introduction) \
GESTION_DE_L_IMBRICATION_FORMAT_UNIVERSEL(introduction,FORMAT_INTE_EDITION)
#define GESTION_DE_L_IMBRICATION_FORMAT_X(introduction) \
GESTION_DE_L_IMBRICATION_FORMAT_UNIVERSEL(introduction \
,SE12(FORMAT_HEXA_DECIMAL_SANS_0_EDITION,FORMAT_HEXA_DECIMAL_EDITION) \
)
#define GESTION_DE_L_IMBRICATION_FORMAT_F(introduction) \
GESTION_DE_L_IMBRICATION_FORMAT_UNIVERSEL(introduction,FORMAT_FLOT_EDITION)
/* Definitions introduites le 20190904074034... */
/* */
/* Le 20190906114010, 'FORMAT_HEXA_DECIMAL_EDITION' a ete remplace par */
/* 'FORMAT_HEXA_DECIMAL_SANS_0_EDITION' afin de supprimer les "0"s redondants en tete */
/* des valeurs hexa-decimales... */
#define GET_ARGUMENTS2_K(titre_attendu,parametre_K1,parametre_K2) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_K1,parametre_K2) \
,GESTION_DE_L_IMBRICATION_FORMAT_K("K1"),parametre_K1 \
,GESTION_DE_L_IMBRICATION_FORMAT_K("K2"),parametre_K2 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS2_K_____Pcompteur_DAppel); \
\
GET_ARGUMENT_K(titre_attendu,parametre_K1); \
\
EGAL(parametre_K2,parametre_K1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de deux arguments "caractere" (introduit le 20091204091116). */
#define GET_ARGUMENTS2_C(titre_attendu,parametre_C1,parametre_C2) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE_chaine(parametre_C1,parametre_C2) \
,GESTION_DE_L_IMBRICATION_FORMAT_C("C1"),parametre_C1 \
,GESTION_DE_L_IMBRICATION_FORMAT_C("C2"),parametre_C2 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS2_C_____Pcompteur_DAppel); \
\
GET_ARGUMENT_C(titre_attendu,parametre_C1); \
\
EGAp(parametre_C2,chain_Acopie(parametre_C1)); \
Eblock \
) \
); \
Eblock \
/* Recuperation de deux arguments "chaine de caracteres" (introduit le 20091204091116). */
#define GET_ARGUMENTS2_L(titre_attendu,parametre_L1,parametre_L2) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_L1,parametre_L2) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L1"),ETAT_LOGIQUE(parametre_L1) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L2"),ETAT_LOGIQUE(parametre_L2) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS2_L_____Pcompteur_DAppel); \
\
GET_ARGUMENT_L(titre_attendu,parametre_L1); \
\
EGAL(parametre_L2,parametre_L1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de deux arguments "Logical" (introduit le 20091204091116). */
#define GET_ARGUMENTS2_N(titre_attendu,parametre_N1,parametre_N2) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_N1,parametre_N2) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N1"),ETAT_LOGIQUE(parametre_N1) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N2"),ETAT_LOGIQUE(parametre_N2) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS2_N_____Pcompteur_DAppel); \
\
GET_ARGUMENT_N(titre_attendu,parametre_N1); \
\
EGAL(parametre_N2,parametre_N1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de deux arguments "Logical" inverse -ou "Negate"- (introduit le */ \
/* 20091204091116). */
#define GET_ARGUMENTS2_I(titre_attendu,parametre_I1,parametre_I2) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_I1,parametre_I2) \
,GESTION_DE_L_IMBRICATION_FORMAT_I("I1"),parametre_I1 \
,GESTION_DE_L_IMBRICATION_FORMAT_I("I2"),parametre_I2 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS2_I_____Pcompteur_DAppel); \
\
GET_ARGUMENT_I(titre_attendu,parametre_I1); \
\
EGAL(parametre_I2,parametre_I1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de deux arguments "Int" (introduit le 20091204091116). */
#define GET_ARGUMENTS2g_I(titre_attendu,parametre_I1,parametre_I2) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_I1,parametre_I2) \
,GESTION_DE_L_IMBRICATION_FORMAT_I("I1"),parametre_I1 \
,GESTION_DE_L_IMBRICATION_FORMAT_I("I2"),parametre_I2 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS2g_I_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE(arguments \
,titre_attendu \
,parametre_I1 \
,parametre_I1 \
,FconversionI \
,NEUT \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
,BLOC(Bblock \
EGAL(parametre_I2,parametre_I1); \
Eblock \
) \
,BLOC(VIDE;) \
,styp_I \
,ityp_I \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
) \
); \
Eblock \
/* Recuperation de deux arguments "Int" plus "Generales" que 'GET_ARGUMENTS2_I(...)' */ \
/* introduite le 20180110105338 et qui permet d'ecrire par exemple : */ \
/* */ \
/* GET_ARGUMENTS2g_I("titre12=",argument1,argument2); */ \
/* (...) */ \
/* GET_ARGUMENT_I("titre1=",argument1); */ \
/* GET_ARGUMENT_I("titre2=",argument2); */ \
/* */ \
/* sans probleme (c'est-a-dire que les deux arguments ont bien les bonnes valeurs quelles */ \
/* que soient les circonstances...). */
#define GET_ARGUMENTS2_X(titre_attendu,parametre_X1,parametre_X2) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_X1,parametre_X2) \
,GESTION_DE_L_IMBRICATION_FORMAT_X("X1"),parametre_X1 \
,GESTION_DE_L_IMBRICATION_FORMAT_X("X2"),parametre_X2 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS2_X_____Pcompteur_DAppel); \
\
GET_ARGUMENT_X(titre_attendu,parametre_X1); \
\
EGAL(parametre_X2,parametre_X1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de deux arguments "Int" a editer en hexa-decimal (introduit le */ \
/* 20091204091116). */
#define GET_ARGUMENTS2_F(titre_attendu,parametre_F1,parametre_F2) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFET(IFNE(parametre_F1,parametre_F2) \
,IFET(IFNE_chaine(titre_attendu,"DepthCueingMinimal=dcm=") \
,TOUJOURS_VRAI \
) \
) \
,GESTION_DE_L_IMBRICATION_FORMAT_F("F1"),parametre_F1 \
,GESTION_DE_L_IMBRICATION_FORMAT_F("F2"),parametre_F2 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS2_F_____Pcompteur_DAppel); \
\
GET_ARGUMENT_F(titre_attendu,parametre_F1); \
\
EGAL(parametre_F2,parametre_F1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de deux arguments "Float" (introduit le 20091204091116). */ \
/* */ \
/* Le traitement specifique de "DepthCueingMinimal=dcm=" introduit le 20190807091111 */ \
/* ('v $xrv/champs_5.1A$I GET_ARGUMENTS2_F..DepthCueingMinimal=..dcm=..') est du aux */ \
/* programmes : */ \
/* */ \
/* $xrq/Hspherik.21$K */ \
/* $xrq/hydrogene.21$K */ \
/* $xrq/hydrogene.51$K */ \
/* */ \
/* $xrv/champs_5.10$K */ \
/* $xrv/champs_5.20$K */ \
/* $xrv/champs_5.30$K */ \
/* */ \
/* Pour lesquels on a : */ \
/* */ \
/* F1=+0 */ \
/* F2=+0.25 */ \
/* */ \
/* car, en effet, ils redefinissent {PROFONDEUR_MINIMALE,PROFONDEUR_MINIMALE_DE_TRONCATION} */ \
/* qui servent a initialiser {profondeur_minimale,profondeur_minimale_de_troncation} (voir */ \
/* 'v $xrq/Hspherik.21$K PROFONDEUR_MINIMALE' par exemple...). */ \
/* */ \
/* Tout cela n'est peut-etre pas tres elegant, mais je n'ai rien trouve de plus simple */ \
/* afin, en particulier, de garantir la compatibilite anterieure... */ \
/* */ \
/* D'ailleurs, au passage, {PROFONDEUR_MINIMALE,PROFONDEUR_MINIMALE_DE_TRONCATION} sont */ \
/* redefinies differemment et {profondeur_minimale,profondeur_minimale_de_troncation} sont */ \
/* donc initialisees differemment, mais cela semble en fait "gomme" (et donc ignore) ici */ \
/* via ce 'GET_ARGUMENTS2_F(...)' a cause du 'EGAL(parametre_F2,parametre_F1)'... */ \
/* */ \
/* Le 20190807120424 fut introduit 'IFET...,TOUJOURS_VRAI)' afin de prevoir l'avenir (cas */ \
/* ou d'autres 'titre_attendu's a exclure devraient etre introduits...). */
#define GET_ARGUMENTS2g_F(titre_attendu,parametre_F1,parametre_F2) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_F1,parametre_F2) \
,GESTION_DE_L_IMBRICATION_FORMAT_F("F1"),parametre_F1 \
,GESTION_DE_L_IMBRICATION_FORMAT_F("F2"),parametre_F2 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS2g_F_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE(arguments \
,titre_attendu \
,parametre_F1 \
,parametre_F1 \
,FconversionF \
,NEUT \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
,BLOC(Bblock \
EGAL(parametre_F2,parametre_F1); \
Eblock \
) \
,BLOC(VIDE;) \
,styp_F \
,ityp_F \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
) \
); \
Eblock \
/* Recuperation de deux arguments "Float" plus "Generales" que 'GET_ARGUMENTS2_F(...)' */ \
/* introduite le 20180110105338 et qui permet d'ecrire par exemple : */ \
/* */ \
/* GET_ARGUMENTS2g_F("titre12=",argument1,argument2); */ \
/* (...) */ \
/* GET_ARGUMENT_F("titre1=",argument1); */ \
/* GET_ARGUMENT_F("titre2=",argument2); */ \
/* */ \
/* sans probleme (c'est-a-dire que les deux arguments ont bien les bonnes valeurs quelles */ \
/* que soient les circonstances...). */
#define GET_ARGUMENTS2_P(titre_attendu,parametre_P1,parametre_P2) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_P1,parametre_P2) \
,GESTION_DE_L_IMBRICATION_FORMAT_P("P1"),parametre_P1 \
,GESTION_DE_L_IMBRICATION_FORMAT_P("P2"),parametre_P2 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS2_P_____Pcompteur_DAppel); \
\
GET_ARGUMENT_P(titre_attendu,parametre_P1); \
\
EGAL(parametre_P2,parametre_P1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de deux arguments "genere_p" (introduit le 20091204091116). */
#define GET_ARGUMENTS3_K(titre_attendu,parametre_K1,parametre_K2,parametre_K3) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_K1,parametre_K3) \
,GESTION_DE_L_IMBRICATION_FORMAT_K("K1"),parametre_K1 \
,GESTION_DE_L_IMBRICATION_FORMAT_K("K3"),parametre_K3 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS3_K_____Pcompteur_DAppel); \
\
GET_ARGUMENTS2_K(titre_attendu \
,parametre_K1 \
,parametre_K2 \
); \
\
EGAL(parametre_K3,parametre_K1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de trois arguments "caractere" (introduit le 20111018094618). */
#define GET_ARGUMENTS3_C(titre_attendu,parametre_C1,parametre_C2,parametre_C3) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE_chaine(parametre_C1,parametre_C3) \
,GESTION_DE_L_IMBRICATION_FORMAT_C("C1"),parametre_C1 \
,GESTION_DE_L_IMBRICATION_FORMAT_C("C3"),parametre_C3 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS3_C_____Pcompteur_DAppel); \
\
GET_ARGUMENTS2_C(titre_attendu \
,parametre_C1 \
,parametre_C2 \
); \
\
EGAp(parametre_C3,chain_Acopie(parametre_C1)); \
Eblock \
) \
); \
Eblock \
/* Recuperation de trois arguments "chaine de caracteres" (introduit le 20111018094618). */
#define GET_ARGUMENTS3_L(titre_attendu,parametre_L1,parametre_L2,parametre_L3) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_L1,parametre_L3) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L1"),ETAT_LOGIQUE(parametre_L1) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L3"),ETAT_LOGIQUE(parametre_L3) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS3_L_____Pcompteur_DAppel); \
\
GET_ARGUMENTS2_L(titre_attendu \
,parametre_L1 \
,parametre_L2 \
); \
\
EGAL(parametre_L3,parametre_L1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de trois arguments "Logical" (introduit le 20111018094618). */
#define GET_ARGUMENTS3_N(titre_attendu,parametre_N1,parametre_N2,parametre_N3) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_N1,parametre_N3) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N1"),ETAT_LOGIQUE(parametre_N1) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N3"),ETAT_LOGIQUE(parametre_N3) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS3_N_____Pcompteur_DAppel); \
\
GET_ARGUMENTS2_N(titre_attendu \
,parametre_N1 \
,parametre_N2 \
); \
\
EGAL(parametre_N3,parametre_N1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de trois arguments "Logical" inverse -ou "Negate"- (introduit le */ \
/* 20111018094618). */
#define GET_ARGUMENTS3_I(titre_attendu,parametre_I1,parametre_I2,parametre_I3) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_I1,parametre_I3) \
,GESTION_DE_L_IMBRICATION_FORMAT_I("I1"),parametre_I1 \
,GESTION_DE_L_IMBRICATION_FORMAT_I("I3"),parametre_I3 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS3_I_____Pcompteur_DAppel); \
\
GET_ARGUMENTS2_I(titre_attendu \
,parametre_I1 \
,parametre_I2 \
); \
\
EGAL(parametre_I3,parametre_I1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de trois arguments "Int" (introduit le 20111018094618). */
#define GET_ARGUMENTS3g_I(titre_attendu,parametre_I1,parametre_I2,parametre_I3) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_I1,parametre_I3) \
,GESTION_DE_L_IMBRICATION_FORMAT_I("I1"),parametre_I1 \
,GESTION_DE_L_IMBRICATION_FORMAT_I("I3"),parametre_I3 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS3g_I_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE(arguments \
,titre_attendu \
,parametre_I1 \
,parametre_I1 \
,FconversionI \
,NEUT \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
,BLOC(Bblock \
EGAL(parametre_I2,parametre_I1); \
EGAL(parametre_I3,parametre_I1); \
Eblock \
) \
,BLOC(VIDE;) \
,styp_I \
,ityp_I \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
) \
); \
Eblock \
/* Recuperation de trois arguments "Int" plus "Generales" que 'GET_ARGUMENTS3_I(...)' */ \
/* introduite le 20180110105338 (pour 'v $xrf/EpongeDeMenger.01$K GET_ARGUMENTS3g_I') */ \
/* et qui permet d'ecrire par exemple : */ \
/* */ \
/* GET_ARGUMENTS3g_I("titre123=",argument1,argument2,argument3); */ \
/* (...) */ \
/* GET_ARGUMENT_I("titre1=",argument1); */ \
/* GET_ARGUMENT_I("titre2=",argument2); */ \
/* GET_ARGUMENT_I("titre3=",argument3); */ \
/* */ \
/* sans probleme (c'est-a-dire que les trois arguments ont bien les bonnes valeurs quelles */ \
/* que soient les circonstances...). */
#define GET_ARGUMENTS3_X(titre_attendu,parametre_X1,parametre_X2,parametre_X3) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_X1,parametre_X3) \
,GESTION_DE_L_IMBRICATION_FORMAT_X("X1"),parametre_X1 \
,GESTION_DE_L_IMBRICATION_FORMAT_X("X3"),parametre_X3 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS3_X_____Pcompteur_DAppel); \
\
GET_ARGUMENTS2_X(titre_attendu \
,parametre_X1 \
,parametre_X2 \
); \
\
EGAL(parametre_X3,parametre_X1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de trois arguments "Int" a editer en hexa-decimal (introduit le */ \
/* 20111018094618). */
#define GET_ARGUMENTS3_F(titre_attendu,parametre_F1,parametre_F2,parametre_F3) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_F1,parametre_F3) \
,GESTION_DE_L_IMBRICATION_FORMAT_F("F1"),parametre_F1 \
,GESTION_DE_L_IMBRICATION_FORMAT_F("F3"),parametre_F3 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS3_F_____Pcompteur_DAppel); \
\
GET_ARGUMENTS2_F(titre_attendu \
,parametre_F1 \
,parametre_F2 \
); \
\
EGAL(parametre_F3,parametre_F1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de trois arguments "Float" (introduit le 20111018094618). */
#define GET_ARGUMENTS3g_F(titre_attendu,parametre_F1,parametre_F2,parametre_F3) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_F1,parametre_F3) \
,GESTION_DE_L_IMBRICATION_FORMAT_F("F1"),parametre_F1 \
,GESTION_DE_L_IMBRICATION_FORMAT_F("F3"),parametre_F3 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS3g_F_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE(arguments \
,titre_attendu \
,parametre_F1 \
,parametre_F1 \
,FconversionF \
,NEUT \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
,BLOC(Bblock \
EGAL(parametre_F2,parametre_F1); \
EGAL(parametre_F3,parametre_F1); \
Eblock \
) \
,BLOC(VIDE;) \
,styp_F \
,ityp_F \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
) \
); \
Eblock \
/* Recuperation de trois arguments "Float" plus "Generales" que 'GET_ARGUMENTS3_F(...)' */ \
/* introduite le 20180110105338 (pour 'v $xrf/EpongeDeMenger.01$K GET_ARGUMENTS3g_F') */ \
/* et qui permet d'ecrire par exemple : */ \
/* */ \
/* GET_ARGUMENTS3g_F("titre123=",argument1,argument2,argument3); */ \
/* (...) */ \
/* GET_ARGUMENT_F("titre1=",argument1); */ \
/* GET_ARGUMENT_F("titre2=",argument2); */ \
/* GET_ARGUMENT_F("titre3=",argument3); */ \
/* */ \
/* sans probleme (c'est-a-dire que les trois arguments ont bien les bonnes valeurs quelles */ \
/* que soient les circonstances...). */
#define GET_ARGUMENTS3_P(titre_attendu,parametre_P1,parametre_P2,parametre_P3) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_P1,parametre_P3) \
,GESTION_DE_L_IMBRICATION_FORMAT_P("P1"),parametre_P1 \
,GESTION_DE_L_IMBRICATION_FORMAT_P("P3"),parametre_P3 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS3_P_____Pcompteur_DAppel); \
\
GET_ARGUMENTS2_P(titre_attendu \
,parametre_P1 \
,parametre_P2 \
); \
\
EGAL(parametre_P3,parametre_P1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de trois arguments "genere_p" (introduit le 20111018094618). */
#define GET_ARGUMENTS4_K(titre_attendu,parametre_K1,parametre_K2,parametre_K3,parametre_K4) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_K1,parametre_K4) \
,GESTION_DE_L_IMBRICATION_FORMAT_K("K1"),parametre_K1 \
,GESTION_DE_L_IMBRICATION_FORMAT_K("K4"),parametre_K4 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS4_K_____Pcompteur_DAppel); \
\
GET_ARGUMENTS3_K(titre_attendu \
,parametre_K1 \
,parametre_K2 \
,parametre_K3 \
); \
\
EGAL(parametre_K4,parametre_K1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de quatre arguments "caractere" (introduit le 20111018094618). */
#define GET_ARGUMENTS4_C(titre_attendu,parametre_C1,parametre_C2,parametre_C3,parametre_C4) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE_chaine(parametre_C1,parametre_C4) \
,GESTION_DE_L_IMBRICATION_FORMAT_C("C1"),parametre_C1 \
,GESTION_DE_L_IMBRICATION_FORMAT_C("C4"),parametre_C4 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS4_C_____Pcompteur_DAppel); \
\
GET_ARGUMENTS3_C(titre_attendu \
,parametre_C1 \
,parametre_C2 \
,parametre_C3 \
); \
\
EGAp(parametre_C4,chain_Acopie(parametre_C1)); \
Eblock \
) \
); \
Eblock \
/* Recuperation de quatre arguments "chaine de caracteres" (introduit le 20111018094618). */
#define GET_ARGUMENTS4_L(titre_attendu,parametre_L1,parametre_L2,parametre_L3,parametre_L4) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_L1,parametre_L4) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L1"),ETAT_LOGIQUE(parametre_L1) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L4"),ETAT_LOGIQUE(parametre_L4) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS4_L_____Pcompteur_DAppel); \
\
GET_ARGUMENTS3_L(titre_attendu \
,parametre_L1 \
,parametre_L2 \
,parametre_L3 \
); \
\
EGAL(parametre_L4,parametre_L1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de quatre arguments "Logical" (introduit le 20111018094618). */
#define GET_ARGUMENTS4_N(titre_attendu,parametre_N1,parametre_N2,parametre_N3,parametre_N4) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_N1,parametre_N4) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N1"),ETAT_LOGIQUE(parametre_N1) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N4"),ETAT_LOGIQUE(parametre_N4) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS4_N_____Pcompteur_DAppel); \
\
GET_ARGUMENTS3_N(titre_attendu \
,parametre_N1 \
,parametre_N2 \
,parametre_N3 \
); \
\
EGAL(parametre_N4,parametre_N1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de quatre arguments "Logical" inverse -ou "Negate"- (introduit le */ \
/* 20111018094618). */
#define GET_ARGUMENTS4_I(titre_attendu,parametre_I1,parametre_I2,parametre_I3,parametre_I4) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_I1,parametre_I4) \
,GESTION_DE_L_IMBRICATION_FORMAT_I("I1"),parametre_I1 \
,GESTION_DE_L_IMBRICATION_FORMAT_I("I4"),parametre_I4 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS4_I_____Pcompteur_DAppel); \
\
GET_ARGUMENTS3_I(titre_attendu \
,parametre_I1 \
,parametre_I2 \
,parametre_I3 \
); \
\
EGAL(parametre_I4,parametre_I1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de quatre arguments "Int" (introduit le 20111018094618). */
#define GET_ARGUMENTS4_X(titre_attendu,parametre_X1,parametre_X2,parametre_X3,parametre_X4) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_X1,parametre_X4) \
,GESTION_DE_L_IMBRICATION_FORMAT_X("X1"),parametre_X1 \
,GESTION_DE_L_IMBRICATION_FORMAT_X("X4"),parametre_X4 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS4_X_____Pcompteur_DAppel); \
\
GET_ARGUMENTS3_X(titre_attendu \
,parametre_X1 \
,parametre_X2 \
,parametre_X3 \
); \
\
EGAL(parametre_X4,parametre_X1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de quatre arguments "Int" a editer en hexa-decimal (introduit le */ \
/* 20111018094618). */
#define GET_ARGUMENTS4_F(titre_attendu,parametre_F1,parametre_F2,parametre_F3,parametre_F4) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_F1,parametre_F4) \
,GESTION_DE_L_IMBRICATION_FORMAT_F("F1"),parametre_F1 \
,GESTION_DE_L_IMBRICATION_FORMAT_F("F4"),parametre_F4 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS4_F_____Pcompteur_DAppel); \
\
GET_ARGUMENTS3_F(titre_attendu \
,parametre_F1 \
,parametre_F2 \
,parametre_F3 \
); \
\
EGAL(parametre_F4,parametre_F1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de quatre arguments "Float" (introduit le 20111018094618). */ \
/* */ \
/* On notera que pour tester le bon fonctionnement du dispositif de validation, il suffit, */ \
/* par exemple, d'introduire dans 'v $xci/jeu_vie.01$K' l'appel suivant : */ \
/* */ \
/* GET_ARGUMENTS4_F */ \
/* ("arg1=""arg2=" */ \
/* ,Ijeu_de_la_vie_generalise_____force_de_la_vie */ \
/* ,Ijeu_de_la_vie_generalise_variable_____rapport_critique */ \
/* ,Ijeu_de_la_vie_generalise_____rapport_critique */ \
/* ,Pconvolution_____ponderation_de_Pconvolution_____maximum_sur_la_spirale */ \
/* ); */ \
/* */ \
/* qui evidemment ne correspond a rien de "coherent" (il s'agit juste d'un test...). */
#define GET_ARGUMENTS4_P(titre_attendu,parametre_P1,parametre_P2,parametre_P3,parametre_P4) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(parametre_P1,parametre_P4) \
,GESTION_DE_L_IMBRICATION_FORMAT_P("P1"),parametre_P1 \
,GESTION_DE_L_IMBRICATION_FORMAT_P("P4"),parametre_P4 \
,BLOC(Bblock \
INCK(GET_ARGUMENTS4_P_____Pcompteur_DAppel); \
\
GET_ARGUMENTS3_P(titre_attendu \
,parametre_P1 \
,parametre_P2 \
,parametre_P3 \
); \
\
EGAL(parametre_P4,parametre_P1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de quatre arguments "genere_p" (introduit le 20111018094618). */
#define GET_ARGUMENTS5_L(titre_attendu,param_L1,param_L2,param_L3,param_L4,param_L5) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(param_L1,param_L5) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L1"),ETAT_LOGIQUE(param_L1) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L5"),ETAT_LOGIQUE(param_L5) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS5_L_____Pcompteur_DAppel); \
\
GET_ARGUMENTS4_L(titre_attendu \
,param_L1 \
,param_L2 \
,param_L3 \
,param_L4 \
); \
\
EGAL(param_L5,param_L1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de cinq arguments "Logical" (introduit le 20150528123220). */
#define GET_ARGUMENTS5_N(titre_attendu,param_N1,param_N2,param_N3,param_N4,param_N5) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(param_N1,param_N5) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N1"),ETAT_LOGIQUE(param_N1) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N5"),ETAT_LOGIQUE(param_N5) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS5_N_____Pcompteur_DAppel); \
\
GET_ARGUMENTS4_N(titre_attendu \
,param_N1 \
,param_N2 \
,param_N3 \
,param_N4 \
); \
\
EGAL(param_N5,param_N1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de cinq arguments "Logical" inverse -ou "Negate"- (introduit le */ \
/* 20150528123220). */
#define GET_ARGUMENTS6_L(titre_attendu,param_L1,param_L2,param_L3,param_L4,param_L5,param_L6) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(param_L1,param_L6) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L1"),ETAT_LOGIQUE(param_L1) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L6"),ETAT_LOGIQUE(param_L6) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS6_L_____Pcompteur_DAppel); \
\
GET_ARGUMENTS5_L(titre_attendu \
,param_L1 \
,param_L2 \
,param_L3 \
,param_L4 \
,param_L5 \
); \
\
EGAL(param_L6,param_L1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de six arguments "Logical" (introduit le 20150528123220). */
#define GET_ARGUMENTS6_N(titre_attendu,param_N1,param_N2,param_N3,param_N4,param_N5,param_N6) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(param_N1,param_N6) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N1"),ETAT_LOGIQUE(param_N1) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N6"),ETAT_LOGIQUE(param_N6) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS6_N_____Pcompteur_DAppel); \
\
GET_ARGUMENTS5_N(titre_attendu \
,param_N1 \
,param_N2 \
,param_N3 \
,param_N4 \
,param_N5 \
); \
\
EGAL(param_N6,param_N1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de six arguments "Logical" inverse -ou "Negate"- (introduit le */ \
/* 20150528123220). */
#define GET_ARGUMENTS7_L(titre_attendu,param_L1,param_L2,param_L3,param_L4,param_L5,param_L6,param_L7) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(param_L1,param_L7) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L1"),ETAT_LOGIQUE(param_L1) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L7"),ETAT_LOGIQUE(param_L7) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS7_L_____Pcompteur_DAppel); \
\
GET_ARGUMENTS6_L(titre_attendu \
,param_L1 \
,param_L2 \
,param_L3 \
,param_L4 \
,param_L5 \
,param_L6 \
); \
\
EGAL(param_L7,param_L1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de sept arguments "Logical" (introduit le 20150528123220). */
#define GET_ARGUMENTS7_N(titre_attendu,param_N1,param_N2,param_N3,param_N4,param_N5,param_N6,param_N7) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(param_N1,param_N7) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N1"),ETAT_LOGIQUE(param_N1) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N7"),ETAT_LOGIQUE(param_N7) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS7_N_____Pcompteur_DAppel); \
\
GET_ARGUMENTS6_N(titre_attendu \
,param_N1 \
,param_N2 \
,param_N3 \
,param_N4 \
,param_N5 \
,param_N6 \
); \
\
EGAL(param_N7,param_N1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de sept arguments "Logical" inverse -ou "Negate"- (introduit le */ \
/* 20150528123220). */
#define GET_ARGUMENTS8_L(titre_attendu,param_L1,param_L2,param_L3,param_L4,param_L5,param_L6,param_L7,param_L8) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(param_L1,param_L8) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L1"),ETAT_LOGIQUE(param_L1) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L8"),ETAT_LOGIQUE(param_L8) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS8_L_____Pcompteur_DAppel); \
\
GET_ARGUMENTS7_L(titre_attendu \
,param_L1 \
,param_L2 \
,param_L3 \
,param_L4 \
,param_L5 \
,param_L6 \
,param_L7 \
); \
\
EGAL(param_L8,param_L1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de huit arguments "Logical" (introduit le 20150528123220). */
#define GET_ARGUMENTS8_N(titre_attendu,param_N1,param_N2,param_N3,param_N4,param_N5,param_N6,param_N7,param_N8) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(param_N1,param_N8) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N1"),ETAT_LOGIQUE(param_N1) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N8"),ETAT_LOGIQUE(param_N8) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS8_N_____Pcompteur_DAppel); \
\
GET_ARGUMENTS7_N(titre_attendu \
,param_N1 \
,param_N2 \
,param_N3 \
,param_N4 \
,param_N5 \
,param_N6 \
,param_N7 \
); \
\
EGAL(param_N8,param_N1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de huit arguments "Logical" inverse -ou "Negate"- (introduit le */ \
/* 20150528123220). */
#define GET_ARGUMENTS9_L(titre_attendu,param_L1,param_L2,param_L3,param_L4,param_L5,param_L6,param_L7,param_L8,param_L9) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(param_L1,param_L9) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L1"),ETAT_LOGIQUE(param_L1) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L9"),ETAT_LOGIQUE(param_L9) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS9_L_____Pcompteur_DAppel); \
\
GET_ARGUMENTS8_L(titre_attendu \
,param_L1 \
,param_L2 \
,param_L3 \
,param_L4 \
,param_L5 \
,param_L6 \
,param_L7 \
,param_L8 \
); \
\
EGAL(param_L9,param_L1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de neuf arguments "Logical" (introduit le 20150528124434). */
#define GET_ARGUMENTS9_N(titre_attendu,param_N1,param_N2,param_N3,param_N4,param_N5,param_N6,param_N7,param_N8,param_N9) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(param_N1,param_N9) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N1"),ETAT_LOGIQUE(param_N1) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N9"),ETAT_LOGIQUE(param_N9) \
,BLOC(Bblock \
INCK(GET_ARGUMENTS9_N_____Pcompteur_DAppel); \
\
GET_ARGUMENTS8_N(titre_attendu \
,param_N1 \
,param_N2 \
,param_N3 \
,param_N4 \
,param_N5 \
,param_N6 \
,param_N7 \
,param_N8 \
); \
\
EGAL(param_N9,param_N1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de neuf arguments "Logical" inverse -ou "Negate"- (introduit le */ \
/* 20150528124434). */
#define GET_ARGUMENTSa_L(titre_attendu,param_L1,param_L2,param_L3,param_L4,param_L5,param_L6,param_L7,param_L8,param_L9,param_La) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(param_L1,param_La) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("L1"),ETAT_LOGIQUE(param_L1) \
,GESTION_DE_L_IMBRICATION_FORMAT_L("La"),ETAT_LOGIQUE(param_La) \
,BLOC(Bblock \
INCK(GET_ARGUMENTSa_L_____Pcompteur_DAppel); \
\
GET_ARGUMENTS9_L(titre_attendu \
,param_L1 \
,param_L2 \
,param_L3 \
,param_L4 \
,param_L5 \
,param_L6 \
,param_L7 \
,param_L8 \
,param_L9 \
); \
\
EGAL(param_La,param_L1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de dix arguments "Logical" (introduit le 20150528124434). */
#define GET_ARGUMENTSa_N(titre_attendu,param_N1,param_N2,param_N3,param_N4,param_N5,param_N6,param_N7,param_N8,param_N9,param_Na) \
Bblock \
GESTION_DE_L_IMBRICATION____DES_GET_ARGUMENTSn_x(__MACRO__,titre_attendu \
,IFNE(param_N1,param_Na) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("N1"),ETAT_LOGIQUE(param_N1) \
,GESTION_DE_L_IMBRICATION_FORMAT_N("Na"),ETAT_LOGIQUE(param_Na) \
,BLOC(Bblock \
INCK(GET_ARGUMENTSa_N_____Pcompteur_DAppel); \
\
GET_ARGUMENTS9_N(titre_attendu \
,param_N1 \
,param_N2 \
,param_N3 \
,param_N4 \
,param_N5 \
,param_N6 \
,param_N7 \
,param_N8 \
,param_N9 \
); \
\
EGAL(param_Na,param_N1); \
Eblock \
) \
); \
Eblock \
/* Recuperation de dix arguments "Logical" inverse -ou "Negate"- (introduit le */ \
/* 20150528124434). */
#define PROKESS_ARGUMENT_K(titre_attendu,parametre_K,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_K(arguments,titre_attendu,parametre_K,parametre_K,seq1,seqI,seqC,seqN); \
Eblock \
/* Recuperation d'un argument "caractere" avec execution d'un post-traitement. */
#define PROKESS_ARGUMENT_C(titre_attendu,parametre_C,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_C(arguments,titre_attendu,parametre_C,parametre_C,seq1,seqI,seqC,seqN); \
Eblock \
/* Recuperation d'un argument "chaine de caracteres" avec execution d'un post-traitement. */
#define PROKESS_ARGUMENT_L(titre_attendu,parametre_L,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_L(arguments,titre_attendu,parametre_L,parametre_L,seq1,seqI,seqC,seqN); \
Eblock \
/* Recuperation d'un argument "Logical" avec execution d'un post-traitement. */
#define PROKESS_ARGUMENT_N(titre_attendu,parametre_N,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_N(arguments,titre_attendu,parametre_N,parametre_N,seq1,seqI,seqC,seqN); \
Eblock \
/* Recuperation d'un argument "Logical" inverse (ou "Negate") avec execution d'un */ \
/* post-traitement. */
#define PROKESS_ARGUMENT_I(titre_attendu,parametre_I,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_I(arguments,titre_attendu,parametre_I,parametre_I,seq1,seqI,seqC,seqN); \
Eblock \
/* Recuperation d'un argument "Int" avec execution d'un post-traitement. */
#define PROKESS_ARGUMENT_X(titre_attendu,parametre_X,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_X(arguments,titre_attendu,parametre_X,parametre_X,seq1,seqI,seqC,seqN); \
Eblock \
/* Recuperation d'un argument "Int" avec execution d'un post-traitement avec edition */ \
/* hexa-decimale (introduit le 20070421093557). */
#define PROKESS_ARGUMENT_F(titre_attendu,parametre_F,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_F(arguments,titre_attendu,parametre_F,parametre_F,seq1,seqI,seqC,seqN); \
Eblock \
/* Recuperation d'un argument "Float" avec execution d'un post-traitement. */
#define PROKESS_ARGUMENT_P(titre_attendu,parametre_P,seq1,seqI,seqC,seqN) \
Bblock \
PROKESS_PARAMETRE_P(arguments,titre_attendu,parametre_P,parametre_P,seq1,seqI,seqC,seqN); \
Eblock \
/* Recuperation d'un argument "genere_p" avec execution d'un post-traitement. */
#define PROKESF_ARGUMENT_C(titre_attendu,parametre_C,seq1,seqI,seqC,seqN) \
Bblock \
INCK(PROKESF_ARGUMENT_C_____Pcompteur_DAppel); \
\
gPROCESS_PARAMETRE(arguments \
,titre_attendu \
,parametre_C \
,parametre_C \
,FconversionC \
,NEUT \
,seq1 \
,seqI \
,NE_PAS_FORCER_sequenceC_DANS_gPROCESS_PARAMETRE_LORS_DE_LA_DERNIERE_RECHERCHE \
,seqC \
,seqN \
,styp_C \
,PERMETTRE_LES_ABREVIATIONS_DANS_gPROCESS_PARAMETRE \
,ityp_C \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un argument "chaine de caracteres" avec execution d'un post-traitement */ \
/* avec forcage de l'execution de 'seqC' au "dernier tour" introduit le 20000207110651. */ \
/* C'est "Forcage" qui justifie le 'F' de 'PROCESF_ARGUMENT_C'... */ \
/* */ \
/* Enfin, on notera que je n'ai introduit que 'PROCESF_ARGUMENT_C(...)' (et pas les */ \
/* {_K,_L,_I,_F,_P} par symetrie) car lui-seul a de l'interet associe a la lecture de */ \
/* fichiers. Mais si besoin etait, cela serait simple que de les introduire... */ \
/* */ \
/* En fait, j'ai decouvert le 20000207173145 que cela ne marchait pas. En effet, tout */ \
/* argument de ce type va donc voir l'execution forcee de 'seqC' lors du dernier */ \
/* tour ; or cela n'est pas toujours souhaite. Ainsi, dans le cas de fichiers, on peut */ \
/* vouloir donner a tous leurs elements la valeur par defaut et non pas les connecter */ \
/* au "pipe". Donc : */ \
/* */ \
/* FORCER_sequenceC_DANS_gPROCESS_PARAMETRE_LORS_DE_LA_DERNIERE_RECHERCHE */ \
/* */ \
/* a ete remplace par : */ \
/* */ \
/* NE_PAS_FORCER_sequenceC_DANS_gPROCESS_PARAMETRE_LORS_DE_LA_DERNIERE_RECHERCHE */ \
/* */ \
/* et ainsi on devrait revenir a la version anterieure, sans malgre tout detruire cette */ \
/* possibilite... */ \
/* */ \
/* Le 20030704142017, les abreviations ont ete autorisees uniquement dans la definition */ \
/* de 'PROCESF_ARGUMENT_C(...)'. */
#define PROKESF_ARGUMENT_FICHIER(titre_attendu,nom_du_fichier,liste_des_valeurs,valeur_par_defaut,transformation,generation) \
Bblock \
INCK(PROKESF_ARGUMENT_FICHIER_____Pcompteur_DAppel); \
\
PROKESF_ARGUMENT_C(titre_attendu,nom_du_fichier \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
,BLOC(transformation(nom_du_fichier \
,liste_des_valeurs \
,valeur_par_defaut \
); \
) \
,BLOC(generation(liste_des_valeurs,valeur_par_defaut);) \
); \
Eblock \
/* Recuperation d'un argument de type "fichier" (introduit le 20190408143526)... */
/* On notera le passage de "_____xxxx" a "____________________xxxx" le 20021105094657 */
/* dans la definition des 'DebutParametres...' et 'FinParametres...' afin qu'ils soient */
/* plus visibles... */
#define PROCESS_ARGUMENT_K(titre_attendu,parametre_K,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENT_K_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE_K(arguments,titre_attendu,parametre_K,parametre_K,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "caractere" avec execution d'un post-traitement. */
#define PROCESS_ARGUMENT_C(titre_attendu,parametre_C,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENT_C_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE_C(arguments,titre_attendu,parametre_C,parametre_C,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "chaine de caracteres" avec execution d'un post-traitement. */
#define PROCESS_ARGUMENT_FICHIER(titre_attendu,nom_du_fichier,liste_des_valeurs,valeur_par_defaut,transformation) \
Bblock \
INCK(PROCESS_ARGUMENT_FICHIER_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_C(titre_attendu,nom_du_fichier \
,BLOC(VIDE;) \
,BLOC(transformation(nom_du_fichier \
,liste_des_valeurs \
,valeur_par_defaut \
); \
) \
); \
Eblock \
/* Recuperation d'un argument de type "fichier" (introduit le 20190403133126 et completes */ \
/* le 20190403141454, puis simplifie le 20190404081830)... */
#define PROCESS_ARGUMENT_L(titre_attendu,parametre_L,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENT_L_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE_L(arguments,titre_attendu,parametre_L,parametre_L,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "Logical" avec execution d'un post-traitement. */
#define PROCESS_ARGUMENT_N(titre_attendu,parametre_N,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENT_N_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE_N(arguments,titre_attendu,parametre_N,parametre_N,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "Logical" inverse (ou "Negate") avec execution d'un */ \
/* post-traitement. */ \
/* */ \
/* ATTENTION : en ce qui concerne l'usage de 'PROCESS_ARGUMENT_N(...)', il est suggere de */ \
/* consulter 'v $xig/fonct$vv$DEF .carree=' ou encore 'v $xci/gauss$K 20071226163024'... */
#define PROCESS_ARGUMENT_I(titre_attendu,parametre_I,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENT_I_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE_I(arguments,titre_attendu,parametre_I,parametre_I,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "Int" avec execution d'un post-traitement. */
#define PROCESS_ARGUMENT_J(titre_attendu,parametre_J,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENT_J_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE_J(arguments,titre_attendu,parametre_J,parametre_J,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "Int" avec execution d'un post-traitement (introduit le */ \
/* 20111213132424). */
#define PROCESS_ARGUMENT_X(titre_attendu,parametre_X,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENT_X_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE_X(arguments,titre_attendu,parametre_X,parametre_X,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "Int" avec execution d'un post-traitement avec edition */ \
/* hexa-decimale (introduit le 20070421093557). */
#define PROCESS_ARGUMENT_Y(titre_attendu,parametre_Y,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENT_Y_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE_Y(arguments,titre_attendu,parametre_Y,parametre_Y,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "Int" avec execution d'un post-traitement avec edition */ \
/* hexa-decimale (introduit le 20111213132424). */
#define PROCESS_ARGUMENT_F(titre_attendu,parametre_F,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENT_F_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE_F(arguments,titre_attendu,parametre_F,parametre_F,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "Float" avec execution d'un post-traitement. */
#define PROCESS_ARGUMENT_P(titre_attendu,parametre_P,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENT_P_____Pcompteur_DAppel); \
\
PROCESS_PARAMETRE_P(arguments,titre_attendu,parametre_P,parametre_P,sequenceI,sequenceC); \
Eblock \
/* Recuperation d'un argument "genere_p" avec execution d'un post-traitement. */
#define PROCESS_ARGUMENTS2_K(titre_attendu,parametre_K1,parametre_K2,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENTS2_K_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_K(titre_attendu,parametre_K1,sequenceI,sequenceC); \
EGAL(parametre_K2,parametre_K1); \
Eblock \
/* Recuperation de deux arguments "caractere" avec execution d'un post-traitement */ \
/* (introduit le 20100105100659). */
#define PROCESS_ARGUMENTS2_C(titre_attendu,parametre_C1,parametre_C2,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENTS2_C_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_C(titre_attendu,parametre_C1,sequenceI,sequenceC); \
EGAp(parametre_C2,chain_Acopie(parametre_C1)); \
Eblock \
/* Recuperation de deux arguments "chaine de caracteres" avec execution d'un post-traitement */ \
/* (introduit le 20100105100659). */
#define PROCESS_ARGUMENTS2_L(titre_attendu,parametre_L1,parametre_L2,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENTS2_L_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_L(titre_attendu,parametre_L1,sequenceI,sequenceC); \
EGAL(parametre_L2,parametre_L1); \
Eblock \
/* Recuperation de deux arguments "Logical" avec execution d'un post-traitement */ \
/* (introduit le 20100105100659). */
#define PROCESS_ARGUMENTS2_N(titre_attendu,parametre_N1,parametre_N2,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENTS2_N_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_N(titre_attendu,parametre_N1,sequenceI,sequenceC); \
EGAL(parametre_N2,parametre_N1); \
Eblock \
/* Recuperation de deux arguments "Logical" inverse (ou "Negate") avec execution d'un */ \
/* post-traitement (introduit le 20100105100659). */
#define PROCESS_ARGUMENTS2_I(titre_attendu,parametre_I1,parametre_I2,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENTS2_I_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_I(titre_attendu,parametre_I1,sequenceI,sequenceC); \
EGAL(parametre_I2,parametre_I1); \
Eblock \
/* Recuperation de deux arguments "Int" avec execution d'un post-traitement */ \
/* (introduit le 20100105100659). */
#define PROCESS_ARGUMENTS2_X(titre_attendu,parametre_X1,parametre_X2,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENTS2_X_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_X(titre_attendu,parametre_X1,sequenceI,sequenceC); \
EGAL(parametre_X2,parametre_X1); \
Eblock \
/* Recuperation de deux arguments "Int" avec execution d'un post-traitement avec edition */ \
/* hexa-decimale (introduit le 20100105100659). */
#define PROCESS_ARGUMENTS2_F(titre_attendu,parametre_F1,parametre_F2,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENTS2_F_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_F(titre_attendu,parametre_F1,sequenceI,sequenceC); \
EGAL(parametre_F2,parametre_F1); \
Eblock \
/* Recuperation de deux arguments "Float" avec execution d'un post-traitement */ \
/* (introduit le 20100105100659). */
#define PROCESS_ARGUMENTS2_P(titre_attendu,parametre_P1,parametre_P2,sequenceI,sequenceC) \
Bblock \
INCK(PROCESS_ARGUMENTS2_P_____Pcompteur_DAppel); \
\
PROCESS_ARGUMENT_P(titre_attendu,parametre_P1,sequenceI,sequenceC); \
EGAL(parametre_P2,parametre_P1); \
Eblock \
/* Recuperation de deux arguments "genere_p" avec execution d'un post-traitement */ \
/* (introduit le 20100105100659). */
#define PROCESF_ARGUMENT_C(titre_attendu,parametre_C,sequenceI,sequenceC) \
Bblock \
INCK(PROCESF_ARGUMENT_C_____Pcompteur_DAppel); \
\
gPROCESS_PARAMETRE(arguments \
,titre_attendu \
,parametre_C \
,parametre_C \
,FconversionC \
,NEUT \
,BLOC(VIDE;) \
,sequenceI \
,NE_PAS_FORCER_sequenceC_DANS_gPROCESS_PARAMETRE_LORS_DE_LA_DERNIERE_RECHERCHE \
,sequenceC \
,BLOC(VIDE;) \
,styp_C \
,PERMETTRE_LES_ABREVIATIONS_DANS_gPROCESS_PARAMETRE \
,ityp_C \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
Eblock \
/* Recuperation d'un argument "chaine de caracteres" avec execution d'un post-traitement */ \
/* avec forcage de l'execution de 'seqC' au "dernier tour" introduit le 20000207110651. */ \
/* C'est "Forcage" qui justifie le 'F' de 'PROCESF_ARGUMENT_C'... */ \
/* */ \
/* Enfin, on notera que je n'ai introduit que 'PROCESF_ARGUMENT_C(...)' (et pas les */ \
/* {_K,_L,_I,_F,_P} par symetrie) car lui-seul a de l'interet associe a la lecture de */ \
/* fichiers. Mais si besoin etait, cela serait simple que de les introduire... */ \
/* */ \
/* En fait, j'ai decouvert le 20000207173145 que cela ne marchait pas. En effet, tout */ \
/* argument de ce type va donc voir l'execution forcee de 'seqC' lors du dernier */ \
/* tour ; or cela n'est pas toujours souhaite. Ainsi, dans le cas de fichiers, on peut */ \
/* vouloir donner a tous leurs elements la valeur par defaut et non pas les connecter */ \
/* au "pipe". Donc : */ \
/* */ \
/* FORCER_sequenceC_DANS_gPROCESS_PARAMETRE_LORS_DE_LA_DERNIERE_RECHERCHE */ \
/* */ \
/* a ete remplace par : */ \
/* */ \
/* NE_PAS_FORCER_sequenceC_DANS_gPROCESS_PARAMETRE_LORS_DE_LA_DERNIERE_RECHERCHE */ \
/* */ \
/* et ainsi on devrait revenir a la version anterieure, sans malgre tout detruire cette */ \
/* possibilite... */ \
/* */ \
/* Le 20030704142017, les abreviations ont ete autorisees uniquement dans la definition */ \
/* de 'PROCESF_ARGUMENT_C(...)'. */
#define PROCESF_ARGUMENT_FICHIER(titre_attendu,nom_du_fichier,liste_des_valeurs,valeur_par_defaut,transformation) \
Bblock \
INCK(PROCESF_ARGUMENT_FICHIER_____Pcompteur_DAppel); \
\
PROCESF_ARGUMENT_C(titre_attendu,nom_du_fichier \
,BLOC(VIDE;) \
,BLOC(transformation(nom_du_fichier \
,liste_des_valeurs \
,valeur_par_defaut \
); \
) \
); \
Eblock \
/* Recuperation d'un argument de type "fichier" (introduit le 20190408143526)... */
/* On notera le passage de "_____xxxx" a "____________________xxxx" le 20021105094657 */
/* dans la definition des 'DebutParametres...' et 'FinParametres...' afin qu'ils soient */
/* plus visibles... */
#define DETECTION_DE_PRESENCE_D_UN_ARGUMENT_OBLIGATOIRE \
Bblock \
Test(I4OU(I4OU(IL_FAUT(editer_la_valeur_des_parametres_d_une_commande) \
,IL_FAUT(editer_le_NOM_SYNTHETIQUE_de_la_commande_courante) \
,IL_FAUT(editer_le_NOM_ABSOLU_DU_SOURCE_c_de_la_commande_courante) \
,IL_FAUT(lister_tous_les_messages_possibles) \
) \
,I6OU(IL_FAUT(permettre_l_acces_au_source_du_programme) \
,IL_FAUT(permettre_l_acces_a_la_liste_des_fonctions_referencees_par_le_programme) \
,IL_FAUT(editer_les_differentes_versions_du_programme) \
,IL_FAUT(editer_les_differentes_versions_du_programme_dans_les_librairies_dynamiques) \
,IL_FAUT(editer_la_liste_des_librairies_dynamiques_utilisees) \
,IL_FAUT(editer_les_differents_includes_du_programme) \
) \
,IL_FAUT(editer_les_differents_bugs_reconnus) \
,IL_FAUT(ne_rien_faire_et_sortir_immediatement) \
) \
) \
/* Test introduit le 20070330085246 car, en effet, a cette date, il manquait. A la date du */ \
/* 20070331110328 il fut complete avec le test de 'ne_rien_faire_et_sortir_immediatement'... */ \
/* */ \
/* Le test de 'editer_les_differentes_versions_du_programme_dans_les_librairies_dynamiques' */ \
/* a ete introduit le 20111009110606 car, en effet, il manquait... */ \
/* */ \
/* Le test de 'editer_la_liste_des_librairies_dynamiques_utilisees' a ete introduit le */ \
/* 20220824180116... */ \
Bblock \
Eblock \
ATes \
Bblock \
Test(I4ET(EST_VRAI(c_est_la_derniere_recherche_des_parametres) \
,IZEQ(ITb1(UTILISATION_des_arguments_possibles \
,INDX(numero_de_l_argument_possible_courant__en_tenant________compte_des_synonymes \
,PREMIER_NUMERO_UNIQUE_DES_ARGUMENTS_POSSIBLES \
) \
) \
) \
/* C'est 'numero_de_l_argument_possible_courant__en_tenant________compte_des_synonymes' */ \
/* qui indexe et non pas 'NUMERO_de_l_argument_possible_courant' car, en effet, ce dernier */ \
/* n'est incremente que si 'EST_VRAI(c_est_la_derniere_recherche_des_parametres' */ \
/* semble-t-il... */ \
,EST_FAUX(au_moins_un_titre_synonyme_a_ete_reconnu_parmi_la_liste_des_titres_synonymes) \
,EST_VRAI(tous_____titre_attendu_____ont_ete_recupere_dans_liste_titres_synonymes) \
) \
) \
/* Avant le 20070323154106, le test precedent etait : */ \
/* */ \
/* Test(IFET(EST_VRAI(c_est_la_derniere_recherche_des_parametres) */ \
/* ,ABSENT(valeur_recherchee_dans_la_liste_des_arguments) */ \
/* ) */ \
/* ) */ \
/* */ \
/* ce qui avait pour effet d'editer le message qui suit pour chacun des synonymes d'une */ \
/* liste de synonymes et ce meme si l'un de ces synonymes avaient ete utilise comme argument */ \
/* et donc reconnu. A compter du 20070323154106 le message suivant ne peut etre emis que */ \
/* lors du traitement du dernier synonyme d'une liste de synonymes (grace a l'indicateur */ \
/* 'tous_____titre_attendu_____ont_ete_recupere_dans_liste_titres_synonymes') et */ \
/* si aucun synonyme de cette liste n'a ete utilise dans 'liste_des_arguments' (grace a */ \
/* 'au_moins_un_titre_synonyme_a_ete_reconnu_parmi_la_liste_des_titres_synonymes'). */ \
/* */ \
/* Le 20070820113942 fut introduit le test de 'UTILISATION_des_arguments_possibles'... */ \
/* deja ete incremente lorsque l'on arrive ici... */ \
Bblock \
PRINT_ERREUR("un argument dont la presence est obligatoire est absent"); \
CAL1(Prer1(COND(IFEQ(compteur_des_synonymes_de_____titre_attendu,UN) \
,ccCHAR("(il s'agit de l'argument '%s')\n") \
,ccCHAR("(il s'agit de l'un des arguments synonymes suivants '%s')\n") \
) \
,liste_des_____titre_attendu_____synonymes \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
/* Ce detecteur de presence d'un argument obligatoire a ete introduit le 20070323151657. */ \
/* Pour voir comment cela s'utilise, imaginons l'argument suivant : */ \
/* */ \
/* GET_ARGUMENT_?("nom=",valeur); */ \
/* */ \
/* et supposons que l'on veuille rendre sa presence obligatoire. Il suffira alors de */ \
/* remplacer le 'GET_ARGUMENT_?(...)' precedent par : */ \
/* */ \
/* PROCESS_ARGUMENT_?("nom=",valeur */ \
/* ,BLOC(DETECTION_DE_PRESENCE_D_UN_ARGUMENT_OBLIGATOIRE;) */ \
/* ,BLOC(VIDE;) */ \
/* ) */ \
/* */ \
/* ('v $xcg/ABSO.01$K DETECTION_DE_PRESENCE_D_UN_ARGUMENT_OBLIGATOIRE') pour que le tour */ \
/* soit joue. On notera au passage que cette detection se fait dans la sequence */ \
/* inconditionnelle 'seqI' de 'PROCESS_ARGUMENT_?(...)'. Au passage, '"nom="' peut etre */ \
/* evidemment une liste de synonymes auquel cas, l'anomalie sera signalee pour chacun des */ \
/* synonymes, alors qu'il serait peut-etre plus logique qu'elle ne sorte qu'une seule fois. */ \
/* Ce dernier probleme fut resolu le 20070323154106 ; desormais, c'est le dernier synonyme */ \
/* de la liste qui est edite si aucun des synonymes n'a ete reconnu... */ \
/* */ \
/* Avant le 20070325172306, l'edition etait : */ \
/* */ \
/* CAL1(Prer1("(son dernier -son seul ?- synonyme est '%s')\n" */ \
/* ,titre_attendu_unique_parmi_une_liste_de_titres_synonymes */ \
/* ) */ \
/* ); */ \
/* */ \
/* qui n'editait que le dernier synonyme de la liste... */ \
/* */ \
/* Le 20070820082420, la procedure 'DETECTION_DE_PRESENCE_D_UN_ARGUMENT_OBLIGATOIRE' a */ \
/* montre une fonctionnement incorrect : elle detectait l'absence d'un parametre obligatoire */ \
/* si celui-ci etait present, alors qu'un ou plusieurs autres parametres le suivait. Cela */ \
/* s'est vu a ce moment-la avec le test : */ \
/* */ \
/* $xcg/ABSO.01$X x=1 K_LF=VRAI */ \
/* */ \
/* "x=" etant declare absent ! Le probleme vient du fait que c'est en traitant "K_LF=VRAI" */ \
/* que la condition 'c_est_la_derniere_recherche_des_parametres' est 'VRAI'. En passant */ \
/* sur la tentative de recuperation de "x=", elle echoue puisque l'on en est en train de */ \
/* recuperer "K_LF=" ("x=" a ete recuperee lors de la boucle precedente...) et l'on */ \
/* considere donc, a tort, que "x=" est absent... */ \
/* */ \
/* Il a fallu introduire 'UTILISATION_des_arguments_possibles' pour resoudre ce probleme... */
#define MARQUEUR________DebutParametresGeneraux \
Bblock \
GET_ARGUMENT_M("____________________DebutParametresGeneraux=",marqueur_____debut_des_parametres_generaux); \
Eblock \
/* Argument fictif destine a marquer le debut des Parametres Generaux (le 20010420143829) */ \
/* lors de l'edition "Parametres=VRAI". Il doit etre le premier... */
#define MARQUEUR________FinParametresGeneraux \
Bblock \
GET_ARGUMENT_M("____________________FinParametresGeneraux=",marqueur_____fin_des_parametres_generaux); \
Eblock \
/* Argument fictif destine a marquer la fin des Parametres Generaux (le 20010420143829) */ \
/* lors de l'edition "Parametres=VRAI". Il doit etre le dernier... */
#define MARQUEUR________DebutParametresAutomatiques \
Bblock \
GET_ARGUMENT_M("____________________DebutParametresAutomatiques=",marqueur_____debut_des_parametres_automatiques); \
Eblock \
/* Argument fictif destine a marquer le debut des Parametres mis en place Automatiquement */ \
/* (le 20120701115154) lors de l'edition "Parametres=VRAI". Il doit etre le premier... */
#define MARQUEUR________FinParametresAutomatiques \
Bblock \
GET_ARGUMENT_M("____________________FinParametresAutomatiques=",marqueur_____fin_des_parametres_automatiques); \
Eblock \
/* Argument fictif destine a marquer la fin des Parametres mis en place Automatiquement */ \
/* (le 20120701115154) lors de l'edition "Parametres=VRAI". Il doit etre le dernier... */
#define MARQUEUR________DebutParametresImages \
Bblock \
GET_ARGUMENT_M("____________________DebutParametresImages=",marqueur_____debut_des_parametres_images); \
Eblock \
/* Argument fictif destine a marquer le debut des Parametres Generaux de nature "Image" */ \
/* (le 20020626162809) lors de l'edition "Parametres=VRAI". Il doit etre le premier... */
#define MARQUEUR________FinParametresImages \
Bblock \
GET_ARGUMENT_M("____________________FinParametresImages=",marqueur_____fin_des_parametres_images); \
Eblock \
/* Argument fictif destine a marquer la fin des Parametres Generaux de nature "Image" */ \
/* (le 20020626162809) lors de l'edition "Parametres=VRAI". Il doit etre le dernier... */
#define MARQUEUR________DebutParametresSpecifiques \
Bblock \
GET_ARGUMENT_M("____________________DebutParametresSpecifiques=",marqueur_____debut_des_parametres_specifiques); \
Eblock \
/* Argument fictif destine a marquer le debut des Parametres Specifiques (20010421090617) */ \
/* lors de l'edition "Parametres=VRAI". Il doit etre le premier... */
#define MARQUEUR________FinParametresSpecifiques \
Bblock \
GET_ARGUMENT_M("____________________FinParametresSpecifiques=",marqueur_____fin_des_parametres_specifiques); \
Eblock \
/* Argument fictif destine a marquer la fin des Parametres Specifiques (20010421090617) */ \
/* lors de l'edition "Parametres=VRAI". Il doit etre le dernier... */
#ifdef Ftraitement_des_formats_de_sortie_VERSION_01
# define INITIALISATIONS_DE_GET_ARGUMENTS_DE_CONTROLE_DE_TRAITEMENT_DES_FORMATS_DE_SORTIE \
Bblock \
Test(EST_FAUX(STANDARD_OUT_EST_UN_PIPE)) \
/* Ceci est inspire de 'v $xtc/files.12$c'... */ \
/* */ \
/* L'appel a 'STANDARD_OUT_EST_UN_PIPE' a ete introduit le 20051117101713... */ \
Bblock \
EGAL(FPrin_____supprimer_les_K_BLANCs_autour_des_K_EGAL,FAUX); \
EGAL(FPrin_____supprimer_les_K_BLANCs_redondants,FAUX); \
/* Lorsque 'STANDARD_OUT' est vraiment la "sortie standard", on autorise par defaut les */ \
/* 'K_BLANC's autour des 'K_EGAL's. Ainsi, en mode interactif on respecte, la mise en page */ \
/* originale, c'est plus joli... */ \
/* */ \
/* La gestion des blancs redondants a ete introduite le 20150310154259... */ \
Eblock \
ATes \
Bblock \
/* Cas ou 'STANDARD_OUT' est un "pipe" ou une redirection : */ \
EGAL(FPrin_____supprimer_les_K_BLANCs_autour_des_K_EGAL,VRAI); \
EGAL(FPrin_____supprimer_les_K_BLANCs_redondants,SE12(VRAI,FAUX)); \
/* Lorsque 'STANDARD_OUT' est redirige vers un "pipe" ou un fichier", on demande par defaut */ \
/* la suppression des 'K_BLANC's autour des 'K_EGAL's. Ainsi, en mode non interactif, il y */ \
/* aura, par defaut, suppression des 'K_BLANC's autour des 'K_EGAL's afin que tous les */ \
/* programmes se comportent de la meme facon et produisent des resultats compatibles et */ \
/* "standardises"... */ \
/* */ \
/* La gestion des blancs redondants a ete introduite le 20150310154259... */ \
/* */ \
/* Le 20210307181536, a cause des sorties de 'v $xcp/Konstantes$K', la gestion des blancs */ \
/* redondants a ete inversees afin que ses sorties dans des fichiers ou bien dans des */ \
/* "pipe"s restent parfaites... */ \
/* */ \
/* Le 20210324094917, la gestion des blancs redondants a ete de nouveau inversee et ce */ \
/* a cause d'eventuels problemes de compatibilite anterieure comme cela s'est vu la veille */ \
/* avec 'v $xiMo/LOG_xiMc$Z 20210323172314'. Cela a evidemment conduit a la modification */ \
/* 'v $xcp/Konstantes$K 20210324095057'... */ \
Eblock \
ETes \
Eblock \
/* Initialisations utiles au traitement des formats de sortie (introduit le 20050131105740). */ \
/* On notera que 'FPrin_____supprimer_les_K_BLANCs_autour_des_K_DEUX_POINTS' n'est pas */ \
/* concerne par cela ; sa valeur par defaut est toujours 'FAUX'... */
# define GET_ARGUMENTS_DE_CONTROLE_DE_TRAITEMENT_DES_FORMATS_DE_SORTIE \
Bblock \
\
DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
GET_ARGUMENT_L("FormatEditerCaracteresNonReconnus=""fecnr=" \
,chain_Acopie_avec_gestion_des_formats_des_editions_entieres_____editer_carac_non_reconnus \
); \
/* Arguments introduits le 20120118123321... */ \
\
GET_ARGUMENT_L("SupprimerBlancDeuxPoints=""sbdp=",FPrin_____supprimer_les_K_BLANCs_autour_des_K_DEUX_POINTS); \
GET_ARGUMENT_L("SupprimerBlancEgal=""sbe=",FPrin_____supprimer_les_K_BLANCs_autour_des_K_EGAL); \
GET_ARGUMENT_L("SupprimerBlancRedondant=""sbr=",FPrin_____supprimer_les_K_BLANCs_redondants); \
/* Le 20090325094302, ":=" et "==" ont ete remplaces par "sbdp=" et "sbe=" suite a */ \
/* l'introduction possible de 'entrer_des_parametres_via_des_setenv' via une variable */ \
/* d'environnement ('v $xig/fonct$vv$DEF 20090325094302'). */ \
/* */ \
/* L'argument "SupprimerBlancRedondant=" a ete introduit le 20150310154259... */ \
GET_ARGUMENT_L("Pmajuscules=",FPrin_____convertir_les_caracteres_majuscules_en_caracteres_minuscules); \
GET_ARGUMENT_L("Pminuscules=",FPrin_____convertir_les_caracteres_minuscules_en_caracteres_majuscules); \
GET_ARGUMENT_K("Pcarret=",FPrin_____carret_chain_Acopie_avec_conversions_possibles_majuscules_minuscules); \
\
FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
Eblock \
/* L'option "SupprimerBlancEgal=" a ete introduite le 20050127112701 et l'option */ \
/* "SupprimerBlancDeuxPoints=" aux environs du 20050128112507. Les "raccourcis" de ces */ \
/* deux options ('":="' et '"=="' l'ont ete 20050128214158 ; finalement, le 20070221112836, */ \
/* '"=="' a ete supprime a cause de 'v $xig/fonct$vv$DEF 20070221110204' ; le 20070226134221 */ \
/* il fut retabli grace a 'v $xig/fonct$vv$FON 20070226134226'...). */
#Aifdef Ftraitement_des_formats_de_sortie_VERSION_01
#Eifdef Ftraitement_des_formats_de_sortie_VERSION_01
#ifdef Ftraitement_des_formats_de_sortie_VERSION_02
# define INITIALISATIONS_DE_GET_ARGUMENTS_DE_CONTROLE_DE_TRAITEMENT_DES_FORMATS_DE_SORTIE \
Bblock \
BLOC(VIDE;); \
Eblock
# define GET_ARGUMENTS_DE_CONTROLE_DE_TRAITEMENT_DES_FORMATS_DE_SORTIE \
Bblock \
\
DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
BLOC(VIDE;); \
\
FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
Eblock
#Aifdef Ftraitement_des_formats_de_sortie_VERSION_02
#Eifdef Ftraitement_des_formats_de_sortie_VERSION_02
#ifdef PRAGMA_CPP_____AUTORISER_LE_GooF
# ifdef PRAGMA_CPP_____SI_LE_GooF_EST_ACTIVABLE_ALORS_FAIRE_DE_L_ARITHMETIQUE_ETENDUE_DES_NOMBRES_FLOTTANTS
/* Cas de l'arithmetique etendue des nombres flottants : */
# define GET_ARGUMENTS_DE_BASCULE_ENTRE_L_ARITHMETIQUE_DE_BASE_ET_L_ARITHMETIQUE_ETENDUE \
Bblock \
\
DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
/* Introduit le 20070130103328 car, en effet, il manquait... */ \
\
BLOC(VIDE;); \
\
FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
/* Introduit le 20070130103328 car, en effet, il manquait... */ \
\
Eblock \
/* Lorsque le 'GooF' est activable et que l'arithmetique etendue est forcee, alors la */ \
/* bascule avec l'arithmetique de base est evidemment impossible... */
# Aifdef PRAGMA_CPP_____SI_LE_GooF_EST_ACTIVABLE_ALORS_FAIRE_DE_L_ARITHMETIQUE_ETENDUE_DES_NOMBRES_FLOTTANTS
/* Cas de l'arithmetique traditionnelle des nombres flottants : */
# Eifdef PRAGMA_CPP_____SI_LE_GooF_EST_ACTIVABLE_ALORS_FAIRE_DE_L_ARITHMETIQUE_ETENDUE_DES_NOMBRES_FLOTTANTS
#Aifdef PRAGMA_CPP_____AUTORISER_LE_GooF
#Eifdef PRAGMA_CPP_____AUTORISER_LE_GooF
#define use_arithmetique_etendue_et_non_basique \
utiliser_l_arithmetique_etendue_au_lieu_de_l_arithmetique_de_base \
/* Afin de raccourcir certaines lignes ('v $xci/gauss$K _et_non_celle_de_base' par exemple. */ \
/* Ceci a ete introduit le 20071224115515... */ \
/* */ \
/* Le 20071226163917, le symbole 'use_arithmetique_etendue_et_non_celle_de_base' a ete */ \
/* raccourci en 'use_arithmetique_etendue_et_non_basique' et ce principalement a cause de */ \
/* 'v $xci/PolyPolaire$K use_arithmetique_etendue_et_non_basique'... */ \
/* */ \
/* Le 20080126091728, cette definition est sortie du '#ifndef' qui suit a cause de */ \
/* 'v $xrs/surfaces.13$I use_arithmetique_etendue_et_non_basique'... */
#ifndef GET_ARGUMENTS_DE_BASCULE_ENTRE_L_ARITHMETIQUE_DE_BASE_ET_L_ARITHMETIQUE_ETENDUE
# define GET_ARGUMENTS_DE_BASCULE_ENTRE_L_ARITHMETIQUE_DE_BASE_ET_L_ARITHMETIQUE_ETENDUE \
Bblock \
\
DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
GET_ARGUMENT_L("arithmetique_etendue=""arie=" \
,si_le_GooF_est_activable_utiliser_l_arithmetique_etendue_au_lieu_de_l_arithmetique_de_base \
); \
GET_ARGUMENT_N("arithmetique_de_base=""arib=" \
,si_le_GooF_est_activable_utiliser_l_arithmetique_etendue_au_lieu_de_l_arithmetique_de_base \
); \
/* Introduit le 20061018105913... */ \
/* */ \
/* ATTENTION, le 20150417093847, je rappelle l'existence d'indicateurs de controle */ \
/* secondaires necessaires lors des calculs avec les nombres complexes, hyper-complexes */ \
/* et hyper-hyper-complexes. Il s'agit de : */ \
/* */ \
/* 'v $ximcf/common$DEF arithmetique_etendue_C=' */ \
/* 'v $ximcf/common$DEF arithmetique_etendue_HC=' */ \
/* 'v $ximcf/common$DEF arithmetique_etendue_HHC=' */ \
/* */ \
/* et ainsi, il conviendra d'utiliser : */ \
/* */ \
/* [arithmetique_etendue=VRAI] arithmetique_etendue_C=VRAI */ \
/* - */ \
/* [arithmetique_etendue=VRAI] arithmetique_etendue_HC=VRAI */ \
/* -- */ \
/* [arithmetique_etendue=VRAI] arithmetique_etendue_HHC=VRAI */ \
/* ------------------------- --- */ \
/* | */ \
/* | */ \
/* ------> facultatif... */ \
/* */ \
/* pour acceder a l'arithmetique etendue des nombres complexes, hyper-complexes et */ \
/* hyper-hyper-complexes respectivement... */ \
/* */ \
/* */ \
/* ATTENTION, le 20150516094936, je rappelle de plus l'existence d'indicateurs de controle */ \
/* secondaires relatifs a l'usage de 'GENERATION_DU_CHAMP_DEMANDE(...)'. Ainsi, par exemple, */ \
/* pour etendre l'arithmetique de 'v $xci/gauss$K', il conviendra d'utiliser : */ \
/* */ \
/* [arithmetique_etendue=VRAI] arithmetique_etendue_gauss=VRAI */ \
/* ------------------------- ----- */ \
/* | */ \
/* | */ \
/* ------> facultatif... */ \
/* */ \
/* et ceci sera vrai de tous les '$K's utilisant 'GENERATION_DU_CHAMP_DEMANDE(...)'... */ \
\
FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
Eblock \
/* Recuperation des arguments relatifs a la bascule entre l'arithmetique de base et */ \
/* l'arithmetique etendue. Ceci a ete introduit le 20061018132259 sous cette forme... */ \
/* */ \
/* ATTENTION : evidemment ce nouveau parametre n'a d'utilite que dans les programme dans */ \
/* lesquels le 'GooF' est activable et surtout dans les programmes qui utilisent des */ \
/* librairies dans lesquelles le 'GooF' est activable. C'est ainsi le cas du programme */ \
/* 'v $xci/multHC_02.01$K' linkant 'v $xbii/GooF_image$K PRAGMA_CPP_____AUTORISER_LE_GooF'. */
#Aifndef GET_ARGUMENTS_DE_BASCULE_ENTRE_L_ARITHMETIQUE_DE_BASE_ET_L_ARITHMETIQUE_ETENDUE
#Eifndef GET_ARGUMENTS_DE_BASCULE_ENTRE_L_ARITHMETIQUE_DE_BASE_ET_L_ARITHMETIQUE_ETENDUE
#define SIGNE_EGAL \
" = " \
/* Introduit le 20180319112641 pour garantir la presence des espaces entourant "="... */
#define EDITION_DE_LA_VALEUR_DE_LA_PLUPART_DES_COMPTEURS \
Bblock \
CALS(FgEDITION_DE_LA_VALEUR_DE_LA_PLUPART_DES_COMPTEURS()); \
Eblock \
/* Introduit le 20180410205856... */
#define EDITION_DE_LA_VALEUR_DES_COMPTEURS_D_ACCES_AUX_FONCTIONS_DE_BASE \
Bblock \
CALS(FgEDITION_DE_LA_VALEUR_DES_COMPTEURS_D_ACCES_AUX_FONCTIONS_DE_BASE()); \
Eblock \
/* Introduit le 20180413110838... */
#define EDITION_DE_LA_VALEUR_DES_COMPTEURS_D_ALLOCATION_DESALLOCATION_MEMOIRE \
Bblock \
CALS(FgEDITION_DE_LA_VALEUR_DES_COMPTEURS_D_ALLOCATION_DESALLOCATION_MEMOIRE()); \
Eblock \
/* Introduit ainsi le 20180316135439 afin que le code correspondant genere par */ \
/* 'gEDITION_DE_LA_VALEUR_DES_COMPTEURS_D_ALLOCATION_DESALLOCATION_MEMOIRE' ne soit pas */ \
/* implante plusieurs fois via 'ABORT_Commande' et 'RETU_Commande'... */
#define EDITION_DE_LA_VALEUR_DES_COMPTEURS_D_ENTREE_DES_ARGUMENTS_DES_K_S \
Bblock \
CALS(FgEDITION_DE_LA_VALEUR_DES_COMPTEURS_D_ENTREE_DES_ARGUMENTS_DES_K_S()); \
Eblock \
/* Introduit le 20180410123854... */
#define EDITION_D_UN_COMPTEUR_D_ALLOCATION_DESALLOCATION_MEMOIRE(fonction,compteur,tabulation,cumul_des_compteurs) \
Bblock \
CALS(Fedition_d_un_compteur_quelconque("#'kMalo(...)'s de '" \
,fonction \
,EnTete_de_sauvegardA ## compteur \
,tabulation \
) \
); \
/* Cette solution implementee le 20180410180411 permet d'economiser de la memoire puisque */ \
/* les 'CAL3(Prme4(...))' ne sont implementes qu'une seule fois (c'est-a-dire dans la */ \
/* fonction 'Fedition_d_un_compteur_quelconque(...)'. */ \
\
INCR(cumul_des_compteurs \
,EnTete_de_sauvegardA ## compteur \
); \
Eblock \
/* Introduit le 20180318102750... */ \
/* procedure a ete simplifiee le 20180318100021 par passage a deux arguments... */
#define TABULATION_EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE \
CENT
#define EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE(fonction,compteur) \
Bblock \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_DESALLOCATION_MEMOIRE(fonction \
,compteur \
,TABULATION_EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE \
,cumul_des_compteurs_de_toutes_les____allocations_memoire \
); \
Eblock \
/* Introduit le 20180317092429 pour simplifier la mise a jour de ce qui suit. Cette */ \
/* procedure a ete simplifiee le 20180318100021 par passage a deux arguments... */
#define TABULATION_EDITION_D_UN_COMPTEUR_DE_DESALLOCATION_MEMOIRE \
VINGT
#define EDITION_D_UN_COMPTEUR_DE_DESALLOCATION_MEMOIRE(fonction,compteur) \
Bblock \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_DESALLOCATION_MEMOIRE(fonction \
,compteur \
,TABULATION_EDITION_D_UN_COMPTEUR_DE_DESALLOCATION_MEMOIRE \
,cumul_des_compteurs_de_toutes_les_desallocations_memoire \
); \
Eblock \
/* Introduit le 20180317111712 pour simplifier la mise a jour de ce qui suit... */
#define gEDITION_DE_LA_VALEUR_DES_COMPTEURS_D_ALLOCATION_DESALLOCATION_MEMOIRE \
Bblock \
Test(IL_FAUT(FgEDITION_DE_LA_VALEUR_DES_COMPTEURS_D_ALLOCATION_DESALLOCATION_MEMOIRE_____activer)) \
Bblock \
BSaveVariable(Positive,Flist_Gelement_____compteur_des_tMalo); \
BSaveVariable(Positive,Flist_Selement_____compteur_des_kMalo); \
BSaveVariable(Positive,Flist_creation_____compteur_des_tMalo); \
BSaveVariable(Positive,Fload_fichier_non_formatte_____compteur_des_kMalo); \
BSaveVariable(Positive,Fsize_fichier_____compteur_des_kMalo); \
BSaveVariable(Positive,Fstore_fichier_non_formatte_____compteur_des_kMalo); \
BSaveVariable(Positive,Fstore_non_securise_fichier_non_formatte_____compteur_des_kMalo); \
BSaveVariable(Positive,Ftest_fichier_____compteur_des_kMalo); \
BSaveVariable(Positive,Ftraitement_des_formats_de_sortie_____compteur_des_kMalo); \
BSaveVariable(Positive,GET_PARAMETRES_____compteur_des_ciMalo); \
BSaveVariable(Positive,GET_PARAMETRES_____compteur_des_cpMalo); \
BSaveVariable(Positive,GENERE__FonctionC_FconversionC_____compteur_des_kMalo); \
BSaveVariable(Positive,RECHERCHE_D_UNE_VALEUR_____compteur_des_kMalo); \
BSaveVariable(Positive,_chain_numero_____compteur_des_kMalo); \
BSaveVariable(Positive,allocation_memoire_avec_validation_____compteur_de_tous_les_Malo); \
BSaveVariable(Positive,chain_ANcopie_____compteur_des_kMalo); \
BSaveVariable(Positive,chain_Aconcaten2_____compteur_des_kMalo); \
BSaveVariable(Positive,chain_Acopie_____compteur_des_kMalo); \
BSaveVariable(Positive,chain_Acopie_avec_conversions_possibles_majuscules_minuscules_____compteur_des_kMalo); \
BSaveVariable(Positive,chain_Acopie_avec_gestion_des_formats_des_editions_entieres_____compteur_des_kMalo); \
BSaveVariable(Positive,chain_Aentier_____compteur_des_kMalo); \
BSaveVariable(Positive,conversion_d_un_chiffre_decimal_en_caractere_____compteur_des_kMalo); \
BSaveVariable(Positive,exec_shell_____compteur_des_kMalo); \
BSaveVariable(Positive,getv_shell_____compteur_des_kMalo); \
BSaveVariable(Positive,parametrage_des_formats_des_editions_flottantes_____compteur_des_kMalo); \
BSaveVariable(Positive,print_defaut_____compteur_des_kMalo); \
\
BSaveVariable(Positive,gCALZ_Free_____compteur_de_tous_les_gCALZ_Free); \
BSaveVariable(Positive,CALZ_FreCC_____compteur_de_tous_les_CALZ_FreCC); \
BSaveVariable(Positive,CALZ_FreDD_____compteur_de_tous_les_CALZ_FreDD); \
BSaveVariable(Positive,CALZ_FreFF_____compteur_de_tous_les_CALZ_FreFF); \
BSaveVariable(Positive,CALZ_FreII_____compteur_de_tous_les_CALZ_FreII); \
BSaveVariable(Positive,CALZ_FreLL_____compteur_de_tous_les_CALZ_FreLL); \
BSaveVariable(Positive,CALZ_FrePP_____compteur_de_tous_les_CALZ_FrePP); \
BSaveVariable(Positive,CALZ_FreSS_____compteur_de_tous_les_CALZ_FreSS); \
/* En effet, les 'Prme1(...)' qui suivent vont eux-aussi incrementer la valeur de ces */ \
/* compteurs. Il convient donc de les sauvegarder avant et d'editer donc ces valeurs */ \
/* sauvegardees... */ \
\
DEFV(Int,INIT(cumul_des_compteurs_de_toutes_les____allocations_memoire,ZERO)); \
DEFV(Int,INIT(veritable_compteur_de_tous_les_gCALZ_Free,UNDEF)); \
DEFV(Int,INIT(cumul_des_compteurs_de_toutes_les_desallocations_memoire,UNDEF)); \
DEFV(Int,INIT(valeur_initiale_du_cumul_des_compteurs_de_toutes_les_desallocations_memoire \
,SE22(ZERO \
,allocation_memoire_et_generation_des_format_EGAr_____compteur_d_allocation_memoire \
) \
) \
); \
/* Le 20180407092822, on anticipe ainsi les 'CALZ_FreCC(...)' qui auront lieu ensuite */ \
/* dans 'v $xig/allocation$vv$FON DESALLOCATION_MEMOIRE' et dont on ne connait pas encore */ \
/* le resultat du comptage. Au passage, on notera que l'on fait l'hypothese qu'il y a */ \
/* autant de desallocations que d'allocations, ce qui permet donc d'utiliser ci-dessus */ \
/* le compteur d'allocations... */ \
\
EGAL(veritable_compteur_de_tous_les_gCALZ_Free \
,ADD2(EnTete_de_sauvegardA ## gCALZ_Free_____compteur_de_tous_les_gCALZ_Free \
,valeur_initiale_du_cumul_des_compteurs_de_toutes_les_desallocations_memoire \
) \
); \
EGAL(cumul_des_compteurs_de_toutes_les_desallocations_memoire \
,valeur_initiale_du_cumul_des_compteurs_de_toutes_les_desallocations_memoire \
); \
\
PRINT_MESSAGE(C_VIDE,"EDITION DES COMPTEURS D'ALLOCATION/DESALLOCATION MEMOIRE"); \
\
CALS(Fsauts_de_lignes(UN)); \
\
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("Flist_Gelement/t",Flist_Gelement_____compteur_des_tMalo); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("Flist_Selement/k",Flist_Selement_____compteur_des_kMalo); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("Flist_creation/t",Flist_creation_____compteur_des_tMalo); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("Fload_fichier_non_formatte/k" \
,Fload_fichier_non_formatte_____compteur_des_kMalo \
); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("Fsize_fichier/k",Fsize_fichier_____compteur_des_kMalo); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("Fstore_fichier_non_formatte/k" \
,Fstore_fichier_non_formatte_____compteur_des_kMalo \
); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("Fstore_non_securise_fichier_non_formatte/k" \
,Fstore_non_securise_fichier_non_formatte_____compteur_des_kMalo \
); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("Ftest_fichier/k",Ftest_fichier_____compteur_des_kMalo); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("Ftraitement_des_formats_de_sortie/k" \
,Ftraitement_des_formats_de_sortie_____compteur_des_kMalo \
); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("GENERE__FonctionC_FconversionC/k" \
,GENERE__FonctionC_FconversionC_____compteur_des_kMalo \
); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("GET_PARAMETRES/i" \
,GET_PARAMETRES_____compteur_des_ciMalo \
); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("GET_PARAMETRES/p" \
,GET_PARAMETRES_____compteur_des_cpMalo \
); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("RECHERCHE_D_UNE_VALEUR/k" \
,RECHERCHE_D_UNE_VALEUR_____compteur_des_kMalo \
); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("_chain_numero/k",_chain_numero_____compteur_des_kMalo); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("chain_ANcopie/k",chain_ANcopie_____compteur_des_kMalo); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("chain_Aconcaten2/k",chain_Aconcaten2_____compteur_des_kMalo); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("chain_Acopie/k",chain_Acopie_____compteur_des_kMalo); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE \
("chain_Acopie_avec_conversions_possibles_majuscules_minuscules/k" \
,chain_Acopie_avec_conversions_possibles_majuscules_minuscules_____compteur_des_kMalo \
); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE \
("chain_Acopie_avec_gestion_des_formats_des_editions_entieres/k" \
,chain_Acopie_avec_gestion_des_formats_des_editions_entieres_____compteur_des_kMalo \
); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("chain_Aentier/k",chain_Aentier_____compteur_des_kMalo); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE \
("conversion_d_un_chiffre_decimal_en_caractere/k" \
,conversion_d_un_chiffre_decimal_en_caractere_____compteur_des_kMalo \
); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("exec_shell/k",exec_shell_____compteur_des_kMalo); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("getv_shell/k",getv_shell_____compteur_des_kMalo); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE \
("parametrage_des_formats_des_editions_flottantes/k" \
,parametrage_des_formats_des_editions_flottantes_____compteur_des_kMalo \
); \
EDITION_D_UN_COMPTEUR_D_ALLOCATION_MEMOIRE("print_defaut/k",print_defaut_____compteur_des_kMalo); \
\
CALS(Fsauts_de_lignes(UN)); \
\
CAL3(Prme2("Cumul des compteurs des 'Malo(...)'s (incluant donc les '?Malo(...)'s)%s%d\n" \
,SIGNE_EGAL \
,EnTete_de_sauvegardA ## allocation_memoire_avec_validation_____compteur_de_tous_les_Malo \
) \
); \
/* Edition introduite le 20180315085718... */ \
\
Test(IFNE(cumul_des_compteurs_de_toutes_les____allocations_memoire \
,EnTete_de_sauvegardA ## allocation_memoire_avec_validation_____compteur_de_tous_les_Malo \
) \
) \
/* Validation introduite le 20180315135802... */ \
Bblock \
PRINT_ERREUR("incoherence dans le comptage des allocations memoire"); \
CAL1(Prer2("(la valeur totale est %d, alors que le cumul est %d)\n" \
,EnTete_de_sauvegardA ## allocation_memoire_avec_validation_____compteur_de_tous_les_Malo \
,cumul_des_compteurs_de_toutes_les____allocations_memoire \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
CALS(Fsauts_de_lignes(UN)); \
\
EDITION_D_UN_COMPTEUR_DE_DESALLOCATION_MEMOIRE("CALZ_FreCC",CALZ_FreCC_____compteur_de_tous_les_CALZ_FreCC); \
EDITION_D_UN_COMPTEUR_DE_DESALLOCATION_MEMOIRE("CALZ_FreDD",CALZ_FreDD_____compteur_de_tous_les_CALZ_FreDD); \
EDITION_D_UN_COMPTEUR_DE_DESALLOCATION_MEMOIRE("CALZ_FreFF",CALZ_FreFF_____compteur_de_tous_les_CALZ_FreFF); \
EDITION_D_UN_COMPTEUR_DE_DESALLOCATION_MEMOIRE("CALZ_FreII",CALZ_FreII_____compteur_de_tous_les_CALZ_FreII); \
EDITION_D_UN_COMPTEUR_DE_DESALLOCATION_MEMOIRE("CALZ_FreLL",CALZ_FreLL_____compteur_de_tous_les_CALZ_FreLL); \
EDITION_D_UN_COMPTEUR_DE_DESALLOCATION_MEMOIRE("CALZ_FrePP",CALZ_FrePP_____compteur_de_tous_les_CALZ_FrePP); \
EDITION_D_UN_COMPTEUR_DE_DESALLOCATION_MEMOIRE("CALZ_FreSS",CALZ_FreSS_____compteur_de_tous_les_CALZ_FreSS); \
/* Edition des compteurs des 'Fre?(...)'s introduite le 20180315085718... */ \
\
CALS(Fsauts_de_lignes(UN)); \
\
CAL3(Prme5("Cumul anticipe des compteurs des 'gCALZ_Free(...)'s%s%d+%d%s%d\n" \
,SIGNE_EGAL \
,EnTete_de_sauvegardA ## gCALZ_Free_____compteur_de_tous_les_gCALZ_Free \
,valeur_initiale_du_cumul_des_compteurs_de_toutes_les_desallocations_memoire \
,SIGNE_EGAL \
,veritable_compteur_de_tous_les_gCALZ_Free \
) \
); \
/* ATTENTION : il s'agit du cumul ANTICIPE car, en effet, l'appel a la fonction */ \
/* 'v $xig/allocation$vv$FON desallocation_memoire_des_format_EGAr' ne peut avoir lieu */ \
/* qu'apres ce qui suit... */ \
\
CALS(Fsauts_de_lignes(UN)); \
\
Test(IFNE(veritable_compteur_de_tous_les_gCALZ_Free \
,cumul_des_compteurs_de_toutes_les_desallocations_memoire \
) \
) \
/* Validation introduite le 20180315135802... */ \
Bblock \
PRINT_ERREUR("incoherence dans le comptage des 'CALZ_Fre?(...)'."); \
CAL1(Prer2("(la valeur totale est %d, alors que le cumul est %d)\n" \
,veritable_compteur_de_tous_les_gCALZ_Free \
,cumul_des_compteurs_de_toutes_les_desallocations_memoire \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
ESaveVariable(Positive,CALZ_FreSS_____compteur_de_tous_les_CALZ_FreSS); \
ESaveVariable(Positive,CALZ_FrePP_____compteur_de_tous_les_CALZ_FrePP); \
ESaveVariable(Positive,CALZ_FreLL_____compteur_de_tous_les_CALZ_FreLL); \
ESaveVariable(Positive,CALZ_FreII_____compteur_de_tous_les_CALZ_FreII); \
ESaveVariable(Positive,CALZ_FreFF_____compteur_de_tous_les_CALZ_FreFF); \
ESaveVariable(Positive,CALZ_FreDD_____compteur_de_tous_les_CALZ_FreDD); \
ESaveVariable(Positive,CALZ_FreCC_____compteur_de_tous_les_CALZ_FreCC); \
ESaveVariable(Positive,gCALZ_Free_____compteur_de_tous_les_gCALZ_Free); \
\
ESaveVariable(Positive,print_defaut_____compteur_des_kMalo); \
ESaveVariable(Positive,parametrage_des_formats_des_editions_flottantes_____compteur_des_kMalo); \
ESaveVariable(Positive,getv_shell_____compteur_des_kMalo); \
ESaveVariable(Positive,exec_shell_____compteur_des_kMalo); \
ESaveVariable(Positive,conversion_d_un_chiffre_decimal_en_caractere_____compteur_des_kMalo); \
ESaveVariable(Positive,chain_Aentier_____compteur_des_kMalo); \
ESaveVariable(Positive,chain_Acopie_avec_gestion_des_formats_des_editions_entieres_____compteur_des_kMalo); \
ESaveVariable(Positive,chain_Acopie_avec_conversions_possibles_majuscules_minuscules_____compteur_des_kMalo); \
ESaveVariable(Positive,chain_Acopie_____compteur_des_kMalo); \
ESaveVariable(Positive,chain_Aconcaten2_____compteur_des_kMalo); \
ESaveVariable(Positive,chain_ANcopie_____compteur_des_kMalo); \
ESaveVariable(Positive,allocation_memoire_avec_validation_____compteur_de_tous_les_Malo); \
ESaveVariable(Positive,_chain_numero_____compteur_des_kMalo); \
ESaveVariable(Positive,RECHERCHE_D_UNE_VALEUR_____compteur_des_kMalo); \
ESaveVariable(Positive,GENERE__FonctionC_FconversionC_____compteur_des_kMalo); \
ESaveVariable(Positive,GET_PARAMETRES_____compteur_des_cpMalo); \
ESaveVariable(Positive,GET_PARAMETRES_____compteur_des_ciMalo); \
ESaveVariable(Positive,Ftraitement_des_formats_de_sortie_____compteur_des_kMalo); \
ESaveVariable(Positive,Ftest_fichier_____compteur_des_kMalo); \
ESaveVariable(Positive,Fstore_non_securise_fichier_non_formatte_____compteur_des_kMalo); \
ESaveVariable(Positive,Fstore_fichier_non_formatte_____compteur_des_kMalo); \
ESaveVariable(Positive,Fsize_fichier_____compteur_des_kMalo); \
ESaveVariable(Positive,Fload_fichier_non_formatte_____compteur_des_kMalo); \
ESaveVariable(Positive,Flist_creation_____compteur_des_tMalo); \
ESaveVariable(Positive,Flist_Selement_____compteur_des_kMalo); \
ESaveVariable(Positive,Flist_Gelement_____compteur_des_tMalo); \
/* Par symetrie... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit le 20180314112759... */
#ifdef GENERER_LES_GET_ARGUMENTS_DE_CONTROLE_DE_L_ARITHMETIQUE_ETENDUE_DES_NOMBRES_FLOTTANTS
# define si_le_GooF_est_activable_utiliser_l_arithmetique_etendue \
si_le_GooF_est_activable_utiliser_l_arithmetique_etendue_au_lieu_de_l_arithmetique_de_base \
/* Introduit le 20180818113515 pour raccourcir deux lignes qui suivent... */
# define GET_ARGUMENTS_DE_CONTROLE_DE_L_ARITHMETIQUE_ETENDUE_DES_NOMBRES_FLOTTANTS \
Bblock \
\
DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
GET_ARGUMENTS_DE_BASCULE_ENTRE_L_ARITHMETIQUE_DE_BASE_ET_L_ARITHMETIQUE_ETENDUE; \
/* Introduit le 20061018132259 sous cette forme... */ \
\
PROCESS_ARGUMENT_L("MIN2_ADD2__ADD2_MUL2=""MIN2_ADD2=""min_plus=" \
,remplacer_l_arithmetique__ADD2_MUL2__par_l_arithmetique__MIN2_ADD2 \
,BLOC(VIDE;) \
,BLOC(Bblock \
EGAL(FfxADD2_____ponderation_de_ADD2,FZERO); \
EGAL(FfxADD2_____ponderation_de_MIN2,FU); \
\
EGAL(FfxMUL2_____ponderation_de_MUL2,FZERO); \
EGAL(FfxMUL2_____ponderation_de_ADD2,FU); \
\
EGAL(si_le_GooF_est_activable_utiliser_l_arithmetique_etendue,VRAI); \
Eblock \
) \
); \
/* Introduit le 20180818111546 et complete le 20181109100545 par "min_plus="... */ \
/* */ \
/* Le 20181109143219, "ADD2_MUL2__MIN2_ADD2=" a ete remplace par "MIN2_ADD2__ADD2_MUL2=" */ \
/* plus logique... */ \
\
PROCESS_ARGUMENT_L("MAX2_ADD2__ADD2_MUL2=""MAX2_ADD2=""max_plus=""tropical=" \
,remplacer_l_arithmetique__ADD2_MUL2__par_l_arithmetique__MAX2_ADD2 \
,BLOC(VIDE;) \
,BLOC(Bblock \
EGAL(FfxADD2_____ponderation_de_ADD2,FZERO); \
EGAL(FfxADD2_____ponderation_de_MAX2,FU); \
\
EGAL(FfxMUL2_____ponderation_de_MUL2,FZERO); \
EGAL(FfxMUL2_____ponderation_de_ADD2,FU); \
\
EGAL(si_le_GooF_est_activable_utiliser_l_arithmetique_etendue,VRAI); \
Eblock \
) \
); \
/* Introduit le 20180818111546 et complete le 20181109100545 par "max_plus=""tropical="... */ \
/* */ \
/* Le 20181109143219, "ADD2_MUL2__MAX2_ADD2=" a ete remplace par "MAX2_ADD2__ADD2_MUL2=" */ \
/* plus logique... */ \
\
GET_ARGUMENT_L("xFloat=",utiliser_evidemment_la_precision_Float_avec_l_arithmetique_etendue); \
/* Introduit le 20090331084223... */ \
\
GET_ARGUMENT_L("mFloat=""calculs_modulo=""congruence=" \
,faire_des_calculs_entiers_brutaux_modulo_avec_l_arithmetique_etendue \
); \
PROCESS_ARGUMENT_I("rFloat=""raison_modulo=""raison_congruence=" \
,raison_des_calculs_entiers_brutaux_modulo_avec_l_arithmetique_etendue \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
Test(IZEQ(raison_des_calculs_entiers_brutaux_modulo_avec_l_arithmetique_etendue)) \
Bblock \
PRINT_ERREUR("la raison d'une congruence ne peut etre nulle"); \
EGAL(raison_des_calculs_entiers_brutaux_modulo_avec_l_arithmetique_etendue \
,RAISON_DES_CALCULS_ENTIERS_BRUTAUX_MODULO_AVEC_L_ARITHMETIQUE_ETENDUE \
); \
CAL1(Prer1("(la valeur par defaut (%d) est forcee)\n" \
,raison_des_calculs_entiers_brutaux_modulo_avec_l_arithmetique_etendue \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
) \
); \
/* Introduit le 20111003104139, la validation ayant ete introduite le 20111003113313... */ \
\
GET_ARGUMENT_L("xFloat_ADD2=",FfxADD2_____utiliser_evidemment_la_precision_Float); \
GET_ARGUMENT_F("pxADD2_ADD2=",FfxADD2_____ponderation_de_ADD2); \
GET_ARGUMENT_F("pxSOUS_ADD2=",FfxADD2_____ponderation_de_SOUS); \
GET_ARGUMENT_F("pxSOUSnc_ADD2=",FfxADD2_____ponderation_de_SOUSnc); \
GET_ARGUMENT_F("pxMUL2_ADD2=",FfxADD2_____ponderation_de_MUL2); \
GET_ARGUMENT_F("pxDIVZ_ADD2=",FfxADD2_____ponderation_de_DIVZ); \
GET_ARGUMENT_F("pxDIVZnc_ADD2=",FfxADD2_____ponderation_de_DIVZnc); \
GET_ARGUMENT_F("pxMIN2_ADD2=",FfxADD2_____ponderation_de_MIN2); \
GET_ARGUMENT_F("pxMAX2_ADD2=",FfxADD2_____ponderation_de_MAX2); \
GET_ARGUMENT_F("pxMINMAX_ADD2=",FfxADD2_____ponderation_de_MINMAX); \
GET_ARGUMENT_F("pxMAXMIN_ADD2=",FfxADD2_____ponderation_de_MAXMIN); \
GET_ARGUMENT_F("pxIMINMAX_ADD2=",FfxADD2_____ponderation_de_IMINMAX); \
GET_ARGUMENT_F("pxIMAXMIN_ADD2=",FfxADD2_____ponderation_de_IMAXMIN); \
GET_ARGUMENT_F("pxMOYE_ADD2=",FfxADD2_____ponderation_de_MOYE); \
GET_ARGUMENT_F("pxMOYZ_ADD2=",FfxADD2_____ponderation_de_MOYZ); \
GET_ARGUMENT_F("pxMOYZSI_ADD2=",FfxADD2_____ponderation_de_MOYZSI); \
GET_ARGUMENT_F("pxMOYQ_ADD2=",FfxADD2_____ponderation_de_MOYQ); \
GET_ARGUMENT_F("pxMOYQSI_ADD2=",FfxADD2_____ponderation_de_MOYQSI); \
GET_ARGUMENT_F("pxMOYH_ADD2=",FfxADD2_____ponderation_de_MOYH); \
GET_ARGUMENT_F("pxSPUIX_ADD2=",FfxADD2_____ponderation_de_SPUIX); \
GET_ARGUMENT_F("pxSPUIXnc_ADD2=",FfxADD2_____ponderation_de_SPUIXnc); \
GET_ARGUMENT_F("pxSE12_ADD2=",FfxADD2_____ponderation_de_SE12); \
GET_ARGUMENT_F("pxSE22_ADD2=",FfxADD2_____ponderation_de_SE22); \
GET_ARGUMENT_F("pxATAN_ADD2=",FfxADD2_____ponderation_de_ATAN); \
GET_ARGUMENT_F("pxATANnc_ADD2=",FfxADD2_____ponderation_de_ATANnc); \
GET_ARGUMENT_F("pxMULH24_ADD2=",FfxADD2_____ponderation_de_MULH24); \
\
GET_ARGUMENT_L("xFloat_SOUS=",FfxSOUS_____utiliser_evidemment_la_precision_Float); \
GET_ARGUMENT_F("pxADD2_SOUS=",FfxSOUS_____ponderation_de_ADD2); \
GET_ARGUMENT_F("pxSOUS_SOUS=",FfxSOUS_____ponderation_de_SOUS); \
GET_ARGUMENT_F("pxSOUSnc_SOUS=",FfxSOUS_____ponderation_de_SOUSnc); \
GET_ARGUMENT_F("pxMUL2_SOUS=",FfxSOUS_____ponderation_de_MUL2); \
GET_ARGUMENT_F("pxDIVZ_SOUS=",FfxSOUS_____ponderation_de_DIVZ); \
GET_ARGUMENT_F("pxDIVZnc_SOUS=",FfxSOUS_____ponderation_de_DIVZnc); \
GET_ARGUMENT_F("pxMIN2_SOUS=",FfxSOUS_____ponderation_de_MIN2); \
GET_ARGUMENT_F("pxMAX2_SOUS=",FfxSOUS_____ponderation_de_MAX2); \
GET_ARGUMENT_F("pxMINMAX_SOUS=",FfxSOUS_____ponderation_de_MINMAX); \
GET_ARGUMENT_F("pxMAXMIN_SOUS=",FfxSOUS_____ponderation_de_MAXMIN); \
GET_ARGUMENT_F("pxIMINMAX_SOUS=",FfxSOUS_____ponderation_de_IMINMAX); \
GET_ARGUMENT_F("pxIMAXMIN_SOUS=",FfxSOUS_____ponderation_de_IMAXMIN); \
GET_ARGUMENT_F("pxMOYE_SOUS=",FfxSOUS_____ponderation_de_MOYE); \
GET_ARGUMENT_F("pxMOYZ_SOUS=",FfxSOUS_____ponderation_de_MOYZ); \
GET_ARGUMENT_F("pxMOYZSI_SOUS=",FfxSOUS_____ponderation_de_MOYZSI); \
GET_ARGUMENT_F("pxMOYQ_SOUS=",FfxSOUS_____ponderation_de_MOYQ); \
GET_ARGUMENT_F("pxMOYQSI_SOUS=",FfxSOUS_____ponderation_de_MOYQSI); \
GET_ARGUMENT_F("pxMOYH_SOUS=",FfxSOUS_____ponderation_de_MOYH); \
GET_ARGUMENT_F("pxSPUIX_SOUS=",FfxSOUS_____ponderation_de_SPUIX); \
GET_ARGUMENT_F("pxSPUIXnc_SOUS=",FfxSOUS_____ponderation_de_SPUIXnc); \
GET_ARGUMENT_F("pxSE12_SOUS=",FfxSOUS_____ponderation_de_SE12); \
GET_ARGUMENT_F("pxSE22_SOUS=",FfxSOUS_____ponderation_de_SE22); \
GET_ARGUMENT_F("pxATAN_AOUS=",FfxSOUS_____ponderation_de_ATAN); \
GET_ARGUMENT_F("pxATANnc_AOUS=",FfxSOUS_____ponderation_de_ATANnc); \
GET_ARGUMENT_F("pxMULH24_AOUS=",FfxSOUS_____ponderation_de_MULH24); \
\
GET_ARGUMENT_L("ADD2_SOUS=",FfxxSOUS_____utiliser_FfxADD2_a_la_place_de_FfxSOUS); \
GET_ARGUMENT_N("SOUS_SOUS=",FfxxSOUS_____utiliser_FfxADD2_a_la_place_de_FfxSOUS); \
/* Introduits le 20061030155146... */ \
\
GET_ARGUMENT_L("xFloat_MUL2=",FfxMUL2_____utiliser_evidemment_la_precision_Float); \
GET_ARGUMENT_F("pxADD2_MUL2=",FfxMUL2_____ponderation_de_ADD2); \
GET_ARGUMENT_F("pxSOUS_MUL2=",FfxMUL2_____ponderation_de_SOUS); \
GET_ARGUMENT_F("pxSOUSnc_MUL2=",FfxMUL2_____ponderation_de_SOUSnc); \
GET_ARGUMENT_F("pxMUL2_MUL2=",FfxMUL2_____ponderation_de_MUL2); \
GET_ARGUMENT_F("pxDIVZ_MUL2=",FfxMUL2_____ponderation_de_DIVZ); \
GET_ARGUMENT_F("pxDIVZnc_MUL2=",FfxMUL2_____ponderation_de_DIVZnc); \
GET_ARGUMENT_F("pxMIN2_MUL2=",FfxMUL2_____ponderation_de_MIN2); \
GET_ARGUMENT_F("pxMAX2_MUL2=",FfxMUL2_____ponderation_de_MAX2); \
GET_ARGUMENT_F("pxMINMAX_MUL2=",FfxMUL2_____ponderation_de_MINMAX); \
GET_ARGUMENT_F("pxMAXMIN_MUL2=",FfxMUL2_____ponderation_de_MAXMIN); \
GET_ARGUMENT_F("pxIMINMAX_MUL2=",FfxMUL2_____ponderation_de_IMINMAX); \
GET_ARGUMENT_F("pxIMAXMIN_MUL2=",FfxMUL2_____ponderation_de_IMAXMIN); \
GET_ARGUMENT_F("pxMOYE_MUL2=",FfxMUL2_____ponderation_de_MOYE); \
GET_ARGUMENT_F("pxMOYZ_MUL2=",FfxMUL2_____ponderation_de_MOYZ); \
GET_ARGUMENT_F("pxMOYZSI_MUL2=",FfxMUL2_____ponderation_de_MOYZSI); \
GET_ARGUMENT_F("pxMOYQ_MUL2=",FfxMUL2_____ponderation_de_MOYQ); \
GET_ARGUMENT_F("pxMOYQSI_MUL2=",FfxMUL2_____ponderation_de_MOYQSI); \
GET_ARGUMENT_F("pxMOYH_MUL2=",FfxMUL2_____ponderation_de_MOYH); \
GET_ARGUMENT_F("pxSPUIX_MUL2=",FfxMUL2_____ponderation_de_SPUIX); \
GET_ARGUMENT_F("pxSPUIXnc_MUL2=",FfxMUL2_____ponderation_de_SPUIXnc); \
GET_ARGUMENT_F("pxSE12_MUL2=",FfxMUL2_____ponderation_de_SE12); \
GET_ARGUMENT_F("pxSE22_MUL2=",FfxMUL2_____ponderation_de_SE22); \
GET_ARGUMENT_F("pxATAN_MUL2=",FfxMUL2_____ponderation_de_ATAN); \
GET_ARGUMENT_F("pxATANnc_MUL2=",FfxMUL2_____ponderation_de_ATANnc); \
GET_ARGUMENT_F("pxMULH24_MUL2=",FfxMUL2_____ponderation_de_MULH24); \
\
GET_ARGUMENT_L("xFloat_DIVZ=",FfxDIVZ_____utiliser_evidemment_la_precision_Float); \
GET_ARGUMENT_F("pxADD2_DIVZ=",FfxDIVZ_____ponderation_de_ADD2); \
GET_ARGUMENT_F("pxSOUS_DIVZ=",FfxDIVZ_____ponderation_de_SOUS); \
GET_ARGUMENT_F("pxSOUSnc_DIVZ=",FfxDIVZ_____ponderation_de_SOUSnc); \
GET_ARGUMENT_F("pxMUL2_DIVZ=",FfxDIVZ_____ponderation_de_MUL2); \
GET_ARGUMENT_F("pxDIVZ_DIVZ=",FfxDIVZ_____ponderation_de_DIVZ); \
GET_ARGUMENT_F("pxDIVZnc_DIVZ=",FfxDIVZ_____ponderation_de_DIVZnc); \
GET_ARGUMENT_F("pxMIN2_DIVZ=",FfxDIVZ_____ponderation_de_MIN2); \
GET_ARGUMENT_F("pxMAX2_DIVZ=",FfxDIVZ_____ponderation_de_MAX2); \
GET_ARGUMENT_F("pxMINMAX_DIVZ=",FfxDIVZ_____ponderation_de_MINMAX); \
GET_ARGUMENT_F("pxMAXMIN_DIVZ=",FfxDIVZ_____ponderation_de_MAXMIN); \
GET_ARGUMENT_F("pxIMINMAX_DIVZ=",FfxDIVZ_____ponderation_de_IMINMAX); \
GET_ARGUMENT_F("pxIMAXMIN_DIVZ=",FfxDIVZ_____ponderation_de_IMAXMIN); \
GET_ARGUMENT_F("pxMOYE_DIVZ=",FfxDIVZ_____ponderation_de_MOYE); \
GET_ARGUMENT_F("pxMOYZ_DIVZ=",FfxDIVZ_____ponderation_de_MOYZ); \
GET_ARGUMENT_F("pxMOYZSI_DIVZ=",FfxDIVZ_____ponderation_de_MOYZSI); \
GET_ARGUMENT_F("pxMOYQ_DIVZ=",FfxDIVZ_____ponderation_de_MOYQ); \
GET_ARGUMENT_F("pxMOYQSI_DIVZ=",FfxDIVZ_____ponderation_de_MOYQSI); \
GET_ARGUMENT_F("pxMOYH_DIVZ=",FfxDIVZ_____ponderation_de_MOYH); \
GET_ARGUMENT_F("pxSPUIX_DIVZ=",FfxDIVZ_____ponderation_de_SPUIX); \
GET_ARGUMENT_F("pxSPUIXnc_DIVZ=",FfxDIVZ_____ponderation_de_SPUIXnc); \
GET_ARGUMENT_F("pxSE12_DIVZ=",FfxDIVZ_____ponderation_de_SE12); \
GET_ARGUMENT_F("pxSE22_DIVZ=",FfxDIVZ_____ponderation_de_SE22); \
GET_ARGUMENT_F("pxATAN_DIVZ=",FfxDIVZ_____ponderation_de_ATAN); \
GET_ARGUMENT_F("pxATANnc_DIVZ=",FfxDIVZ_____ponderation_de_ATANnc); \
GET_ARGUMENT_F("pxMULH24_DIVZ=",FfxDIVZ_____ponderation_de_MULH24); \
\
GET_ARGUMENT_L("MUL2_DIVZ=",FfxxDIVZ_____utiliser_FfxMUL2_a_la_place_de_FfxDIVZ); \
GET_ARGUMENT_N("DIVZ_DIVZ=",FfxxDIVZ_____utiliser_FfxMUL2_a_la_place_de_FfxDIVZ); \
/* Introduits le 20061030155146... */ \
\
GET_ARGUMENT_L("xFloat_MIN2=",FfxMIN2_____utiliser_evidemment_la_precision_Float); \
GET_ARGUMENT_F("pxADD2_MIN2=",FfxMIN2_____ponderation_de_ADD2); \
GET_ARGUMENT_F("pxSOUS_MIN2=",FfxMIN2_____ponderation_de_SOUS); \
GET_ARGUMENT_F("pxSOUSnc_MIN2=",FfxMIN2_____ponderation_de_SOUSnc); \
GET_ARGUMENT_F("pxMUL2_MIN2=",FfxMIN2_____ponderation_de_MUL2); \
GET_ARGUMENT_F("pxDIVZ_MIN2=",FfxMIN2_____ponderation_de_DIVZ); \
GET_ARGUMENT_F("pxDIVZnc_MIN2=",FfxMIN2_____ponderation_de_DIVZnc); \
GET_ARGUMENT_F("pxMIN2_MIN2=",FfxMIN2_____ponderation_de_MIN2); \
GET_ARGUMENT_F("pxMAX2_MIN2=",FfxMIN2_____ponderation_de_MAX2); \
GET_ARGUMENT_F("pxMINMAX_MIN2=",FfxMIN2_____ponderation_de_MINMAX); \
GET_ARGUMENT_F("pxMAXMIN_MIN2=",FfxMIN2_____ponderation_de_MAXMIN); \
GET_ARGUMENT_F("pxIMINMAX_MIN2=",FfxMIN2_____ponderation_de_IMINMAX); \
GET_ARGUMENT_F("pxIMAXMIN_MIN2=",FfxMIN2_____ponderation_de_IMAXMIN); \
GET_ARGUMENT_F("pxMOYE_MIN2=",FfxMIN2_____ponderation_de_MOYE); \
GET_ARGUMENT_F("pxMOYZ_MIN2=",FfxMIN2_____ponderation_de_MOYZ); \
GET_ARGUMENT_F("pxMOYZSI_MIN2=",FfxMIN2_____ponderation_de_MOYZSI); \
GET_ARGUMENT_F("pxMOYQ_MIN2=",FfxMIN2_____ponderation_de_MOYQ); \
GET_ARGUMENT_F("pxMOYQSI_MIN2=",FfxMIN2_____ponderation_de_MOYQSI); \
GET_ARGUMENT_F("pxMOYH_MIN2=",FfxMIN2_____ponderation_de_MOYH); \
GET_ARGUMENT_F("pxSPUIX_MIN2=",FfxMIN2_____ponderation_de_SPUIX); \
GET_ARGUMENT_F("pxSPUIXnc_MIN2=",FfxMIN2_____ponderation_de_SPUIXnc); \
GET_ARGUMENT_F("pxSE12_MIN2=",FfxMIN2_____ponderation_de_SE12); \
GET_ARGUMENT_F("pxSE22_MIN2=",FfxMIN2_____ponderation_de_SE22); \
GET_ARGUMENT_F("pxATAN_MIN2=",FfxMIN2_____ponderation_de_ATAN); \
GET_ARGUMENT_F("pxATANnc_MIN2=",FfxMIN2_____ponderation_de_ATANnc); \
GET_ARGUMENT_F("pxMULH24_MIN2=",FfxMIN2_____ponderation_de_MULH24); \
\
GET_ARGUMENT_L("xFloat_MAX2=",FfxMAX2_____utiliser_evidemment_la_precision_Float); \
GET_ARGUMENT_F("pxADD2_MAX2=",FfxMAX2_____ponderation_de_ADD2); \
GET_ARGUMENT_F("pxSOUS_MAX2=",FfxMAX2_____ponderation_de_SOUS); \
GET_ARGUMENT_F("pxSOUSnc_MAX2=",FfxMAX2_____ponderation_de_SOUSnc); \
GET_ARGUMENT_F("pxMUL2_MAX2=",FfxMAX2_____ponderation_de_MUL2); \
GET_ARGUMENT_F("pxDIVZ_MAX2=",FfxMAX2_____ponderation_de_DIVZ); \
GET_ARGUMENT_F("pxDIVZnc_MAX2=",FfxMAX2_____ponderation_de_DIVZnc); \
GET_ARGUMENT_F("pxMIN2_MAX2=",FfxMAX2_____ponderation_de_MIN2); \
GET_ARGUMENT_F("pxMAX2_MAX2=",FfxMAX2_____ponderation_de_MAX2); \
GET_ARGUMENT_F("pxMINMAX_MAX2=",FfxMAX2_____ponderation_de_MINMAX); \
GET_ARGUMENT_F("pxMAXMIN_MAX2=",FfxMAX2_____ponderation_de_MAXMIN); \
GET_ARGUMENT_F("pxIMINMAX_MAX2=",FfxMAX2_____ponderation_de_IMINMAX); \
GET_ARGUMENT_F("pxIMAXMIN_MAX2=",FfxMAX2_____ponderation_de_IMAXMIN); \
GET_ARGUMENT_F("pxMOYE_MAX2=",FfxMAX2_____ponderation_de_MOYE); \
GET_ARGUMENT_F("pxMOYZ_MAX2=",FfxMAX2_____ponderation_de_MOYZ); \
GET_ARGUMENT_F("pxMOYZSI_MAX2=",FfxMAX2_____ponderation_de_MOYZSI); \
GET_ARGUMENT_F("pxMOYQ_MAX2=",FfxMAX2_____ponderation_de_MOYQ); \
GET_ARGUMENT_F("pxMOYQSI_MAX2=",FfxMAX2_____ponderation_de_MOYQSI); \
GET_ARGUMENT_F("pxMOYH_MAX2=",FfxMAX2_____ponderation_de_MOYH); \
GET_ARGUMENT_F("pxSPUIX_MAX2=",FfxMAX2_____ponderation_de_SPUIX); \
GET_ARGUMENT_F("pxSPUIXnc_MAX2=",FfxMAX2_____ponderation_de_SPUIXnc); \
GET_ARGUMENT_F("pxSE12_MAX2=",FfxMAX2_____ponderation_de_SE12); \
GET_ARGUMENT_F("pxSE22_MAX2=",FfxMAX2_____ponderation_de_SE22); \
GET_ARGUMENT_F("pxATAN_MAX2=",FfxMAX2_____ponderation_de_ATAN); \
GET_ARGUMENT_F("pxATANnc_MAX2=",FfxMAX2_____ponderation_de_ATANnc); \
GET_ARGUMENT_F("pxMULH24_MAX2=",FfxMAX2_____ponderation_de_MULH24); \
\
GET_ARGUMENT_F("HORNER_2_04_44=""H2_04_44=",FfHORNER_2_04_____coefficient_44); \
GET_ARGUMENT_F("HORNER_2_04_43=""H2_04_43=",FfHORNER_2_04_____coefficient_43); \
GET_ARGUMENT_F("HORNER_2_04_42=""H2_04_42=",FfHORNER_2_04_____coefficient_42); \
GET_ARGUMENT_F("HORNER_2_04_41=""H2_04_41=",FfHORNER_2_04_____coefficient_41); \
GET_ARGUMENT_F("HORNER_2_04_40=""H2_04_40=",FfHORNER_2_04_____coefficient_40); \
GET_ARGUMENT_F("HORNER_2_04_34=""H2_04_34=",FfHORNER_2_04_____coefficient_34); \
GET_ARGUMENT_F("HORNER_2_04_33=""H2_04_33=",FfHORNER_2_04_____coefficient_33); \
GET_ARGUMENT_F("HORNER_2_04_32=""H2_04_32=",FfHORNER_2_04_____coefficient_32); \
GET_ARGUMENT_F("HORNER_2_04_31=""H2_04_31=",FfHORNER_2_04_____coefficient_31); \
GET_ARGUMENT_F("HORNER_2_04_30=""H2_04_30=",FfHORNER_2_04_____coefficient_30); \
GET_ARGUMENT_F("HORNER_2_04_24=""H2_04_24=",FfHORNER_2_04_____coefficient_24); \
GET_ARGUMENT_F("HORNER_2_04_23=""H2_04_23=",FfHORNER_2_04_____coefficient_23); \
GET_ARGUMENT_F("HORNER_2_04_22=""H2_04_22=",FfHORNER_2_04_____coefficient_22); \
GET_ARGUMENT_F("HORNER_2_04_21=""H2_04_21=",FfHORNER_2_04_____coefficient_21); \
GET_ARGUMENT_F("HORNER_2_04_20=""H2_04_20=",FfHORNER_2_04_____coefficient_20); \
GET_ARGUMENT_F("HORNER_2_04_14=""H2_04_14=",FfHORNER_2_04_____coefficient_14); \
GET_ARGUMENT_F("HORNER_2_04_13=""H2_04_13=",FfHORNER_2_04_____coefficient_13); \
GET_ARGUMENT_F("HORNER_2_04_12=""H2_04_12=",FfHORNER_2_04_____coefficient_12); \
GET_ARGUMENT_F("HORNER_2_04_11=""H2_04_11=",FfHORNER_2_04_____coefficient_11); \
GET_ARGUMENT_F("HORNER_2_04_10=""H2_04_10=",FfHORNER_2_04_____coefficient_10); \
GET_ARGUMENT_F("HORNER_2_04_04=""H2_04_04=",FfHORNER_2_04_____coefficient_04); \
GET_ARGUMENT_F("HORNER_2_04_03=""H2_04_03=",FfHORNER_2_04_____coefficient_03); \
GET_ARGUMENT_F("HORNER_2_04_02=""H2_04_02=",FfHORNER_2_04_____coefficient_02); \
GET_ARGUMENT_F("HORNER_2_04_01=""H2_04_01=",FfHORNER_2_04_____coefficient_01); \
GET_ARGUMENT_F("HORNER_2_04_00=""H2_04_00=",FfHORNER_2_04_____coefficient_00); \
/* Les arguments de 'HORNER_2_04(...)' ont ete introduits le 20181126113624... */ \
/* */ \
/* Pour ce qui est de leur signification, voir 'v $xig/fonct$vv$FON HORNER_2_04.x,y,.....='. */ \
\
FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
Eblock \
/* Recuperation des arguments relatifs a l'arithmetique "etendue" des nombres flottants. */ \
/* Ceci a ete introduit le 20050303120845... */ \
/* */ \
/* Le 20061023104050 furent introduites les ponderations du type '_*ponderation_de_MINMAX' */ \
/* et '_*ponderation_de_MAXMIN'... */ \
/* */ \
/* Le 20061025132344 furent introduites les ponderations du type '_*ponderation_de_MOYZSI' */ \
/* et '_*ponderation_de_MOYQSI'... */ \
/* */ \
/* Le 20080102133640 furent introduites les ponderations du type '*_ponderation_de_IMINMAX' */ \
/* et '*_ponderation_de_IMAXMIN'... */ \
/* */ \
/* Le 20090330123200 les indicateurs '*_utiliser_evidemment_la_precision_Float' furent */ \
/* introduits... */ \
/* */ \
/* Le 20180821095031 furent introduites les ponderations du type '*_ponderation_de_SE12' */ \
/* et '*_ponderation_de_SE22'... */ \
/* */ \
/* Le 20180823095353 furent introduites les ponderations du type '_*ponderation_de_MOYH'... */ \
/* */ \
/* Le 20181009170824 furent introduites les ponderations du type '_*ponderation_de_ATAN'... */
# define EDITION_DE_LA_VALEUR_DES_COMPTEURS_DE_REFERENCE_LORS_DU__RETU_Commande \
Bblock \
EDITION_DE_LA_VALEUR_DE_LA_PLUPART_DES_COMPTEURS; \
/* Editions introduites sous cette forme le 20180410205856... */ \
\
Test(IL_FAUT(editer_la_valeur_des_compteurs_de_reference_lors_du__RETU_Commande)) \
Bblock \
PRINT_MESSAGE(C_VIDE,"EDITION DES COMPTEURS D'INSTRUCTION"); \
/* Edition introduite le 20170518184508... */ \
\
CALS(Fsauts_de_lignes(UN)); \
\
CAL3(Prme2("Compteur de reference 'FfxADD2(...)'%s%d\n",SIGNE_EGAL,FfxADD2_____compteur_de_reference)); \
CAL3(Prme2("Compteur de reference 'FfxSOUS(...)'%s%d\n",SIGNE_EGAL,FfxSOUS_____compteur_de_reference)); \
CAL3(Prme2("Compteur de reference 'FfxMUL2(...)'%s%d\n",SIGNE_EGAL,FfxMUL2_____compteur_de_reference)); \
CAL3(Prme2("Compteur de reference 'FfxDIVZ(...)'%s%d\n",SIGNE_EGAL,FfxDIVZ_____compteur_de_reference)); \
CAL3(Prme2("Compteur de reference 'FfxMIN2(...)'%s%d\n",SIGNE_EGAL,FfxMIN2_____compteur_de_reference)); \
CAL3(Prme2("Compteur de reference 'FfxMAX2(...)'%s%d\n",SIGNE_EGAL,FfxMAX2_____compteur_de_reference)); \
\
CALS(Fsauts_de_lignes(UN)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Introduit le 20130518210504... */
#Aifdef GENERER_LES_GET_ARGUMENTS_DE_CONTROLE_DE_L_ARITHMETIQUE_ETENDUE_DES_NOMBRES_FLOTTANTS
# define GET_ARGUMENTS_DE_CONTROLE_DE_L_ARITHMETIQUE_ETENDUE_DES_NOMBRES_FLOTTANTS \
Bblock \
\
DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
BLOC(VIDE;); \
\
FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
Eblock
# define EDITION_DE_LA_VALEUR_DES_COMPTEURS_DE_REFERENCE_LORS_DU__RETU_Commande \
Bblock \
EDITION_DE_LA_VALEUR_DE_LA_PLUPART_DES_COMPTEURS; \
/* Editions introduites sous cette forme le 20180410205856... */ \
Eblock \
/* Introduit le 20130518210504... */
#Eifdef GENERER_LES_GET_ARGUMENTS_DE_CONTROLE_DE_L_ARITHMETIQUE_ETENDUE_DES_NOMBRES_FLOTTANTS
#define INTRODUCTION_D_UNE_VALEUR_INTERACTIVE \
K_INTERROGATION \
/* Pour demander la definition interactive d'une valeur (introduit le 20051111123040). */
#define AVERTIR_EN_CAS_D_INCOMPATIBILITE_D_EDITION_DES_SYNONYMES \
Bblock \
Test(IFET(IL_NE_FAUT_PAS(editer_les_synonymes_des_parametres_d_une_commande) \
,IL_FAUT(grouper_les_synonymes_des_parametres_d_une_commande) \
) \
) \
Bblock \
PRINT_ATTENTION("les options 'ParametresSynonymes=' et 'ParametresSynonymesGrouper=' sont mal utilises"); \
CAL1(Prer0("(le fonctionnement suivant sera equivalent a : ")); \
CAL1(Prer2("'ParametresSynonymes=%s' et 'ParametresSynonymesGrouper=%s')\n" \
,C_FAUX____ \
,C_FAUX____ \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Avertissement en cas d'incompatibilites reconnues dans l'edition des synonymes. Cela a */ \
/* ete introduit le 20070330185257... */
#define AVERTIR_EN_CAS_D_INCOMPATIBILITE_DE_MISE_EN_PAGE_DES_PARAMETRES \
Bblock \
Test(IFET(IL_FAUT(sauter_une_ligne_pour_chaque_nouveau_Parametre) \
,IL_FAUT(alterner_les_parametres_pour_plus_de_lisibilite) \
) \
) \
Bblock \
PRINT_ATTENTION("les options 'SautParametres=' et 'AlternerParametres=' ne peuvent etre VRAI simultanement"); \
CAL1(Prer2("(le fonctionnement suivant sera equivalent a : 'SautParametres=%s' et 'AlternerParametres=%s')\n" \
,C_FAUX____ \
,C_VRAI____ \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Avertissement en cas d'incompatibilites reconnues dans la mise en page d'edition des */ \
/* parametres. Cela a ete introduit le 20060622135953... */
#define AVERTIR_EN_CAS_D_ENTREE_INTERACTIVE_D_UN_PARAMETRE \
Bblock \
Test(IL_FAUT(tenter_une_entree_interactive_des_parametres)) \
Bblock \
Test(EST_VRAI(STANDARD_IN_EST_UN_PIPE)) \
Bblock \
PRINT_ATTENTION("l'entree interactive des Parametres est impossible si 'STANDARD_IN' est un 'pipe'"); \
EGAL(tenter_une_entree_interactive_des_parametres,FAUX); \
/* L'entree interactive est alors desactivee immediatement (introduit le 20051117101210)... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFET(IL_FAUT(tenter_une_entree_interactive_des_parametres) \
,IFEQ(PREMIER_CARACTERE_ITb0(introduction_d_une_valeur_interactive) \
,INTRODUCTION_D_UNE_VALEUR_INTERACTIVE \
) \
) \
) \
Bblock \
PRINT_ATTENTION("un 'set noglob' prealable est necessaire dans le contexte courant (et dans cet ordre)"); \
CAL1(Prer2("ParametresInteractifsIntroduction='%c' ParametresInteractifsActivation=%s\n" \
,PREMIER_CARACTERE_ITb0(introduction_d_une_valeur_interactive) \
,ETAT_LOGIQUE(tenter_une_entree_interactive_des_parametres) \
) \
); \
CAL1(Prer2("[PII='%c' PIA=%s]\n" \
,PREMIER_CARACTERE_ITb0(introduction_d_une_valeur_interactive) \
,ETAT_LOGIQUE(tenter_une_entree_interactive_des_parametres) \
) \
); \
CAL1(Prer0("\n")); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Avertissement en cas d'entree interactive des parametres. Ceci fut introduit le */ \
/* 20051112205650... */
#define AVERTIR_EN_CAS_D_ENTREE_VIA_UN_setenv_D_UN_PARAMETRE \
Bblock \
Test(EST_VRAI(entrer_des_parametres_via_des_setenv)) \
Bblock \
Test(IFGT(numero_d_argument_courant,NUMERO_PREMIER_ARGUMENT)) \
Bblock \
PRINT_ATTENTION("le parametre 'Environnement=' (ou 'setenv=') doit etre le premier pour etre effectif"); \
\
EGAL(entrer_des_parametres_via_des_setenv,FAUX); \
/* Ce parametre est alors desactive (meme si cela ne sert plus a rien et ce a cause de */ \
/* la definition de 'v $xig/fonct$vv$DEF gPROCESS_PARAMETRE_ENTREE_PAR_setenv'...). */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Avertissement en cas d'entree des parametres via des 'setenv's. Ceci fut introduit le */ \
/* 20060315151257 a cause de 'v $xig/fonct$vv$DEF gPROCESS_PARAMETRE_ENTREE_PAR_setenv' */ \
/* ou l'on voit que l'entree via des 'setenv' ne se fait que lors du premier balayage de */ \
/* liste complete des arguments du '$K' courant, c'est-a-dire lorsque l'on tente de */ \
/* recuperer le premier parametre. Dans ce cas, celui-ci doit imperativement etre donc */ \
/* 'entrer_des_parametres_via_des_setenv' (entre via "Environnement=" ou "setenv=")... */
#define MISE_A_JOUR_des_format_EGAr \
Bblock \
CALS(desallocation_memoire_des_format_EGAr()); \
CALS(allocation_memoire_et_generation_des_format_EGAr()); \
Eblock \
/* Introduit le 20200329091313. En effet a cette date (et donc bien tardivement) je decouvre */ \
/* que la pre-generation des 'format_EGAr's presente un inconvenient en ce qui concerne les */ \
/* formats susceptibles d'etre modifies via un 'GET_ARGUMENT_*(...)'. C'est par exemple */ \
/* le cas de "SigneInt=" et de "SigneFlot=" qui, a cette date, etaient donc ineffectifs... */ \
/* La solution est donc de les regenerer apres ces 'GET_ARGUMENT_*(...)'s... */
#define editer_versions_programme_librairies_dynamiques \
editer_les_differentes_versions_du_programme_dans_les_librairies_dynamiques \
/* Pour raccourcir une ligne qui va suivre (introduit le 20111009111159)... */
#ifndef NE_PAS_GENERER__GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE__POUVANT_ETRE_FACULTATIFS__01
/* Cet indicateur est controlable par '$xcc/cpp$Z __POUVANT_ETRE_FACULTATIFS__' ainsi que */
/* par 'PRAGMA_CPP_____BLOQUER_LA_SIMPLIFICATION__POUVANT_ETRE_FACULTATIFS__'... */
#Aifndef NE_PAS_GENERER__GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE__POUVANT_ETRE_FACULTATIFS__01
& mdefine NePasGenerer_PARAMETRE_____editer_la_valeur_des_compteurs_de_reference_lors_du__RETU_Commande&&&
& mdefine NePasGenerer_PARAMETRE_____lister_les_parametres_non_parfaitement_reconnus&&&
& mdefine NePasGenerer_PARAMETRE_____permettre_l_acces_au_source_du_programme&&&
& mdefine NePasGenerer_PARAMETRE_____valider_la_longueur_des_noms_absolus_de_fichiers&&&
& mdefine NePasGenerer_PARAMETRE_____forcer_la_validation_de_la_longueur_des_noms_absolus_de_fichiers&&&
& mdefine NePasGenerer_PARAMETRE_____valider_la_longueur_des_noms_relatifs_de_fichiers&&&
& mdefine NePasGenerer_PARAMETRE_____forcer_la_validation_de_la_longueur_des_noms_relatifs_de_fichiers&&&
& mdefine NePasGenerer_PARAMETRE_____DoQu_____editer_le_message_d_une_possible_boucle_infinie&&&
& mdefine NePasGenerer_PARAMETRE_____editer_____liste_des_CODE_ERREUR_rencontres&&&
& mdefine NePasGenerer_PARAMETRE_____Fstore_non_securise_fichier_non_formatte_____compacter_1&&&
& mdefine NePasGenerer_PARAMETRE_____Fstore_non_securise_fichier_non_formatte_____taux_de_compactage_1&&&
& mdefine NePasGenerer_PARAMETRE_____Fload_fichier_non_formatte_____decompacter_1&&&
/* Ces 'mdefine's ont ete introduits le 20200418132843. L'avantage de cette solution par */
/* rapport a la solution anterieure (qui consistait a ne pas implementer les procedures */
/* du type 'GET_ARGUMENT_L(...)' correspondantes) est que les 'GET_ARGUMENT_L(...)'s */
/* associees sont bien referencees ce qui permet de lister ensuite les parametres non */
/* generees via 'editer_le_nom_des_parametres_non_generes_d_une_commande'... */
#Eifndef NE_PAS_GENERER__GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE__POUVANT_ETRE_FACULTATIFS__01
#ifndef NE_PAS_GENERER__GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE__POUVANT_ETRE_FACULTATIFS__02
/* Cet indicateur est controlable par '$xcc/cpp$Z __POUVANT_ETRE_FACULTATIFS__' ainsi que */
/* par 'PRAGMA_CPP_____BLOQUER_LA_SIMPLIFICATION__POUVANT_ETRE_FACULTATIFS__'... */
#Aifndef NE_PAS_GENERER__GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE__POUVANT_ETRE_FACULTATIFS__02
& mdefine NePasGenerer_PARAMETRE_____allocation_memoire_avec_validation_____valider_par_rapport_a_MemorySizeMB&&&
& mdefine NePasGenerer_PARAMETRE_____temp_allocation_memoire_avec_validation_____Amarge_de_securite&&&
& mdefine NePasGenerer_PARAMETRE_____temp_allocation_memoire_avec_validation_____Bmarge_de_securite&&&
& mdefine NePasGenerer_PARAMETRE_____Malo_____valider_si_possible_l_utilisation_de_la_memoire_allouee&&&
/* Ces 'mdefine's ont ete introduits le 20200418132843. L'avantage de cette solution par */
/* rapport a la solution anterieure (qui consistait a ne pas implementer les procedures */
/* du type 'GET_ARGUMENT_L(...)' correspondantes) est que les 'GET_ARGUMENT_L(...)'s */
/* associees sont bien referencees ce qui permet de lister ensuite les parametres non */
/* generees via 'editer_le_nom_des_parametres_non_generes_d_une_commande'... */
#Eifndef NE_PAS_GENERER__GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE__POUVANT_ETRE_FACULTATIFS__02
#define GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE \
Bblock \
/* Cette initialisation doit etre faite dynamiquement car, en effet, cela n'est pas possible */ \
/* dans 'v $xig/fonct$vv$FON sequence_d_echappement_VT100_alternance_des_parametres' puisque */ \
/* la fonction generalement referencee par 'INIC(...)' ne peut etre executee au moment de */ \
/* la definition d'une variable 'Common'. Ceci fut mis en place le 20060610115523... */ \
/* */ \
/* Jusqu'au 20060610150539, il y avait donc ci-desus : */ \
/* */ \
/* EGAL(sequence_d_echappement_VT100_alternance_des_parametres */ \
/* ,chain_Acopie(SEQUENCE_D_ECHAPPEMENT_VT100_INVERSION) */ \
/* ); */ \
/* */ \
/* parce qu'il semblait impossible de faire cette initialisation directement dans */ \
/* 'v $xig/fonct$vv$FON sequence_d_echappement_VT100_alternance_des_parametres'. En fait */ \
/* cela est effectivement impossible si l'on utilise alors 'INIC(...)', or apparemment, il */ \
/* est possible d'utiliser 'INIT(...)', d'ou la suppression de ce 'EGAL(...)'. */ \
\
DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____PRIMAIRES; \
\
BLOC( \
begin_nouveau_block \
Bblock \
/* Introduit le 20091123131100 pour des raisons de lisibilite (tabulation...). */ \
EGAL(bloquer_provisoirement__entrer_des_parametres_via_des_setenv,VRAI); \
/* Introduit le 20090422091211... */ \
\
GET_ARGUMENT_L("Parametres=",editer_la_valeur_des_parametres_d_une_commande); \
/* Ce parametre doit imperativement etre le premier, puisque c'est lui qui controle */ \
/* l'edition des parametres qui le suivent (d'ou le 20061116094115 la remise en seconde */ \
/* position de 'MARQUEUR________DebutParametresGeneraux'...). */ \
/* */ \
/* Le 20030710112150, j'ai enfin compris pourquoi "Parametres=" n'apparaissait pas lors */ \
/* "Parametres=VRAI" etait demande, de meme que le manque d'homogeneite du debut de la */ \
/* liste des parametres (lorsque "Parametres=VRAI") alors que les parametres de mise en */ \
/* page "TabulationParametres=" et/ou "SautParametres=" etaient demandes. En fait, il */ \
/* suffit que d'autres parametres les suivent. Ainsi, pour que la mise en page des */ \
/* parametres soit homogene, il faut imperativement qu'il y ait d'autres parametres */ \
/* introduits apres eux et ce afin que le traitement de l'un d'eux ne soit pas fait */ \
/* dans 'c_est_la_derniere_recherche_des_parametres' car, en effet, dans ce cas le */ \
/* dernier parametre traite (le dernier de la liste d'appel) est traite simultanement a */ \
/* l'edition des parametres ; donc si ce parametre controle cette edition, une partie de */ \
/* celle-ci (en fait celle qui concerne les parametres qui precedent ce dernier parametre */ \
/* dans la liste des 'GET_ARGUMENT_?(...)' qui est ici definie....) sera faite alors que */ \
/* ce parametre n'aura pas encore sa nouvelle valeur. Ainsi, par exemple, on pourra */ \
/* ecrire : */ \
/* */ \
/* Parametres=VRAI */ \
/* TabulationParametres=... */ \
/* SautParametres=VRAI */ \
/* Parametres=VRAI */ \
/* */ \
/* le deuxieme "Parametres=VRAI" etant la uniquement pour que "SautParametres=VRAI" (ou */ \
/* "TabulationParametres=...") ne soit pas le dernier de la liste. Cela a d'ailleurs */ \
/* entraine la modification 'v $Falias_use 20030710115901'. */ \
\
EGAL(bloquer_provisoirement__entrer_des_parametres_via_des_setenv,FAUX); \
/* Introduit le 20090422091211... */ \
Eblock \
end_nouveau_block \
\
MARQUEUR________DebutParametresGeneraux; \
/* Argument fictif destine a marquer le debut des Parametres Generaux (le 20010420143829). */ \
/* Il ne peut apparaitre qu'apres 'editer_la_valeur_des_parametres_d_une_commande' afin */ \
/* justement de pouvoir etre edite... */ \
/* */ \
/* Le 20030710112150, 'MARQUEUR________DebutParametresGeneraux' est passe en tete car cela */ \
/* est plus logique (par definition de 'MARQUEUR________DebutParametresGeneraux'...). */ \
/* */ \
/* Le 20061116094115, 'MARQUEUR________DebutParametresGeneraux' est repasse en seconde */ \
/* position (et donc derriere "Parametres=") car, en effet, en premiere position il ne */ \
/* peut pas etre edite par "Parametres=VRAI"... */ \
\
GET_ARGUMENT_L("ForcerExecution=",forcer_l_execution_malgre_les_editions_demandees); \
/* Ce parametre a ete introduit le 20170604111437 afin de permettre de savoir quels sont */ \
/* parametres reellement utilises pour l'execution d'une commande. Il faudra donc utiliser : */ \
/* */ \
/* Parametres=VRAI */ \
/* ForcerExecution=VRAI */ \
/* */ \
\
GET_ARGUMENT_L("ParametresNonGeneres=""PNG=",editer_le_nom_des_parametres_non_generes_d_une_commande); \
/* Introduit le 20180228101858 et mis ici le 20200418122451, hots des arguments facultatifs */ \
/* 'GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE__POUVANT_ETRE_FACULTATIFS__01'... */ \
\
GET_ARGUMENTS5_L("editer_compteurs_de_reference=""ecr=" \
,editer_la_valeur_des_compteurs_de_reference_lors_du__RETU_Commande \
,FgEDITION_DE_LA_VALEUR_DE_LA_PLUPART_DES_COMPTEURS_____activer \
,FgEDITION_DE_LA_VALEUR_DES_COMPTEURS_D_ALLOCATION_DESALLOCATION_MEMOIRE_____activer \
,FgEDITION_DE_LA_VALEUR_DES_COMPTEURS_D_ENTREE_DES_ARGUMENTS_DES_K_S____activer \
,FgEDITION_DE_LA_VALEUR_DES_COMPTEURS_D_ACCES_AUX_FONCTIONS_DE_BASE____activer \
); \
/* Mis ici le 20180314115527... */ \
\
GET_ARGUMENT_L("ListerParametresNonParfaitementReconnus=""LPNPR=" \
,lister_les_parametres_non_parfaitement_reconnus \
); \
/* Ce parametre introduit le 20150530094835 permet de bloquer l'edition des messages */ \
/* emis lorsqu'un ou plusieurs parametres n'existent pas ou sont mal utilises. Il pourra */ \
/* etre utilise, par exemple, dans un '$Z' pour remplacer temporairement un '$X' par un */ \
/* autre, alors qu'il n'ont pas les memes parametres (ainsi, par exemple, '$xci/init$X' */ \
/* remplacant '$xci/fract_2D.01$X'...). */ \
\
GET_ARGUMENT_L("SourceProgramme=",permettre_l_acces_au_source_du_programme); \
/* ATTENTION : je note le 20080917170001 qu'evidemment il ne faut pas ecrire : */ \
/* */ \
/* ... SourceProgramme=VRAI | $Mor */ \
/* */ \
/* car, en effet, cela donne le message : */ \
/* */ \
/* Vim: Warning: Output is not to a terminal */ \
/* */ \
/* et ne fonctionne pas... */ \
\
GET_ARGUMENT_L("Vna=""Valider_noms_absolus=",valider_la_longueur_des_noms_absolus_de_fichiers); \
/* Le parametre "Vna=" a ete introduit le 20070416135936... */ \
GET_ARGUMENT_L("Fvna=""Forcer_validation_noms_absolus=" \
,forcer_la_validation_de_la_longueur_des_noms_absolus_de_fichiers \
); \
/* Ce parametre a ete introduit le 20070619173244... */ \
GET_ARGUMENT_L("Vnr=""Valider_noms_relatifs=",valider_la_longueur_des_noms_relatifs_de_fichiers); \
/* Le parametre "Vnr=" a ete introduit le 20070416135936... */ \
GET_ARGUMENT_L("Fvnr=""Forcer_validation_noms_relatifs=" \
,forcer_la_validation_de_la_longueur_des_noms_relatifs_de_fichiers \
); \
/* Ce parametre a ete introduit le 20070619173244... */ \
\
GET_ARGUMENT_L("DoQu_infinie=""DoQu=",DoQu_____editer_le_message_d_une_possible_boucle_infinie); \
/* Introduit le 20120419142800... */ \
\
GET_ARGUMENT_L("EditerCodesErreurs=""ECE=",editer_____liste_des_CODE_ERREUR_rencontres); \
/* Introduit le 20110224152209... */ \
\
GET_ARGUMENT_L("compacter_1=",Fstore_non_securise_fichier_non_formatte_____compacter_1); \
GET_ARGUMENT_F("taux_compactage_1=",Fstore_non_securise_fichier_non_formatte_____taux_de_compactage_1); \
GET_ARGUMENT_L("decompacter_1=",Fload_fichier_non_formatte_____decompacter_1); \
\
PROCESS_ARGUMENT_L("All=" \
,editer_tout_ce_est_utile_concernant_le_fonctionnement_et_l_utilisation \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
EGAL(editer_les_differents_bugs_reconnus \
,editer_tout_ce_est_utile_concernant_le_fonctionnement_et_l_utilisation \
); \
EGAL(editer_les_differents_includes_du_programme \
,editer_tout_ce_est_utile_concernant_le_fonctionnement_et_l_utilisation \
); \
EGAL(lister_tous_les_messages_possibles \
,editer_tout_ce_est_utile_concernant_le_fonctionnement_et_l_utilisation \
); \
EGAL(editer_le_NOM_SYNTHETIQUE_de_la_commande_courante \
,editer_tout_ce_est_utile_concernant_le_fonctionnement_et_l_utilisation \
); \
EGAL(editer_le_NOM_ABSOLU_DU_SOURCE_c_de_la_commande_courante \
,editer_tout_ce_est_utile_concernant_le_fonctionnement_et_l_utilisation \
); \
EGAL(editer_la_valeur_des_parametres_d_une_commande \
,editer_tout_ce_est_utile_concernant_le_fonctionnement_et_l_utilisation \
); \
EGAL(editer_les_differentes_variables_d_environnement_utiles \
,editer_tout_ce_est_utile_concernant_le_fonctionnement_et_l_utilisation \
); \
EGAL(editer_les_differentes_versions_du_programme \
,editer_tout_ce_est_utile_concernant_le_fonctionnement_et_l_utilisation \
); \
EGAL(editer_la_liste_des_librairies_dynamiques_utilisees \
,editer_tout_ce_est_utile_concernant_le_fonctionnement_et_l_utilisation \
); \
EGAL(editer_versions_programme_librairies_dynamiques \
,editer_tout_ce_est_utile_concernant_le_fonctionnement_et_l_utilisation \
); \
Eblock \
) \
); \
/* Ce parametre a ete introduit le 20091027115127... */ \
/* */ \
/* Le cas de 'editer_les_differentes_versions_du_programme_dans_les_librairies_dynamiques' */ \
/* a ete introduit le 20111009110606 car, en effet, il manquait... */ \
/* */ \
/* Le test de 'editer_la_liste_des_librairies_dynamiques_utilisees' a ete introduit le */ \
/* 20220824180116... */ \
\
GET_ARGUMENT_I("TabulationParametres=",tabulation_des_valeurs_affectees_aux_titres); \
/* Ce parametre doit imperativement etre le second si l'on souhaite que la tabulation des */ \
/* sorties de "Parametres=VRAI" soit homogene... */ \
PROCESS_ARGUMENT_L("SautParametres=" \
,sauter_une_ligne_pour_chaque_nouveau_Parametre \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
AVERTIR_EN_CAS_D_INCOMPATIBILITE_DE_MISE_EN_PAGE_DES_PARAMETRES; \
Eblock \
) \
); \
/* Ce nouveau parametre a ete introduit le 20030627132814 afin de permettre d'aerer la */ \
/* presentation. Le 20030628110830, j'ai change "NL_Parametres=" en "SautParametres=" qui */ \
/* me semble plus "homogene"... */ \
\
/* Les parametres suivants relatifs aux synonymes ont ete mis ici le 20070330145617, alors */ \
/* qu'anterieurement ils figuraient juste apres "cpp="... */ \
\
PROCESS_ARGUMENT_L("ParametresSynonymes=""PS=" \
,editer_les_synonymes_des_parametres_d_une_commande \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
AVERTIR_EN_CAS_D_INCOMPATIBILITE_D_EDITION_DES_SYNONYMES; \
Eblock \
) \
); \
PROCESS_ARGUMENT_L("ParametresSynonymesGrouper=""PSG=" \
,grouper_les_synonymes_des_parametres_d_une_commande \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
AVERTIR_EN_CAS_D_INCOMPATIBILITE_D_EDITION_DES_SYNONYMES; \
Eblock \
) \
); \
/* Parametre introduit le 20070330091147... */ \
\
GET_ARGUMENT_I("ParametresLongueurMaximale=" \
,editer_la_valeur_des_parametres_d_une_commande_____longueur_maximale_des_vecteurs \
); \
\
/* Les parametres precedents relatifs aux synonymes ont ete mis ici le 20070330145617, alors */ \
/* qu'anterieurement ils figuraient juste apres "cpp="... */ \
\
PROCESS_ARGUMENT_K("FORMAT_CHAI=""CHAI=" \
,PREMIER_CARACTERE_ITb0(FORMAT_CHAI_EDITION_____caractere_d_encadrement) \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
MISE_A_JOUR_des_format_EGAr; \
Eblock \
) \
); \
PROCESS_ARGUMENT_K("FORMAT_CHAR=""CHAR=" \
,PREMIER_CARACTERE_ITb0(FORMAT_CHAR_EDITION_____caractere_d_encadrement) \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
MISE_A_JOUR_des_format_EGAr; \
Eblock \
) \
); \
/* Introduit le 20070227185323... */ \
\
PROCESS_ARGUMENT_L("AlternerParametres=" \
,alterner_les_parametres_pour_plus_de_lisibilite \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
AVERTIR_EN_CAS_D_INCOMPATIBILITE_DE_MISE_EN_PAGE_DES_PARAMETRES; \
Eblock \
) \
); \
GET_ARGUMENT_C("TypeAlternanceParametres=",sequence_d_echappement_VT100_alternance_des_parametres); \
/* Ces nouveaux parametres ont ete introduits le 20060610103137 afin de permettre d'inverser */ \
/* un parametre sur deux lors de leur eventuelle edition et ainsi en ameliorer la */ \
/* lisibilite... */ \
/* */ \
/* Evidemment, l'inversion ne prend effet qu'apres son activation dans le cas ou la non */ \
/* est l'etat par defaut (cas le 20060610111958)... */ \
\
GET_ARGUMENT_L("NomParametres=",editer_le_nom_des_parametres_d_une_commande); \
\
PROCESS_ARGUMENT_C("PreFixeParametres=""PFP=" \
,prefixe_destine_a_abreger_certains_Parametres_qui_suivent \
,BLOC(VIDE;) \
,BLOC(Bblock \
Test(EST_FAUX(chain_compare(prefixe_destine_a_abreger_certains_Parametres_qui_suivent \
,C_VIDE \
) \
) \
) \
Bblock \
INCR(nombre_de_demandes_effectives_de_PreFixeParametres,I); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
) \
); \
/* Le parametre 'prefixe_destine_a_abreger_certains_Parametres_qui_suivent' a ete */ \
/* introduit le 20030704090902 afin de permettre une utilisation du type abreviation des */ \
/* parametres trop longs. Ainsi, par exemple, au lieu d'ecrire : */ \
/* */ \
/* LISTE_A11=... */ \
/* LISTE_A12=... */ \
/* (...) */ \
/* LISTE_A23=... */ \
/* */ \
/* on pourra ecrire : */ \
/* */ \
/* PreFixeParametres="LISTE_" */ \
/* A11=... */ \
/* A12=... */ \
/* (...) */ \
/* A23=... */ \
/* */ \
/* lors de l'utilisation de 'v $xrv/SysLin_2D.01$K'. Mais ATTENTION, afin de pouvoir */ \
/* ecrire : */ \
/* */ \
/* (...) */ \
/* PreFixeParametres="LISTE_" */ \
/* A11=... */ \
/* A12=... */ \
/* (...) */ \
/* A23=... */ \
/* PreFixeParametres="" */ \
/* (...) */ \
/* */ \
/* il est necessaire que ce dispositif ne prefixe pas "PreFixeParametres=" (et ne le */ \
/* transforme donc pas, dans cet exemple, en "LISTE_PreFixeParametres=" qui n'existe */ \
/* pas...). C'est pourquoi, le 20030704142017, ce dispositif a vu son utilisation */ \
/* restreinte a 'PROCESF_ARGUMENT_C(...)' et interdite a 'PROCESS_PARAMETRE(...)'... */ \
/* Ainsi, "PreFixeParametres=" n'est plus prefixable de meme que tous les parametres */ \
/* definis via 'PROCESS_PARAMETRE(...)'... */ \
/* */ \
/* Le 20030708094336, les 'GET_ARGUMENT_C(...)' ont ete remplaces par des */ \
/* 'PROCESS_ARGUMENT_C(...)' afin de permettre le comptage des demandes de modifications */ \
/* effectives de 'prefixe_destine_a_abreger_certains_Parametres_qui_suivent'... */ \
\
PROCESS_ARGUMENT_L("ParametresInteractifsActivation=""PIA=" \
,tenter_une_entree_interactive_des_parametres \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
AVERTIR_EN_CAS_D_ENTREE_INTERACTIVE_D_UN_PARAMETRE; \
Eblock \
) \
); \
/* Ce parametre a ete introduit le 20051111141329 et le 20051112205650 ("PIA="). */ \
PROCESS_ARGUMENT_K("ParametresInteractifsIntroduction=""PII=" \
,PREMIER_CARACTERE_ITb0(introduction_d_une_valeur_interactive) \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
AVERTIR_EN_CAS_D_ENTREE_INTERACTIVE_D_UN_PARAMETRE; \
Eblock \
) \
); \
/* Ce parametre a ete introduit le 20051112205650 et le 20051114115905 ("PII="). */ \
\
GET_ARGUMENT_L("ChronometrerCommande=""ChC=",chronometrer_la_commande_courante); \
/* Ce parametre a ete introduit le 20170518114143 et permet de chronometrer la commande */ \
/* courante. Au passage, "CC=" n'est pas disponible ('v $xci/ondes.01$K CC=')... */ \
\
GET_ARGUMENT_L("NeRienFaire=""NRF=",ne_rien_faire_et_sortir_immediatement); \
/* Ce parametre a ete introduit le 20061110090803 afin de permettre de tester qu'un certain */ \
/* '$X' peut s'executer et qu'en particulier il est compatible avec les '$SO' dont il a */ \
/* besoin... */ \
/* */ \
/* Le synonyme "NRF=" a ete introduit le 20180414110021 pour simplifier les tests... */ \
\
GET_ARGUMENT_C("IdentifiantBranchesParalleles=""IdentifiantBrancheParallele=""IBP=" \
,identifiant_de_branches_paralleles \
); \
/* Afin de pouvoir distinguer, si besoin est, plusieurs commandes identiques s'executant */ \
/* en parallele, par exemple via 'execRVB' (introduit le 20111121135717 et complete le */ \
/* 20111122093216 avec les synonymes "IdentifiantBrancheParallele=" et "IBP="...). */ \
\
GET_ARGUMENT_L("FconversionIJXY_vide_forcee=""FIJXYvf=" \
,FconversionI__FconversionJ__FconversionX__FconversionY_____une_valeur_vide_doit_etre_forcee \
); \
GET_ARGUMENT_L("FconversionF_vide_forcee=""FFvf=" \
,FconversionF_____une_valeur_vide_doit_etre_forcee \
); \
GET_ARGUMENT_L("FconversionK_vide_forcee=""FKvf=" \
,FconversionK_____une_valeur_vide_doit_etre_forcee \
); \
GET_ARGUMENT_L("FconversionCCLCN_vide_forcee=""FCCLCNvf=" \
,FconversionC__FconversionCL__FconversionCN_____une_valeur_vide_doit_etre_forcee \
); \
/* Arguments introduits le 20120108102520... */ \
/* */ \
/* On notera qu'evidemment ces arguments doivent etre utilises avant les arguments */ \
/* concernes. Ainsi, par exemple : */ \
/* */ \
/* $xcg/DIVZ.01$X nombre_2= FconversionF_vide_forcee=FAUX */ \
/* */ \
/* n'utilisera pas la valeur par defaut (=1, 'v $xcg/DIVZ.01$K NOMBRE_2') mais la valeur */ \
/* forcee (=0, 'v $xig/fonct$vv$DEF VALEUR_VIDE_POUR_FconversionF'). Il conviendra donc */ \
/* d'ecrire : */ \
/* */ \
/* $xcg/DIVZ.01$X FconversionF_vide_forcee=FAUX nombre_2= */ \
/* */ \
/* pour obtenir l'effet attendu... */ \
\
GET_ARGUMENT_L("avertir_UNDEF=""UNDEF=" \
,FconversionI__FconversionJ__FconversionX__FconversionY_____avertir_lors_de_l_entree_de_UNDEF \
); \
GET_ARGUMENT_L("avertir_FLOT__UNDEF=""FLOT__UNDEF=""FUNDEF=" \
,FconversionF_____avertir_lors_de_l_entree_de_FLOT__UNDEF \
); \
/* Parametres introduits le 20070821131554... */ \
/* */ \
/* Evidemment, ces parametres doivent etre utilises avant toute entree de nombres valant */ \
/* 'UNDEF' et 'FLOT__UNDEF' respectivement... */ \
\
GET_ARGUMENT_L("confondre_J_X_Y_avec_I=""cJXYI=""cIJXY=""IJXY=" \
,FconversionJ__FconversionX__FconversionY_____confondre_les_types__J_X_Y__avec__le_type_I \
); \
/* On notera que la logique veut qu'evidemment ce 'GET_ARGUMENT_L(...)' apparaisse */ \
/* avant tout {GET_ARGUMENT_J(...),GET_ARGUMENT_X(...),GET_ARGUMENT_Y(...)}. Ceci fut */ \
/* introduit le 20070422091214... */ \
\
GET_ARGUMENT_L("IBase_10_10=""IB1010=""Base_10_10=""B1010=" \
,FconversionI__FconversionJ_____editer_les_valeurs_entieres_decimales_en_decimal \
); \
GET_ARGUMENT_N("IBase_10_16=""IB1016=""Base_10_16=""B1016=" \
,FconversionI__FconversionJ_____editer_les_valeurs_entieres_decimales_en_decimal \
); \
GET_ARGUMENT_L("IBase_16_10=""IB1610=""Base_16_10=""B1610=" \
,FconversionI__FconversionJ_____editer_les_valeurs_entieres_hexa_decimales_en_decimal \
); \
GET_ARGUMENT_N("IBase_16_16=""IB1616=""Base_16_16=""B1616=" \
,FconversionI__FconversionJ_____editer_les_valeurs_entieres_hexa_decimales_en_decimal \
); \
/* Ceci a ete introduit le 20021204090003 en vue de l'utiliser dans 'v $xcp/substitue.01$K' */ \
/* et les versions simplifiees ont ete introduites le 20021207131214. Le 20030710112150, */ \
/* ces 'GET_ARGUMENT_L(...)'s et 'GET_ARGUMENT_N(...)'s ont ete mis ici, alors qu'avant */ \
/* cette date, ils etaient avant le 'NomParametres=', mais il etait plus logique que la */ \
/* des parametres : */ \
/* */ \
/* editer_le_nom_des_parametres_d_une_commande */ \
/* prefixe_destine_a_abreger_certains_Parametres_qui_suivent */ \
/* */ \
/* soit juste apres 'MARQUEUR________DebutParametresGeneraux'... */ \
/* */ \
/* Le prefixe "I" a ete introduit le 20070421084035 par symetrie avec les nouveaux */ \
/* parametres qui sont destines a 'GET_ARGUMENT_X(...)' et 'GET_ARGUMENT_Y(...)' et qui */ \
/* suivent. Malgre tout, les anciennes formes (sans le prefixe "I") sont conservees afin */ \
/* d'eviter de tout recompiler (et ce a cause de 'v $Falias_use Base_10_16'...). */ \
GET_ARGUMENT_L("XBase_10_10=""XB1010=" \
,FconversionX__FconversionY_____editer_les_valeurs_entieres_decimales_en_decimal \
); \
GET_ARGUMENT_N("XBase_10_16=""XB1016=" \
,FconversionX__FconversionY_____editer_les_valeurs_entieres_decimales_en_decimal \
); \
GET_ARGUMENT_L("XBase_16_10=""XB1610=" \
,FconversionX__FconversionY_____editer_les_valeurs_entieres_hexa_decimales_en_decimal \
); \
GET_ARGUMENT_N("XBase_16_16=""XB1616=" \
,FconversionX__FconversionY_____editer_les_valeurs_entieres_hexa_decimales_en_decimal \
); \
/* Ceci a ete introduit le 20070420190717 en vue de l'utiliser dans 'v $xcg/parallele.01$K'. */ \
\
GET_ARGUMENT_L("Gmajuscules=" \
,GET_ARGUMENT_____convertir_les_caracteres_majuscules_en_caracteres_minuscules \
); \
GET_ARGUMENT_L("Gminuscules=" \
,GET_ARGUMENT_____convertir_les_caracteres_minuscules_en_caracteres_majuscules \
); \
GET_ARGUMENT_K("Gcarret=" \
,GET_ARGUMENT_____carret_chain_Acopie_avec_conversions_possibles_majuscules_minuscules \
); \
\
GET_ARGUMENTS_DE_CONTROLE_DE_TRAITEMENT_DES_FORMATS_DE_SORTIE; \
\
GET_ARGUMENT_K("cpp=",PREMIER_CARACTERE_ITb0(cINTRODUCTION_DES_DIRECTIVES_DU_PREPROCESSEUR_cpp)); \
\
PROCESS_ARGUMENT_K("SigneInt=" \
,PREMIER_CARACTERE_ITb0(signe_de_FORMAT_INTE_EDITION) \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
MISE_A_JOUR_des_format_EGAr; \
Eblock \
) \
); \
PROCESS_ARGUMENT_K("SigneFlot=" \
,PREMIER_CARACTERE_ITb0(signe_de_FORMAT_FLOT_EDITION) \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
MISE_A_JOUR_des_format_EGAr; \
Eblock \
) \
); \
/* Ces deux nouveaux parametres ont ete introduits aux environs du 20010202150000. */ \
/* ATTENTION, ces deux parametres ne sont pas editees lors de "Parametres=VRAI" si leur */ \
/* valeur est vide ; en effet, 'v $xig/fonct$vv$FON EDITER_LA_VALEUR_dans_FconversionK' */ \
/* (la valeur vide correspondant a 'K_NULL'). */ \
/* */ \
/* Le 20200329091313 a ete introduite une mise a jour immedaite des 'format_EGAr's... */ \
PROCESS_ARGUMENT_K("ModeFlot=" \
,PREMIER_CARACTERE_ITb0(mode_fg_de_FORMAT_FLOT_EDITION) \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
MISE_A_JOUR_des_format_EGAr; \
Eblock \
) \
); \
/* Ce nouveau parametre a ete introduit le 20091123111002 afin de permettre de garantir le */ \
/* nombre de decimales (via donc "%f"). Ceci sera particulierement utilise dans l'usage */ \
/* 'v $xci/display$K X11_____KeyPress_____norm_XY_curseur'... */ \
PROCESS_ARGUMENT_I("ChiffresFlot=" \
,nombre_de_chiffres_des_editions_flottantes \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
EGAL(parametrage_des_formats_des_editions_flottantes_____initialiser_le_parametrage \
,VRAI \
); \
&define _____GENERE_I_SETENV_ChiffresFlot GENERE_I_SETENV("SETENV_ChiffresFlot",nombre_de_chiffres_des_editions_flottantes)&&& \
/* En effet, si 'nombre_de_chiffres_des_editions_flottantes' a change de valeur, il faut */ \
/* refaire l'initialisation du processus de parametrage des formats des editions flottantes. */ \
/* */ \
/* Jusqu'au 20060109093426, il y avait ici de plus : */ \
/* */ \
/* GET_ARGUMENT_K */ \
/* ("CaractereFlot=" */ \
/* ,PREMIER_CARACTERE_ITb0 */ \
/* (parametrage_des_formats_des_editions_flottantes_____caractere_param) */ \
/* ); */ \
/* */ \
/* mais, cela n'a aucune utilite, je le supprime donc... */ \
/* */ \
/* On notera bien que via 'v $xci/valeurs.03$I nombre_de_decimales' ce parametre possede */ \
/* un synonyme 'nombre_de_decimales' declare en general sous la forme : */ \
/* */ \
/* GET_ARGUMENT_I("decimales=",nombre_de_decimales); */ \
/* */ \
/* par exemple dans 'v $xcg/ABSO.01$K nombre_de_decimales'... */ \
Eblock \
) \
); \
/* Ce nouveau parametre a ete introduit le 20060104161630 et 'SETENV_ChiffresFlot' le */ \
/* 20180218190542... */ \
\
GET_ARGUMENT_I("NombreMaximalChiffresNumeros=""nmcn=""Nchiffres=" \
,ChaineNumero_____nombre_maximal_de_chiffres \
); \
/* Ce nouveau parametre a ete introduit le 20080602111607... */ \
/* */ \
/* Le 20160721174735 fut ajoute "Nchiffres=" qui est proche de "chiffres=" frequemment */ \
/* utilise ('v $xrc/mandel.41$K GET_ARGUMENT_I..chiffres=..nombre_de_chiffres..')... */ \
\
GET_ARGUMENT_L("DoubleDefinition=",tester_la_double_definition_des_parametres); \
\
GET_ARGUMENT_L("EditerCommandes=",editer_les_commandes_avant_execution); \
\
begin_nouveau_block \
Bblock \
/* Introduit le 20091123131100 pour des raisons de lisibilite (tabulation...). */ \
EGAL(bloquer_provisoirement__entrer_des_parametres_via_des_setenv,VRAI); \
/* Introduit le 20090422091211... */ \
\
GET_ARGUMENT_L("NomSynthetique=",editer_le_NOM_SYNTHETIQUE_de_la_commande_courante); \
GET_ARGUMENT_L("NomAbsoluSource=",editer_le_NOM_ABSOLU_DU_SOURCE_c_de_la_commande_courante); \
/* Introduit le 20240104111119... */ \
GET_ARGUMENT_L("ListerMessages=",lister_tous_les_messages_possibles); \
\
EGAL(bloquer_provisoirement__entrer_des_parametres_via_des_setenv,FAUX); \
/* Introduit le 20090422091211... */ \
Eblock \
end_nouveau_block \
\
PROCESS_ARGUMENT_L("SETENV=""setenv=""Environnement=" \
,entrer_des_parametres_via_des_setenv \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
AVERTIR_EN_CAS_D_ENTREE_VIA_UN_setenv_D_UN_PARAMETRE; \
Eblock \
) \
); \
/* Ce dispositif permet d'entrer certains parametres via des variables de type 'setenv'. */ \
/* Soit un certain parametre qui habituellement est introduit via : */ \
/* */ \
/* PARAMETRE=... */ \
/* */ \
/* Deux cas se presentent : */ \
/* */ \
/* 1-la variable '$P__' existe (cas standard, car cette variable est definie */ \
/* implicitement par 'v $Fcommandes P__'). Alors, ce parametre peut etre introduit */ \
/* par un : */ \
/* */ \
/* setenv P__PARAMETRE ... */ \
/* */ \
/* 2-la variable '$P__' n'existe pas (elle a donc ete detruite par un 'unsetenv'). */ \
/* Alors, ce parametre peut etre introduit par un : */ \
/* */ \
/* unsetenv P__ */ \
/* (...) */ \
/* setenv P__NomSynthetiqueDuFichierCourant__PARAMETRE ... */ \
/* */ \
/* ou 'NomSynthetiqueDuFichierCourant' designe la chaine qui est engendree par la */ \
/* variable 'NOM_SYNTHETIQUE_DU_FICHIER_COURANT' et qui peut etre editee grace a : */ \
/* */ \
/* NomSynthetique=VRAI */ \
/* */ \
/* ce qui permet de traiter ainsi simultanement plusieurs commandes '$X' (ce qui */ \
/* n'est pas possible si la variable '$P__' existe car alors les noms des variables */ \
/* de type 'setenv' sont independantes de la commande '$X' utilisee...) meme si */ \
/* elles possedent des parametres formellement identiques... */ \
/* */ \
/* Le 20060315151257, les 'GET_ARGUMENT_L(...)'s correspondants ont ete remplaces par des */ \
/* 'PROCESS_ARGUMENT_L(...)'s afin de garantir que 'entrer_des_parametres_via_des_setenv' */ \
/* est le premier parametre traite d'un programme '$K' et de signaler le probleme dans le */ \
/* cas contraire ('v $xig/fonct$vv$DEF gPROCESS_PARAMETRE_ENTREE_PAR_setenv')... */ \
/* */ \
/* Le 20080918131207, je note que lorsqu'il y a des synonymes et que plusieurs variables */ \
/* 'setenv' correspondantes existent, c'est la derniere rencontree qui l'emporte. Ainsi par */ \
/* exemple, la commande 'v $xcg/ABSO.01$K "x=""nombre=""n=""a="' possede quatre synonymes */ \
/* pour definir le nombre 'nombre' dont on cherche la valeur absolue. Si les deux variables */ \
/* suivantes existent : */ \
/* */ \
/* setenv P__n -1 */ \
/* setenv P__x -2 */ \
/* */ \
/* la valeur editee vaudra "+1" puisque "n=" est apres "x=" dans '"x=""nombre=""n=""a="'... */ \
/* ---- ---- ---- ---- */ \
/* || || /||\ /||\ */ \
/* || || || || */ \
/* || | --------- | || */ \
/* || ----------- || */ \
/* || || */ \
/* | ------------------------------------- | */ \
/* --------------------------------------- */ \
/* */ \
/* Ce n'est donc pas l'ordre alphabetique des variables 'P__...' qui l'emporte, mais l'odre */ \
/* de definition des synonymes. Enfin, si l'un des {"x=","nombre=","n=","a="} est present */ \
/* (lors de l'appel de la commande '$xcg/ABSO.01$X'), c'est le dernier rencontre qui */ \
/* l'emporte sur les eventuelles variables 'setenv'... */ \
/* */ \
/* Le 20090325094302, fut introduit "SETENV=" par symetrie avec la variable d'environnement */ \
/* '$SETENV' introduite la meme date... */ \
\
begin_nouveau_block \
Bblock \
/* Introduit le 20091123131100 pour des raisons de lisibilite (tabulation...). */ \
EGAL(bloquer_provisoirement__entrer_des_parametres_via_des_setenv,VRAI); \
/* Introduit le 20090422091211... */ \
\
GET_ARGUMENT_L("ListeFonctions=" \
,permettre_l_acces_a_la_liste_des_fonctions_referencees_par_le_programme \
); \
/* Introduit le 20120626104316... */ \
GET_ARGUMENT_L("SetenvUniverselles=""SeUn=" \
,GENERE_TYPE_SETENV_____editer_les_variables_SETENV_universelles \
); \
/* Introduit le 20180218174623... */ \
/* */ \
/* Le 20180328144928, il y a eu remplacement de '"UniverselleSetenv=""UnSe="' par */ \
/* par '"SetenvUniverselles=""SeUn="' plus homogene... */ \
GET_ARGUMENT_L("Setenv=",editer_les_differentes_variables_d_environnement_utiles); \
/* Introduit le 20091114113908... */ \
GET_ARGUMENT_L("SetenvSO=" \
,editer_les_differentes_variables_d_environnement_utiles_dans_les_librairies_dynamiques \
); \
/* Introduit le 20091116092801... */ \
GET_ARGUMENT_L("Versions=",editer_les_differentes_versions_du_programme); \
PROCESS_ARGUMENT_L("VersionsSO=" \
,editer_versions_programme_librairies_dynamiques \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
Test(IFET(IL_NE_FAUT_PAS(editer_les_differentes_versions_du_programme) \
,IL_FAUT(editer_versions_programme_librairies_dynamiques) \
) \
) \
Bblock \
PRINT_ERREUR("Probleme dans l'edition des versions"); \
EGAL(editer_les_differentes_versions_du_programme,VRAI); \
CAL1(Prer2("'VersionsSO=%s' demande 'Versions=%s' qui est force " \
,ETAT_LOGIQUE(editer_versions_programme_librairies_dynamiques) \
,ETAT_LOGIQUE(editer_les_differentes_versions_du_programme) \
) \
); \
CAL1(Prer2("dans l'ordre 'Versions=%s VersionsSO=%s'.\n" \
,ETAT_LOGIQUE(editer_les_differentes_versions_du_programme) \
,ETAT_LOGIQUE(editer_versions_programme_librairies_dynamiques) \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
) \
); \
/* Introduit le 20091116092801... */ \
GET_ARGUMENT_L("LibrairiesDynamiques=""LibDyn=",editer_la_liste_des_librairies_dynamiques_utilisees); \
/* Introduit le 20220824180116... */ \
GET_ARGUMENT_L("Bugs=",editer_les_differents_bugs_reconnus); \
GET_ARGUMENT_L("Includes=",editer_les_differents_includes_du_programme); \
\
EGAL(bloquer_provisoirement__entrer_des_parametres_via_des_setenv,FAUX); \
/* Introduit le 20090422091211... */ \
Eblock \
end_nouveau_block \
\
GET_ARGUMENT_L("Prin=",Prin_____changer_le_stream); \
GET_ARGUMENT_L("Prer=",Prer_____changer_le_stream); \
GET_ARGUMENT_L("Prme=",Prme_____changer_le_stream); \
/* ATTENTION, l'ordre a de l'importance ; par exemple : */ \
/* */ \
/* ... Parametres=VRAI Prme=VRAI | $Mor */ \
/* */ \
/* ne donnera pas une bonne pagination, alors qu'il faut en fait utiliser : */ \
/* */ \
/* ... Prme=VRAI Parametres=VRAI | $Mor */ \
/* */ \
/* a cause de 'v $xig/fonct$vv$FON Valeur.de.tous.les.parametres.de.cette.commande'. */ \
/* */ \
/* On notera les valeurs par defaut suivantes : */ \
/* */ \
/* stream_Prin = STREAM_OUT */ \
/* stream_Prme = STREAM_ERREUR */ \
/* stream_Prer = STREAM_ERREUR */ \
/* */ \
\
GET_ARGUMENT_L("CAL1=",CAL1_____executer); \
&define _____GENERE_L_SETENV_CAL1 GENERE_L_SETENV("SETENV_CAL1",CAL1_____executer)&&& \
GET_ARGUMENT_L("CAL2=",CAL2_____executer); \
&define _____GENERE_L_SETENV_CAL2 GENERE_L_SETENV("SETENV_CAL2",CAL2_____executer)&&& \
GET_ARGUMENT_L("CAL3=",CAL3_____executer); \
&define _____GENERE_L_SETENV_CAL3 GENERE_L_SETENV("SETENV_CAL3",CAL3_____executer)&&& \
GET_ARGUMENT_L("CAL4=",CAL4_____executer); \
/* Les "_____GENERE_L_SETENV_" ont ete introduits le 20180218102015... */ \
\
GET_ARGUMENT_L("AccelerateurFonctions=""AccFoncs=",ACCELERATEUR_DE_FONCTIONS_A_N_ARGUMENTS____utiliser); \
/* Ce parametre a ete introduit le 20120310093800... */ \
\
GET_ARGUMENT_L("EditionVerrou=""EditerVerrou=""EV=",ePARALLELE_____editer_le_verrou); \
/* Ce parametre a ete introduit le 20070710113651 et complete le 20070710125300... */ \
\
GET_ARGUMENT_L("Bloquer=",bloquer_tous_les_messages_d_erreur_des_fichiers); \
\
GET_ARGUMENT_L("NomsConvertissables=" \
,FonctionI_Fload_____les_noms_des_fichiers_sont_convertissables_en_valeurs_numeriques \
); \
/* Introduit le 20031130101525... */ \
/* */ \
/* ATTENTION : ce parametre doit evidemment etre modifie avant d'etre utilise via les */ \
/* fonctions 'Fload_fichier_formatte_Int(...)' et 'Fload_fichier_formatte_Float(...)'. */ \
\
GET_ARGUMENT_L("Verifier=" \
,Fstore_fichier_non_formatte_____valider_le_contenu_des_fichiers_apres_leur_ecriture \
); \
\
GET_ARGUMENT_L("UtiliserDirectoryTemporaire=""UDT=" \
,Fstore_fichier_non_formatte_____utiliser_un_directory_temporaire \
); \
GET_ARGUMENT_I("NumeroDirectoryTemporaire=""NDT=" \
,Fstore_fichier_non_formatte_____numero_directory_temporaire_a_utiliser \
); \
GET_ARGUMENT_L("ConserverTemporairementFichierExistant=""CTFE=" \
,Fstore_fichier_non_formatte_____conserver_temporairement_le_fichier_s_il_existe_deja \
); \
GET_ARGUMENT_L("NomFicherNomCache=""NFNC=" \
,Fstore_fichier_non_formatte_____introduire__nom_du_fichier__dans__nom_cache_du_fichier \
); \
GET_ARGUMENT_K("SubstitutSeparateurPath=""SSP=" \
,MOVE_CARACTERE_____substitut_des_SEPARATEUR_DES_PATHS \
); \
GET_ARGUMENT_I("IndexHeuristiqueIdentiteFileSystems=""IHIFS=" \
,Fstore_fichier_non_formatte_____index_heuristique_d_identite_de_File_Systems \
); \
/* Introduits le 20160511102356... */ \
/* */ \
/* Le 20160511114847, le changement de Directory Temporaire a ete deconseille (voir a */ \
/* ce propos 'v $xig/fonct$vv$FON 20160511114323'), puis le 20160512124152, cet */ \
/* avertissement a ete supprime, apres avoir resolu de facon heuristique le test */ \
/* de savoir sir deux noms absolus appartiennent au meme 'File System' (voir a ce */ \
/* propos 'v $xig/fonct$vv$FON 20160512122844'). Cela a conduit le 20160512124152 a */ \
/* l'introduction de 'index_heuristique_d_identite_de_File_Systems' ci-dessus... */ \
/* */ \
/* Le 20170424144151 cela fut complete par l'introduction possible du nom d'un fichier */ \
/* dans son nom cache ('v $xig/fonct$vv$FON nom_relatif_temporaire'), mais evidemment */ \
/* apres avoir remplacer les 'SEPARATEUR_DES_PATHS' par d'autres caracteres ('_' par */ \
/* defaut)... */ \
/* */ \
/* Le 20170424174046 fut introduite la possibilite de conserver temporairement la nouvelle */ \
/* version d'un fichier pre-existant... */ \
\
GET_ARGUMENT_L("Attendre=",attendre_un_fichier_inexistant_ou_non_conforme); \
\
GET_ARGUMENT_L("Alleger=",gPRINT_DEFAUT_____n_editer_que_le_message_principal); \
&define _____GENERE_L_SETENV_Alleger GENERE_L_SETENV("SETENV_Alleger",gPRINT_DEFAUT_____n_editer_que_le_message_principal)&&& \
/* Les "_____GENERE_L_SETENV_" ont ete introduits le 20180218102015... */ \
\
GET_ARGUMENT_L("ATTENTION=",PRINT_ATTENTION_____editer_les_messages); \
&define _____GENERE_L_SETENV_ATTENTION GENERE_L_SETENV("SETENV_ATTENTION",PRINT_ATTENTION_____editer_les_messages)&&& \
/* Les "_____GENERE_L_SETENV_" ont ete introduits le 20180218102015... */ \
GET_ARGUMENT_L("AVERTISSEMENT=",PRINT_AVERTISSEMENT_____editer_les_messages); \
GET_ARGUMENT_L("DEBUG=",PRINT_DEBUG_____editer_les_messages); \
GET_ARGUMENT_L("DEFAUT=",PRINT_DEFAUT_____editer_les_messages); \
GET_ARGUMENT_L("ERREUR=",PRINT_ERREUR_____editer_les_messages); \
&define _____GENERE_L_SETENV_ERREUR GENERE_L_SETENV("SETENV_ERREUR",PRINT_ERREUR_____editer_les_messages)&&& \
/* Les "_____GENERE_L_SETENV_" ont ete introduits le 20180218102015... */ \
GET_ARGUMENT_L("MESSAGE=",PRINT_MESSAGE_____editer_les_messages); \
\
GET_ARGUMENT_L("EnTetePrin=",Prin_____editer_les_messages_d_en_tete); \
&define _____GENERE_L_SETENV_EnTetePrin GENERE_L_SETENV("SETENV_EnTetePrin",Prin_____editer_les_messages_d_en_tete)&&& \
/* Les "_____GENERE_L_SETENV_" ont ete introduits le 20180218102015... */ \
GET_ARGUMENT_L("EnTetePrer=",Prer_____editer_les_messages_d_en_tete); \
&define _____GENERE_L_SETENV_EnTetePrer GENERE_L_SETENV("SETENV_EnTetePrer",Prer_____editer_les_messages_d_en_tete)&&& \
/* Les "_____GENERE_L_SETENV_" ont ete introduits le 20180218102015... */ \
GET_ARGUMENT_L("EnTetePrme=",Prme_____editer_les_messages_d_en_tete); \
&define _____GENERE_L_SETENV_EnTetePrme GENERE_L_SETENV("SETENV_EnTetePrme",Prme_____editer_les_messages_d_en_tete)&&& \
/* Les "_____GENERE_L_SETENV_" ont ete introduits le 20180218102015... */ \
/* Introduits le 20111121144901... */ \
\
GET_ARGUMENT_L("suppression_K_LF_en_tete=""sK_LFet=" \
,chain_Acopie_avec_suppression_d_un_eventuel_K_LF_en_tete_____la_suppression_est_utile \
); \
/* Introduit le 20150504175719 pour 'v $Falias_exec123 suppression__K_LF_en_tete'... */ \
\
GET_ARGUMENT_I("SeuilLectureFichier=""SLF=",Fload_fichier_non_formatte_____seuil_size_fichier); \
GET_ARGUMENT_I("SeuilEcritureFichier=""SEF=",Fstore_fichier_non_formatte_____seuil_size_fichier); \
/* Introduits le 20141006101935... */ \
/* */ \
/* ATTENTION, l'usage de "SLF=..." impliquera en general l'usage de : */ \
/* */ \
/* Verifier=FAUX */ \
/* */ \
/* afin que les octets non lus ne soient pas ensuite consideres comme des trous... */ \
/* */ \
/* Le 20160520143437, on notera que : */ \
/* */ \
/* SeuilLectureFichier=... */ \
/* */ \
/* permet, par exemple, de visualiser avec 'v $xci/display$K' des fichiers qui ne sont */ \
/* en fait pas des images (et par exemple des images qui auraient ete compressees ; voir */ \
/* par exemple 'v $xrC/CompressionDeCompression_Compression.01$vv$I 20160520143634'). */ \
\
GET_ARGUMENT_L("generation_d_un_nom_relatif_temporaire_____compatibilite_20061226=""compatibilite_20061226=" \
,generation_d_un_nom_relatif_temporaire_____compatibilite_20061226 \
); \
/* Introduit le 20061226105656 et complete le 20090302092640... */ \
GET_ARGUMENT_L("generation_d_un_nom_relatif_temporaire_____compatibilite_20231213=""compatibilite_20231213=" \
,generation_d_un_nom_relatif_temporaire_____compatibilite_20231213 \
); \
/* Introduit le 20231213171956... */ \
\
GET_ARGUMENT_L("ValidMalo=",allocation_memoire_avec_validation_____valider_par_rapport_a_MemorySizeMB); \
/* Introduit le 20120201124742... */ \
GET_ARGUMENT_L("SignalerAbortNonAllocation=""SANA=" \
,allocation_memoire_avec_validation_____signaler_explicitement_l_abort_de_non_allocation \
); \
/* Introduit le 20200727115625... */ \
\
begin_nouveau_block \
Bblock \
DEFV(Int,INIT(temp_allocation_memoire_avec_validation_____Amarge_de_securite \
,allocation_memoire_avec_validation_____Amarge_de_securite \
) \
); \
DEFV(Int,INIT(temp_allocation_memoire_avec_validation_____Bmarge_de_securite \
,allocation_memoire_avec_validation_____Bmarge_de_securite \
) \
); \
/* Ceci a ete introduit le 20051026160342 car, en effet, il est extremement dangereux de */ \
/* modifier ces variables dynamiquement puisque 'Malo(...)' est utilise partout et tout */ \
/* le temps (en particulier ici-meme...). Il faut donc passer par des variables temporaires */ \
/* dont le type est 'Int', contrairement aux "originaux" qui eux sont 'Positive'. C'est */ \
/* seulement apres avoir valide ces valeurs temporaires, qu'elles peuvent etre activees... */ \
/* */ \
/* ATTENTION : ces deux variables temporaires sont referencees explicitement dans */ \
/* 'v $xcc/cpp$Z 20060203092633'. */ \
/* */ \
/* ATTENTION : ces deux variables temporaires sont aussi referencees explicitement dans */ \
/* 'v $xcc/LFonctionR$vv$D/ArgumentsModification$vv$sed'. */ \
\
PROCESS_ARGUMENT_I("AMargeMalo=" \
,temp_allocation_memoire_avec_validation_____Amarge_de_securite \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
Test(IZGT(temp_allocation_memoire_avec_validation_____Amarge_de_securite)) \
Bblock \
EGAL(allocation_memoire_avec_validation_____Amarge_de_securite \
,temp_allocation_memoire_avec_validation_____Amarge_de_securite \
); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("marge 'multiplicative A' de 'Malo(...)' negative ou nulle"); \
CAL1(Prer2("(marge demandee %d et marge courante conservee %d)\n" \
,temp_allocation_memoire_avec_validation_____Amarge_de_securite \
,allocation_memoire_avec_validation_____Amarge_de_securite \
) \
); \
Eblock \
ETes \
Eblock \
) \
); \
PROCESS_ARGUMENT_I("BMargeMalo=" \
,temp_allocation_memoire_avec_validation_____Bmarge_de_securite \
,BLOC(VIDE;) \
,BLOC( \
Bblock \
Test(IZGE(temp_allocation_memoire_avec_validation_____Bmarge_de_securite)) \
Bblock \
EGAL(allocation_memoire_avec_validation_____Bmarge_de_securite \
,temp_allocation_memoire_avec_validation_____Bmarge_de_securite \
); \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("marge 'additive B' de 'Malo(...)' negative"); \
CAL1(Prer2("(marge demandee %d et marge courante conservee %d)\n" \
,temp_allocation_memoire_avec_validation_____Bmarge_de_securite \
,allocation_memoire_avec_validation_____Bmarge_de_securite \
) \
); \
Eblock \
ETes \
Eblock \
) \
); \
/* Introduit le 20041020114836. On notera bien que la valeur alors forcee ne s'appliquera */ \
/* evidemment qu'aux 'Malo(...)' posterieurs et non pas a ceux qui ont deja eu lieu... */ \
/* */ \
/* Le 20051026152349, j'ai introduit en plus de la marge "additive" 'B', une marge */ \
/* "multiplicative" 'A'... */ \
Eblock \
end_nouveau_block \
\
GET_ARGUMENT_L("CheckMalo=",Malo_____valider_si_possible_l_utilisation_de_la_memoire_allouee); \
/* Introduit le 20041023103137... */ \
\
GET_ARGUMENT_F("FffDIVZ_a_peu_pres_____epsilon=",FffDIVZ_a_peu_pres_____epsilon); \
\
GET_ARGUMENT_I("Int_indefini=",Fload_fichier_formatte_Int_____valeur_indefinie); \
GET_ARGUMENT_F("Float_indefini=",Fload_fichier_formatte_Float_____valeur_indefinie); \
/* Le 20000126173913 les valeurs {PETIT_INFINI,F_PETIT_INFINI} ont ete remplacees par les */ \
/* valeurs {ZERO,FZERO} qui semblent plus universels, les structures : */ \
/* */ \
/* GIT_ARGUMENT_I("Int_indefini=",...,PETIT_INFINI); */ \
/* GIT_ARGUMENT_F("Float_indefini=",...,F_PETIT_INFINI); */ \
/* */ \
/* n'ont plus de raison d'etre... */ \
\
GET_ARGUMENTS_DE_CONTROLE_DE_L_ARITHMETIQUE_ETENDUE_DES_NOMBRES_FLOTTANTS; \
/* Introduit le 20050303120845... */ \
\
MARQUEUR________FinParametresGeneraux; \
/* Argument fictif destine a marquer la fin des Parametres Generaux (le 20010420143829) */ \
/* et qui doit imperativement etre le dernier... */ \
\
MARQUEUR________DebutParametresAutomatiques; \
/* Argument fictif destine a marquer le debut des Parametres mis en place Automatiquement */ \
/* (le 20120701120424). */ \
BLOC(VIDE;); \
/* A la date du 20120701124750 il n'y a pas de parametres mis en place automatiquement... */ \
MARQUEUR________FinParametresAutomatiques; \
/* Argument fictif destine a marquer la fin des Parametres mis en place Automatiquement */ \
/* (le 20120701120424). */ \
) \
\
FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____PRIMAIRES; \
\
Eblock \
/* Recuperation de tous les arguments de controle de portee generale. */ \
/* */ \
/* ATTENTION, dans le cas ou une 'liste_de_recuperation' contiendrait elle-meme des */ \
/* elements susceptibles d'utiliser l'un de ces indicateurs, il est alors evident que */ \
/* l'ordre d'apparition des arguments effectifs est significatif. Ainsi, par exemple, */ \
/* le programme 'v $xrv/AXPB.01$K GET_ARGUMENTS_' qui contient dans 'GET_ARGUMENTS_(...)' */ \
/* un 'PRINT_ATTENTION(...)'. Alors : */ \
/* */ \
/* $xrv/AXPB.01$X ne=... (...) DEFAUT=FAUX */ \
/* */ \
/* et : */ \
/* */ \
/* $xrv/AXPB.01$X DEFAUT=FAUX (...) ne=... */ \
/* */ \
/* ne se comporteront pas de la meme facon. Dans le premier cas, 'PRINT_ATTENTION(...)' */ \
/* sera effectif (le message sortira) et ineffectif dans le second cas (le message ne */ \
/* sortira pas...). */ \
/* */ \
/* Dans le meme ordre d'idee, le parametre "Parametres=" ne peut jamais etre edite par */ \
/* lui-meme, ce qui implique que tous les parametres qui le precederaient ne pourraient */ \
/* etre edites, ce qui impose qu'il soit mis en premier... */ \
/* */ \
/* De meme, les options "Int_indefini=" et "Float_indefini=" doivent apparaitre avant que */ \
/* les valeurs ainsi positionnees soient utilisees dans les deux fonctions */ \
/* 'Fload_fichier_formatte_Int(...)' et 'Fload_fichier_formatte_Float(...)'. */
#define VALIDATION_DES_DEMANDES_EVENTUELLES_DE_PREFIXAGE_DE_CERTAINS_PARAMETRES \
Bblock \
Test(IZNE(nombre_de_demandes_effectives_de_PreFixeParametres)) \
Bblock \
Test(IZEQ(nombre_de_parametres_supportant_PreFixeParametres)) \
Bblock \
PRINT_ATTENTION("le prefixage de certains parametres n'a pas d'utilite ici"); \
CAL1(Prer2("il y a eu %d %s de changement du prefixe (via 'PreFixeParametres=' ou 'PFP=')\n" \
,nombre_de_demandes_effectives_de_PreFixeParametres \
,PLURIEL_S("demande",nombre_de_demandes_effectives_de_PreFixeParametres) \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Validation de l'utilite des demandes de prefixage introduite le 20030708094336... */
#define ACTIONS_A_EFFECTUER_SYSTEMATIQUEMENT_AVANT_GET_PARAMETRES(nombre_d_arguments_y_compris_le_nom) \
Bblock \
CALS(FgACTIONS_A_EFFECTUER_SYSTEMATIQUEMENT_AVANT_GET_PARAMETRES()); \
/* Introduit le 20180217183252 afin d'eviter la recompilation des '$K's dans le cas ou */ \
/* des actions nouvelles seraient introduites ici... */ \
\
EGAL(nombre_d_arguments_possibles_regroupes_par_classe_de_synonymes \
,valeur_calculee_par_xcc_cpp_Z_de_____nombre_d_arguments_possibles_regroupes_par_classe_de_synonymes \
); \
/* Introduit le 20081116113229. La valeur attribuee est en fait une "pseudo-variable" */ \
/* calculee par 'v $xccp/cpp$Z VC_NoMbRe_PaRaMeTrEs'... */ \
\
EGAL(entrer_des_parametres_via_des_setenv \
,GvalDefaut("SETENV" \
,GvalDefaut("setenv" \
,entrer_des_parametres_via_des_setenv \
) \
) \
); \
/* Le 20090324182721, j'ai tente d'introduire ici : */ \
/* */ \
/* EGAL(entrer_des_parametres_via_des_setenv */ \
/* ,GvalDefaut("SETENV" */ \
/* ,entrer_des_parametres_via_des_setenv */ \
/* ) */ \
/* ); */ \
/* */ \
/* afin de permettre de "forcer" dans tous les '$X's devant s'executer (par exemple dans */ \
/* un '$Z') le parametre : */ \
/* */ \
/* Environnement=VRAI */ \
/* */ \
/* Cela permettrait, par exemple, d'inhiber globalement la sortie des messages d'erreur, en */ \
/* faisant donc : */ \
/* */ \
/* setenv SETENV $EXIST */ \
/* setenv SETENV_MesNoParam $EXIST */ \
/* */ \
/* setenv P__CAL1 FAUX */ \
/* */ \
/* au prealable... */ \
/* */ \
/* Le 20090421100424, il a fallu introduire de plus la variable '$SETENV_MesNoParam' a */ \
/* cause des '$X's qui sont utilises sans parametres ('v $Falias_direct .xcp.ferme_K_NL.X'). */ \
/* Il faut donc pouvoir inhiber, si besoin est, les messages d'avertissement correspondants. */ \
/* */ \
/* Malheureusement, cela ne marche pas (provisoirement...) a cause des parametres ":=" et */ \
/* "==" qui semblent alors recevoir les valeurs logiques erronees "P__". Ce probleme */ \
/* subsiste si l'on force 'entrer_des_parametres_via_des_setenv' brutalement a 'VRAI'. */ \
/* Je supprime donc cette possibilite jusqu'a nouvel ordre... */ \
/* */ \
/* Le 20090325094302, j'ai compris. Cela vient du fait qu'a cette date, on trouvait dans */ \
/* l'ordre : */ \
/* */ \
/* GET_ARGUMENT_L("SupprimerBlancDeuxPoints="":=",...); */ \
/* GET_ARGUMENT_L("SupprimerBlancEgal=""==",...); */ \
/* */ \
/* via 'GET_ARGUMENTS_DE_CONTROLE_DE_TRAITEMENT_DES_FORMATS_DE_SORTIE', puis plus loin : */ \
/* */ \
/* PROCESS_ARGUMENT_L("setenv=""Environnement=",...); */ \
/* */ \
/* Or lorsque 'EST_VRAI(entrer_des_parametres_via_des_setenv)', le nom des variables */ \
/* d'environnement demande 'MOVE_CARACTERE_NE_DEPLACE_QUE_LES_CARACTERES_ALPHA_NUMERIQUES', */ \
/* d'abord et a la fin 'MOVE_CARACTERE_DEPLACE_TOUS_LES_CARACTERES'. Ainsi, en utilisant : */ \
/* */ \
/* setenv=VRAI */ \
/* */ \
/* le probleme decrit le 20090324182721 ne se manifestait pas car, encore une fois ":=" et */ \
/* "==" etait traites avant le "setenv=VRAI". Mais si 'entrer_des_parametres_via_des_setenv' */ \
/* est force ici a 'VRAI' via le 'GvalDefaut(...)' l'ordre precedent n'est plus verifie : */ \
/* un "setenv=VRAI" est alors en quelque sorte fait avant ":=" et "==". La solution la plus */ \
/* simple est donc de remplacer ":=" et "==" par quelque chose ne contenant que des */ \
/* caracteres alpha-numeriques... */ \
/* */ \
/* On notera que la variable '$setenv' est aussi disponible par symetrie avec ""setenv="... */ \
\
Test(TOUJOURS_FAUX) \
/* Test introduit le 20090422110711. La variable '$SETENV_MesNoParam' n'a plus d'interet, */ \
/* non plus que les 'PRINT_ATTENTION(...)'s, a cette date. Mais je ne veux pas detruire */ \
/* cette sequence, d'ou ce 'Test(...)'... */ \
Bblock \
Test(IFET(EST_VRAI(entrer_des_parametres_via_des_setenv) \
,IFEQ(nombre_d_arguments_y_compris_le_nom,UN) \
) \
) \
/* Test introduit le 20090325102311. En effet, la recuperation des arguments via des */ \
/* 'setenv's est faite lorsque 'IFEQ(numero_d_argument_courant,NUMERO_PREMIER_ARGUMENT)'. */ \
/* Or si la commande courante ne recoit aucun argument, la condition 'IFEQ(...)' precedente */ \
/* n'est jamais remplie et alors aucun argument ne peut donc "rentrer" via des 'setenv's... */ \
Bblock \
Test(EST_VRAI(GvalDefaut("SETENV_MesNoParam",EXIST))) \
/* Test introduit le 20090421100424 car il y a effectivement un certain nombre de '$X's qui */ \
/* sont utilises sans parametres ('v $Falias_direct .xcp.ferme_K_NL.X'). Il faut donc */ \
/* pouvoir inhiber, si besoin est, les messages suivants... */ \
Bblock \
PRINT_ATTENTION("l'une des deux variables '$setenv'/'$SETENV' est positionnee a 'VRAI'"); \
PRINT_ATTENTION("cette commande n'ayant aucun argument : ce positionnement est ici ineffectif"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
INITIALISATIONS_DE_GET_ARGUMENTS_DE_CONTROLE_DE_TRAITEMENT_DES_FORMATS_DE_SORTIE; \
/* Initialisations utiles au traitement des formats de sortie introduit le 20050131105740... */ \
Eblock \
/* Introduit le 20030710091913 pour prevoir des extensions futures... */
#define ACTIONS_A_EFFECTUER_SYSTEMATIQUEMENT_APRES_GET_PARAMETRES \
Bblock \
VALIDATION_DES_DEMANDES_EVENTUELLES_DE_PREFIXAGE_DE_CERTAINS_PARAMETRES; \
/* Validation de l'utilite des demandes de prefixage introduite le 20030708094336... */ \
\
CALS(FgACTIONS_A_EFFECTUER_SYSTEMATIQUEMENT_APRES_GET_PARAMETRES()); \
/* Introduit le 20180217183252 afin d'eviter la recompilation des '$K's dans le cas ou */ \
/* des actions nouvelles seraient introduites ici... */ \
Eblock \
/* Introduit le 20030710091913 pour prevoir des extensions futures... */
#define GET_ARGUMENTS_(nombre_d_arguments_y_compris_le_nom,liste_de_recuperation) \
Bblock \
ACTIONS_A_EFFECTUER_SYSTEMATIQUEMENT_AVANT_GET_PARAMETRES(nombre_d_arguments_y_compris_le_nom); \
/* Actions a effectuer systematiquement apres 'GET_PARAMETRES(...)' introduites le */ \
/* 20030710091913. */ \
\
GET_PARAMETRES(nombre_d_arguments_y_compris_le_nom \
,arguments \
,BLOC(GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE; \
\
MARQUEUR________DebutParametresSpecifiques; \
/* Argument fictif destine a marquer le debut des Parametres Specifiques (20010421090617). */ \
\
BLOC(liste_de_recuperation); \
\
MARQUEUR________FinParametresSpecifiques; \
/* Argument fictif destine a marquer la fin des Parametres Specifiques (20010421090617). */ \
) \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
/* Cette nouvelle option permet d'editer les valeurs des parametres reellement utilises... */ \
/* ATTENTION, pour certaines commandes, et en particulier celles de '$xcp', cette option */ \
/* ne doit pas etre utilisee en temps normal (sa valeur par defaut respecte cette contrainte */ \
/* puisqu'elle vaut 'NE_PAS_EDITER_LES_VALEURS_APRES_Fconversion'). En effet, pour les */ \
/* commandes de type "filtre", la valeur des parametres alors obtenues s'insererait dans */ \
/* le flot des fichiers traites. Malgre cela, pour connaitre la valeur des parametres par */ \
/* defaut des commandes de type "filtre", il suffira de faire par exemple : */ \
/* */ \
/* saut | <commande_de_type_filtre> Parametres=VRAI */ \
/* */ \
/* pour obtenir cette information... */ \
\
ACTIONS_A_EFFECTUER_SYSTEMATIQUEMENT_APRES_GET_PARAMETRES; \
/* Actions a effectuer systematiquement apres 'GET_PARAMETRES(...)' introduites le */ \
/* 20030710091913. */ \
Eblock \
/* Procedure de recuperation d'une liste d'arguments. */
#define ARG__Fmise_a_jour_du_systeme_de_gestion_de_fichiers_____compatibilite_20121025 \
"Fmise_a_jour_du_systeme_de_gestion_de_fichiers_____compatibilite_20121025=""compatibilite_20121025=" \
/* Pour raccourcir une ligne qui va suivre (introduit le 20121025182732)... */ \
/* */ \
/* Le 20140824094534, pour eviter une definition circulaire, 'ARG__' a ete place devant */ \
/* 'Fmise_a_jour_du_systeme_de_gestion_de_fichiers_____compatibilite_20121025'... */
#define GET_ARGUMENTSf(nombre_d_arguments_y_compris_le_nom,liste_de_recuperation) \
/* On notera le nom 'GET_ARGUMENTSf(...)' ne meme longueur que 'GET_ARGUMENTSi(...)' afin */ \
/* de ne pas provoquer de decalages dans les sources '$K' des programmes de '$xciP' le */ \
/* 19981202094102 lors de leur mise a jour... */ \
Bblock \
ACTIONS_A_EFFECTUER_SYSTEMATIQUEMENT_AVANT_GET_PARAMETRES(nombre_d_arguments_y_compris_le_nom); \
/* Actions a effectuer systematiquement apres 'GET_PARAMETRES(...)' introduites le */ \
/* 20030710091913. */ \
\
GET_PARAMETRES(nombre_d_arguments_y_compris_le_nom \
,arguments \
,BLOC(GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE; \
\
MARQUEUR________DebutParametresImages; \
/* Argument fictif destine a marquer le debut des Parametres Generaux de nature "Image" */ \
/* (le 20020626162809) et qui doit imperativement etre le premier... */ \
\
GET_ARGUMENT_F("EpsilonLissageSubstitution=",epsilon_de_LISSAGE_LISTE_DE_SUBSTITUTION); \
/* Cet argument a ete introduit le 20040910131944, principalement a cause de */ \
/* 'v $xiii/Images$DEF LISSAGE_LISTE_DE_SUBSTITUTION' qui est utilise par la commande */ \
/* 'v $xciP/LISSE$K GET_ARGUMENTSf'. Cela a mis en evidence le fait qu'en general : */ \
/* */ \
/* __DENORMALISE_NIVEAU(______NORMALISE_NIVEAU(niveau)) # niveau */ \
/* */ \
/* et meme : */ \
/* */ \
/* __DENORMALISE_NIVEAU(______NORMALISE_NIVEAU(niveau)) < niveau */ \
/* */ \
/* Cela a donc des consequences ennuyeuses dans 'v $xigP/.INTERPOLE$Y .xciP/LISSE.X' */ \
/* ce qui s'est manifeste a cette date dans 'v $xigP/gris.52.1$Z'. */ \
\
GET_ARGUMENT_L("Dpipe_Iload_fichier=",Iload_fichier_____tester_le_debordement_du_pipe); \
/* Afin de pouvoir ne pas tester le debordement des pipes dans 'Iload_fichier(...)' alors */ \
/* qu'il est teste par defaut et provoque une erreur. Ceci a ete introduit le 19980520185424 */ \
/* pour etre utilise dans des programmes tels 'v $xci/Sdisplay_RVB$K' qui peuvent recevoir */ \
/* des triplets d'images {$ROUGE,$VERTE,$BLEUE}, ou encore 'v $xciP/S_NIVEAU$K' qui peut */ \
/* transmettre des triplets de palettes {$ROUGE,$VERTE,$BLEUE}. Une autre application a */ \
/* ete decouverte le 20001213125231 ; elle permet a un programme producteur d'une serie */ \
/* d'images (par exemple '$xci/Ising_2D.11$X') de communiquer ses resultats a un programme */ \
/* consommateur d'images (par exemple '$xci/sequence$X' qui visualise ainsi "en direct"). */ \
\
\
GET_ARGUMENT_L(ARG__Fmise_a_jour_du_systeme_de_gestion_de_fichiers_____compatibilite_20121025 \
,Fmise_a_jour_du_systeme_de_gestion_de_fichiers_____compatibilite_20121025 \
); \
/* Introduit le 20121025182732... */ \
GET_ARGUMENT_L("ErreurLecture=" \
,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers \
); \
/* L'acces a cet argument a ete introduit le 20020626162809 (il etait inaccessible avant). */ \
\
MARQUEUR________FinParametresImages; \
/* Argument fictif destine a marquer la fin des Parametres Generaux de nature "Image" */ \
/* (le 20020626162809) et qui doit imperativement etre le dernier... */ \
\
MARQUEUR________DebutParametresSpecifiques; \
/* Argument fictif destine a marquer le debut des Parametres Specifiques (20010421090617). */ \
\
BLOC(liste_de_recuperation); \
\
MARQUEUR________FinParametresSpecifiques; \
/* Argument fictif destine a marquer la fin des Parametres Specifiques (20010421090617). */ \
) \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
\
ACTIONS_A_EFFECTUER_SYSTEMATIQUEMENT_APRES_GET_PARAMETRES; \
/* Actions a effectuer systematiquement apres 'GET_PARAMETRES(...)' introduites le */ \
/* 20030710091913. */ \
Eblock \
/* Procedure de recuperation d'une liste d'arguments specifique aux programmes de '$xciP'. */ \
/* Le 19981202094102, la procedure 'GET_ARGUMENTSif(...)' a ete introduite afin que le */ \
/* parametre 'Iload_fichier_____tester_le_debordement_du_pipe' soit utilisable dans des */ \
/* programmes tels 'v $xciP/S_NIVEAU$K' qui n'utilisaient par 'GET_ARGUMENTSi(...)' mais */ \
/* 'GET_ARGUMENTS_(...)'... */
#define ENTREE_ARGUMENT_pasX \
"px="
#define ENTREE_ARGUMENT_pasY \
"py="
#define ENTREE_ARGUMENTS_pasX_pasY \
Bblock \
GET_ARGUMENT_I(ENTREE_ARGUMENT_pasX,pasX); \
GET_ARGUMENT_I(ENTREE_ARGUMENT_pasY,pasY); \
Eblock
#define ENTREE_ARGUMENT_translationX \
"tx="
#define ENTREE_ARGUMENT_translationY \
"ty="
/* Entree des ARGUMENTs {pasX,pasY}. */
/* */
/* Ne pas oublier 'v $xiii/Images$DEF ENTREE_ARGUMENT_translation' (le 20170713094944)... */
#ifndef __VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI
/* Introduit le 20170712134325... */
# define ENTREE_ARGUMENTS_translationX_translationY \
Bblock \
GET_ARGUMENT_I(ENTREE_ARGUMENT_translationX,translationX); \
GET_ARGUMENT_I(ENTREE_ARGUMENT_translationY,translationY); \
Eblock
/* Entree des ARGUMENTs {translationX,translationY}. */
#Aifndef __VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI
# define ENTREE_ARGUMENTS_translationX_translationY \
Bblock \
GET_ARGUMENT_E(ENTREE_ARGUMENT_translationX,translationX); \
GET_ARGUMENT_E(ENTREE_ARGUMENT_translationY,translationY); \
/* Malgre '__VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI', les arguments {"tx=","ty="} */ \
/* sont ici definis afin de les "bloquer" de facon a ce qu'aucun '$K's ne les definissent */ \
/* avec un autre sens... */ \
Eblock
#Eifndef __VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI
#ifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_01
# define INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi \
Bblock \
/* Rien a faire car, en effet, c'est le mode implicite... */ \
Eblock \
/* Initialisation du format des images en mode 'Std'. */
#Aifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_01
#Eifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_01
#ifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_02
# define INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi \
Bblock \
SET_DIMENSIONS_2D_SANS_VALIDATION(XminPal,XmaxPal,YminPal,YmaxPal); \
Eblock \
/* Initialisation du format des images en mode 'Pal'. */
#Aifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_02
#Eifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_02
#ifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_03
# define INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi \
Bblock \
SET_DIMENSIONS_2D_SANS_VALIDATION(GvalDefaut("Xmin",XminPal) \
,GvalDefaut("Xmax",XmaxPal) \
,GvalDefaut("Ymin",YminPal) \
,GvalDefaut("Ymax",YmaxPal) \
); \
Eblock \
/* Initialisation du format des images en utilisant les variables d'environnement */ \
/* {{$Xmin,$Xmax},{$Ymin,$Ymax}} (introduit le 20020126150829). */
#Aifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_03
#Eifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_03
#ifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_04
# define INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi \
Bblock \
SET_DIMENSIONS_3D_SANS_VALIDATION(GvalDefaut("Xmin",XminPal) \
,GvalDefaut("Xmax",XmaxPal) \
,GvalDefaut("Ymin",YminPal) \
,GvalDefaut("Ymax",YmaxPal) \
,GvalDefaut("Zmin",k___Zmin) \
,GvalDefaut("Zmax",k___Zmax) \
); \
Eblock \
/* Initialisation du format des images en utilisant les variables d'environnement */ \
/* {{$Xmin,$Xmax},{$Ymin,$Ymax},{$Zmin,$Zmax}} (introduit le 20020212154742). */
#Aifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_04
#Eifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_04
#ifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_05
# define INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi \
Bblock \
SET_DIMENSIONS_2D(GvalDefaut("Xmin",XminPal) \
,GvalDefaut("Xmax",XmaxPal) \
,GvalDefaut("Ymin",YminPal) \
,GvalDefaut("Ymax",YmaxPal) \
); \
Eblock \
/* Initialisation du format des images en utilisant les variables d'environnement */ \
/* {{$Xmin,$Xmax},{$Ymin,$Ymax}} (introduit le 20020213100517). */
#Aifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_05
#Eifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_05
#ifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_06
# define INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi \
Bblock \
SET_DIMENSIONS_3D(GvalDefaut("Xmin",XminPal) \
,GvalDefaut("Xmax",XmaxPal) \
,GvalDefaut("Ymin",YminPal) \
,GvalDefaut("Ymax",YmaxPal) \
,GvalDefaut("Zmin",k___Zmin) \
,GvalDefaut("Zmax",k___Zmax) \
); \
Eblock \
/* Initialisation du format des images en utilisant les variables d'environnement */ \
/* {{$Xmin,$Xmax},{$Ymin,$Ymax},{$Zmin,$Zmax}} (introduit le 20020213100517). */
#Aifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_06
#Eifdef INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi_VERSION_06
#define AVERTIR_EN_CAS_DE_COORDONNEES_X_DENORMALISEES_HORS_D_UN_CARRE(coordonnees_dans_un_carre,coordonnees_normalisees) \
Bblock \
Test(IFET(EST_VRAI(coordonnees_dans_un_carre) \
,EST_FAUX(coordonnees_normalisees) \
) \
) \
Bblock \
PRINT_ATTENTION("les 'X' denormalisees ne seront pas utilisables en mode 'carre' des champs 3D"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Validation introduite le 20060607175331... */
#define AVERTIR_EN_CAS_DE_COORDONNEES_Y_DENORMALISEES_HORS_D_UN_CARRE(coordonnees_dans_un_carre,coordonnees_normalisees) \
Bblock \
Test(IFET(EST_VRAI(coordonnees_dans_un_carre) \
,EST_FAUX(coordonnees_normalisees) \
) \
) \
Bblock \
PRINT_ATTENTION("les 'Y' denormalisees ne seront pas utilisables en mode 'carre' des champs 3D"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Validation introduite le 20060607175331... */
#define ARG__AXE_NIVEAUX_OUVERT_FERME_____COMPATIBILITE_19951221 \
"AXE_NIVEAUX_OUVERT_FERME_____compatibilite_19951221=""compatibilite_19951221=""compatibilite_20091015=" \
/* Introduit le 20101020110921 afin de raccourcir la longueur d'une ligne a venir, le */ \
/* nouvel argment "compatibilite_20091015=" rappelant 'v $xiii/Images$STR 20091015174102'. */ \
/* */ \
/* Le 20140824093631 "NIVEAUX_____compatibilite_19951221=" ainsi que */ \
/* "NIVEAUX_____compatibilite_20091015=" ont ete reduits pour des raisons d'encombrement... */
#define ACTIONS_A_EFFECTUER_POUR_LA_GESTION_DE_LA_NORMALISATION_DES_COORDONNEES \
Bblock \
/* Nota : le gestion de la "super-echelle" a ete introduite le 20060118094518 car, en */ \
/* effet, je me suis rendu compte a cette date que de plus en plus de programmes */ \
/* utilisaient ce dispositif... */ \
\
DEBUT_D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
GET_ARGUMENTS2_F("cXmin=""lXmin=" \
,f____cNORMALISE_OX_____borne_inferieure \
,f____lNORMALISE_OX_____borne_inferieure \
); \
GET_ARGUMENTS2_F("cXmax=""lXmax=" \
,f____cNORMALISE_OX_____borne_superieure \
,f____lNORMALISE_OX_____borne_superieure \
); \
GET_ARGUMENTS2_F("cYmin=""lYmin=" \
,f____cNORMALISE_OY_____borne_inferieure \
,f____lNORMALISE_OY_____borne_inferieure \
); \
GET_ARGUMENTS2_F("cYmax=""lYmax=" \
,f____cNORMALISE_OY_____borne_superieure \
,f____lNORMALISE_OY_____borne_superieure \
); \
GET_ARGUMENTS2_F("cZmin=""lZmin=" \
,f____cNORMALISE_OZ_____borne_inferieure \
,f____lNORMALISE_OZ_____borne_inferieure \
); \
GET_ARGUMENTS2_F("cZmax=""lZmax=" \
,f____cNORMALISE_OZ_____borne_superieure \
,f____lNORMALISE_OZ_____borne_superieure \
); \
/* Introduits le 20120323075041... */ \
\
PROCESS_ARGUMENT_L("rectangulaire=" \
,super_echelle_____utiliser_le_mode_rectangulaire \
,BLOC(VIDE;) \
,BLOC(Bblock \
CHOIX_DE_LA_SUPER_ECHELLE(NEUL(super_echelle_____utiliser_le_mode_rectangulaire) \
,NEUL(super_echelle_____utiliser_le_mode_carre__grand_carre) \
); \
Eblock \
) \
); \
PROCESS_ARGUMENT_N("carree=""carre=" \
,super_echelle_____utiliser_le_mode_rectangulaire \
,BLOC(VIDE;) \
,BLOC(Bblock \
CHOIX_DE_LA_SUPER_ECHELLE(NOTL(super_echelle_____utiliser_le_mode_rectangulaire) \
,NEUL(super_echelle_____utiliser_le_mode_carre__grand_carre) \
); \
/* L'usage de 'NOTL(...)' est du a celui de 'PROCESS_ARGUMENT_N(...)' car, en effet, lorsque */ \
/* 'CHOIX_DE_LA_SUPER_ECHELLE(...)' est execute, le parametre logique en cours de traitement */ \
/* est alors inverse ('v $xig/fonct$vv$DEF NOTL.valeur_L_par_defaut'). Evidemment ce */ \
/* 'NOTL(...)' ne porte que sur 'super_echelle_____utiliser_le_mode_rectangulaire' qui est */ \
/* le parametre qui est en train de faire l'objet du 'PROCESS_ARGUMENT_N(...)', alors que */ \
/* 'super_echelle_____utiliser_le_mode_carre__grand_carre' est un indicateur que l'on ne */ \
/* fait que tester ici (via 'CHOIX_DE_LA_SUPER_ECHELLE(...)') et qui ne fait donc que */ \
/* l'objet d'un 'NEUL(...)'... */ \
Eblock \
) \
); \
PROCESS_ARGUMENT_L("grand_carre=" \
,super_echelle_____utiliser_le_mode_carre__grand_carre \
,BLOC(VIDE;) \
,BLOC(Bblock \
CHOIX_DE_LA_SUPER_ECHELLE(NEUL(super_echelle_____utiliser_le_mode_rectangulaire) \
,NEUL(super_echelle_____utiliser_le_mode_carre__grand_carre) \
); \
Eblock \
) \
); \
PROCESS_ARGUMENT_N("petit_carre=" \
,super_echelle_____utiliser_le_mode_carre__grand_carre \
,BLOC(VIDE;) \
,BLOC(Bblock \
CHOIX_DE_LA_SUPER_ECHELLE(NEUL(super_echelle_____utiliser_le_mode_rectangulaire) \
,NOTL(super_echelle_____utiliser_le_mode_carre__grand_carre) \
); \
/* L'usage de 'NOTL(...)' est du a celui de 'PROCESS_ARGUMENT_N(...)' car, en effet, lorsque */ \
/* 'CHOIX_DE_LA_SUPER_ECHELLE(...)' est execute, le parametre logique en cours de traitement */ \
/* est alors inverse ('v $xig/fonct$vv$DEF NOTL.valeur_L_par_defaut'). */ \
Eblock \
) \
); \
\
/* Nota : le gestion de la "super-echelle" a ete introduite le 20060118094518 car, en */ \
/* effet, je me suis rendu compte a cette date que de plus en plus de programmes */ \
/* utilisaient ce dispositif... */ \
\
PROCESS_ARGUMENT_L("carre_X_CHAMP_3D=" \
,ACCES_A_LA_COORDONNEE_X_D_UN_CHAMP_3D_____coordonnees_dans_un_carre \
,BLOC(VIDE;) \
,BLOC(Bblock \
AVERTIR_EN_CAS_DE_COORDONNEES_X_DENORMALISEES_HORS_D_UN_CARRE \
(NEUL(ACCES_A_LA_COORDONNEE_X_D_UN_CHAMP_3D_____coordonnees_dans_un_carre) \
,NEUL(ACCES_A_LA_COORDONNEE_X_D_UN_CHAMP_3D_____coordonnees_normalisees) \
); \
Eblock \
) \
); \
PROCESS_ARGUMENT_L("carre_Y_CHAMP_3D=" \
,ACCES_A_LA_COORDONNEE_Y_D_UN_CHAMP_3D_____coordonnees_dans_un_carre \
,BLOC(VIDE;) \
,BLOC(Bblock \
AVERTIR_EN_CAS_DE_COORDONNEES_Y_DENORMALISEES_HORS_D_UN_CARRE \
(NEUL(ACCES_A_LA_COORDONNEE_Y_D_UN_CHAMP_3D_____coordonnees_dans_un_carre) \
,NEUL(ACCES_A_LA_COORDONNEE_Y_D_UN_CHAMP_3D_____coordonnees_normalisees) \
); \
Eblock \
) \
); \
/* Introduit le 20041107135519 afin de pouvoir garantir, par exemple, de generer une periode */ \
/* d'un sinus le long de 'dimX' et 'dimY' dans 'v $xci/sinus$K GENERATION_DU_CHAMP_DEMANDE'. */ \
GET_ARGUMENT_L("carre_X_CHAMP_3D_____compatibilite_20061128=" \
,ACCES_A_LA_COORDONNEE_X_D_UN_CHAMP_3D_____compatibilite_20061128 \
); \
GET_ARGUMENT_L("carre_Y_CHAMP_3D_____compatibilite_20061128=" \
,ACCES_A_LA_COORDONNEE_Y_D_UN_CHAMP_3D_____compatibilite_20061128 \
); \
/* Introduit le 20061128143333 afin de pouvoir garantir la compatibilite anterieure, si */ \
/* besoin est... */ \
GET_ARGUMENT_L("carre_X_CHAMP_3D_____compatibilite_20100210=" \
,ACCES_A_LA_COORDONNEE_X_D_UN_CHAMP_3D_____compatibilite_20100210 \
); \
GET_ARGUMENT_L("carre_Y_CHAMP_3D_____compatibilite_20100210=" \
,ACCES_A_LA_COORDONNEE_Y_D_UN_CHAMP_3D_____compatibilite_20100210 \
); \
/* Introduit le 20100210104418 afin de pouvoir garantir la compatibilite anterieure, si */ \
/* besoin est... */ \
\
GET_ARGUMENT_L \
("AXES_COORDONNEES_FERMES_OUVERTS_____compatibilite_20090929=""COORDONNEES_____compatibilite_20090929=" \
,AXES_COORDONNEES_FERMES_OUVERTS_____compatibilite_20090929 \
); \
/* Introduit le 20090929094249 afin de pouvoir garantir la compatibilite anterieure, si */ \
/* besoin est... */ \
GET_ARGUMENT_L(ARG__AXE_NIVEAUX_OUVERT_FERME_____COMPATIBILITE_19951221 \
,AXE_NIVEAUX_OUVERT_FERME_____compatibilite_19951221 \
); \
/* Introduit le 20091015111748 afin de pouvoir garantir la compatibilite anterieure, si */ \
/* besoin est... */ \
/* */ \
/* Le 20091015174057, "compatibilite_20091015" a ete change en "compatibilite_19951221" */ \
/* la date "19951221" etant approximative et resultat d'un 'retrouva $xiiD/definit.2$DEF' */ \
/* en choisissant la plus ancienne archive utilisant 'BLANC' et non plus 'COULEURS', */ \
/* c'est-a-dire finalement la premiere... */ \
\
PROCESS_ARGUMENT_L("X_CHAMP_3D_normalisee=" \
,ACCES_A_LA_COORDONNEE_X_D_UN_CHAMP_3D_____coordonnees_normalisees \
,BLOC(VIDE;) \
,BLOC(Bblock \
AVERTIR_EN_CAS_DE_COORDONNEES_X_DENORMALISEES_HORS_D_UN_CARRE \
(NEUL(ACCES_A_LA_COORDONNEE_X_D_UN_CHAMP_3D_____coordonnees_dans_un_carre) \
,NEUL(ACCES_A_LA_COORDONNEE_X_D_UN_CHAMP_3D_____coordonnees_normalisees) \
); \
Eblock \
) \
); \
PROCESS_ARGUMENT_N("X_CHAMP_3D_denormalisee=" \
,ACCES_A_LA_COORDONNEE_X_D_UN_CHAMP_3D_____coordonnees_normalisees \
,BLOC(VIDE;) \
,BLOC(Bblock \
AVERTIR_EN_CAS_DE_COORDONNEES_X_DENORMALISEES_HORS_D_UN_CARRE \
(NEUL(ACCES_A_LA_COORDONNEE_X_D_UN_CHAMP_3D_____coordonnees_dans_un_carre) \
,NOTL(ACCES_A_LA_COORDONNEE_X_D_UN_CHAMP_3D_____coordonnees_normalisees) \
); \
/* L'usage de 'NOTL(...)' est du a celui de 'PROCESS_ARGUMENT_N(...)' car, en effet, */ \
/* lorsque 'AVERTIR_EN_CAS_DE_COORDONNEES_X_DENORMALISEES_HORS_D_UN_CARRE(...)' est */ \
/* execute, le parametre logique en cours de traitement est alors inverse */ \
/* ('v $xig/fonct$vv$DEF NOTL.valeur_L_par_defaut'). */ \
Eblock \
) \
); \
PROCESS_ARGUMENT_L("Y_CHAMP_3D_normalisee=" \
,ACCES_A_LA_COORDONNEE_Y_D_UN_CHAMP_3D_____coordonnees_normalisees \
,BLOC(VIDE;) \
,BLOC(Bblock \
AVERTIR_EN_CAS_DE_COORDONNEES_Y_DENORMALISEES_HORS_D_UN_CARRE \
(NEUL(ACCES_A_LA_COORDONNEE_Y_D_UN_CHAMP_3D_____coordonnees_dans_un_carre) \
,NEUL(ACCES_A_LA_COORDONNEE_Y_D_UN_CHAMP_3D_____coordonnees_normalisees) \
); \
Eblock \
) \
); \
PROCESS_ARGUMENT_N("Y_CHAMP_3D_denormalisee=" \
,ACCES_A_LA_COORDONNEE_Y_D_UN_CHAMP_3D_____coordonnees_normalisees \
,BLOC(VIDE;) \
,BLOC(Bblock \
AVERTIR_EN_CAS_DE_COORDONNEES_Y_DENORMALISEES_HORS_D_UN_CARRE \
(NEUL(ACCES_A_LA_COORDONNEE_Y_D_UN_CHAMP_3D_____coordonnees_dans_un_carre) \
,NOTL(ACCES_A_LA_COORDONNEE_Y_D_UN_CHAMP_3D_____coordonnees_normalisees) \
); \
/* L'usage de 'NOTL(...)' est du a celui de 'PROCESS_ARGUMENT_N(...)' car, en effet, */ \
/* lorsque 'AVERTIR_EN_CAS_DE_COORDONNEES_X_DENORMALISEES_HORS_D_UN_CARRE(...)' est */ \
/* execute, le parametre logique en cours de traitement est alors inverse */ \
/* ('v $xig/fonct$vv$DEF NOTL.valeur_L_par_defaut'). */ \
Eblock \
) \
); \
/* Introduits le 20060607175331... */ \
\
FIN___D_IMBRICATION_DES_____gPROCESS_PARAMETRE_____SECONDAIRES; \
\
Eblock \
/* Introduit le 20060118095058... */
#if ( (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_01)) \
)
# define GET_ARGUMENTSi(nombre_d_arguments_y_compris_le_nom,liste_de_recuperation) \
Bblock \
DEFV(Logical,INIT(le_format_des_images_a_ete_defini,VRAI)); \
/* Le format des images etant immuable en 'GESTION_DU_FORMAT_DES_IMAGES_VERSION_01' on fait */ \
/* comme si les definitions avaient ete deja rencontrees... */ \
\
ACTIONS_A_EFFECTUER_SYSTEMATIQUEMENT_AVANT_GET_PARAMETRES(nombre_d_arguments_y_compris_le_nom); \
/* Actions a effectuer systematiquement apres 'GET_PARAMETRES(...)' introduites le */ \
/* 20030710091913. */ \
\
GET_PARAMETRES(nombre_d_arguments_y_compris_le_nom \
,arguments \
,BLOC(GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE; \
\
MARQUEUR________DebutParametresImages; \
/* Argument fictif destine a marquer le debut des Parametres Generaux de nature "Image" */ \
/* (le 20010420143829) et qui doit imperativement etre le premier... */ \
\
ENTREE_ARGUMENTS_pasX_pasY; \
ENTREE_ARGUMENTS_translationX_translationY; \
/* A cause de '__VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI', cette forme "compacte" a ete */ \
/* introduite le 20170712135356... */ \
\
GET_ARGUMENT_L("UniquementSubstitutions=""us=",ne_faire_que_les_substitutions); \
GET_ARGUMENT_L("EtatFiltrageNiveaux=""efn=",etat_Filtrage_niveaux); \
GET_ARGUMENT_I("CodeCombinaisonNiveaux=""ccn=" \
,Fcombinaison_universelle_de_deux_niveaux_____code \
); \
GET_ARGUMENT_F("PonderationCombinaisonNiveaux=""pcn=" \
,FBARY_____ponderation_de_la_fonction \
); \
/* Introduit le 20170715093935 afin de controler l'ecriture des points. Ainsi, si l'on veut */ \
/* que lors de l'ecriture d'un point, il y ait combinaison d'une certaine facon avec la */ \
/* valeur anterieure, il faudra activer le dispositif en faisant : */ \
/* */ \
/* UniquementSubstitutions=FAUX */ \
/* EtatFiltrageNiveaux=VRAI */ \
/* */ \
/* en choisissant le mode de combinaison avec ('v $xiipf/fonction.2$DEF code_FVARIABLE') : */ \
/* */ \
/* CodeCombinaisonNiveaux=1 FNEUTRE1 */ \
/* =2 FNEUTRE2 */ \
/* =3 FNEUTRE */ \
/* =4 FADD */ \
/* =5 FBARY */ \
/* =6 FMOYENNE */ \
/* =7 FSUB */ \
/* =8 FMUL */ \
/* =10 FDIV */ \
/* =11 FMAX */ \
/* =12 FMIN */ \
/* =13 FMINMAX */ \
/* =14 FOR */ \
/* =15 FAND */ \
/* =16 FEOR */ \
/* */ \
/* avec, si besoin est : */ \
/* */ \
/* PonderationCombinaisonNiveaux=... */ \
/* */ \
\
GET_ARGUMENT_F("EpsilonAxes=",DENORMALISE_AXES_____epsilon); \
GET_ARGUMENT_F("EpsilonNiveaux=",GENP_____epsilon_des_fonctions_de_ce_type); \
GET_ARGUMENT_F("EpsilonLissageSubstitution=",epsilon_de_LISSAGE_LISTE_DE_SUBSTITUTION); \
/* Definition du format des images. On notera la presence de deux listes de recuperation */ \
/* afin de pouvoir gerer l'indicateur 'le_format_des_images_a_ete_defini' correctement... */ \
/* 'Xmin', 'Xmax',... sont recuperes en premiers, au cas ou leur "vraie" valeur serait */ \
/* necessaire dans 'BLOC(liste_de_recuperation)', par exemple dans des normalisations ou */ \
/* des denormalisations (voir le cas des 'GIT_ARGUMENT_X(...)'). ATTENTION : dans un tel */ \
/* cas, leur utilisation est faite avant de les valider dans les tests qui suivent... */ \
/* */ \
/* Je note le 20160708092557 que si l'on souhaite sous-echantillonner une image, etant */ \
/* donnee l'existence des parametres 'NE_PAS_FORCER_L_INDEXATION_SIMPLIFIEE_A_PRIORI' et */ \
/* '__VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI', le plus simple et le plus sur est d'utiliser */ \
/* d'une part : */ \
/* */ \
/* px=... py=... */ \
/* */ \
/* pour n'atteindre qu'un point sur N ('pasX' et 'pasY' etant references explicitement et */ \
/* inconditionnellement dans les definitions du type 'v $xiii/begin_end$DEF begin_ligne') */ \
/* et d'autre part : */ \
/* */ \
/* Xmin=... Xmax=... Ymin=... Ymax=... */ \
/* */ \
/* pour faire une translation de la grille de sous-echantillonnage (ici aussi, 'Xmin', */ \
/* 'Xmax', 'Ymin' et 'Ymax' etant references explicitement et inconditionnellement dans */ \
/* les definitions du type 'v $xiii/begin_end$DEF begin_ligne')... */ \
\
ACTIONS_A_EFFECTUER_POUR_LA_GESTION_DE_LA_NORMALISATION_DES_COORDONNEES; \
/* Introduit le 20060118095058... */ \
\
GET_ARGUMENT_L("Progression=",begin_end_____editer_la_progression); \
GET_ARGUMENT_I("PasProgression=",begin_end_____pas_d_edition_de_la_progression); \
/* Afin de pouvoir voir eventuellement la progression des parcours d'images... */ \
/* */ \
/* Je rappelle le 20190311100351 que c'est en general (toujours ?) {$Zmin,$Zmax} et non */ \
/* pas '$formatI' qui conditionnent l'edition de la progression si elle est demandee... */ \
\
GET_ARGUMENT_P("load_niveau_hors_image=""lnhi=",Niveau____hors_image); \
GET_ARGUMENT_P("load_niveau_hors_album=""lnha=",Niveau____hors_album); \
/* Ces arguments ont ete introduits le 20070213145252. */ \
\
\
GET_ARGUMENT_L \
(ARG__Fmise_a_jour_du_systeme_de_gestion_de_fichiers_____compatibilite_20121025 \
,Fmise_a_jour_du_systeme_de_gestion_de_fichiers_____compatibilite_20121025 \
); \
/* Introduit le 20121025182732... */ \
\
GET_ARGUMENT_L("Dpipe_Iload_fichier=",Iload_fichier_____tester_le_debordement_du_pipe); \
/* Afin de pouvoir ne pas tester le debordement des pipes dans 'Iload_fichier(...)' alors */ \
/* qu'il est teste par defaut et provoque une erreur. Ceci a ete introduit le 19980520185424 */ \
/* pour etre utilise dans des programmes tels 'v $xci/Sdisplay_RVB$K' qui peuvent recevoir */ \
/* des triplets d'images {$ROUGE,$VERTE,$BLEUE}, ou encore 'v $xciP/S_NIVEAU$K' qui peut */ \
/* transmettre des triplets de palettes {$ROUGE,$VERTE,$BLEUE}... */ \
GET_ARGUMENT_L("ErreurLecture=" \
,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers \
); \
/* L'acces a cet argument a ete introduit le 20020626102936 (il etait inaccessible avant). */ \
\
GET_ARGUMENT_L("erreur_nom_absent_Iload_image=""enaIl=" \
,Iload_image_____un_nom_absent_est_une_erreur \
); \
GET_ARGUMENT_L("erreur_nom_absent_Iacces_image=""enaIa=" \
,Iacces_image_____un_nom_absent_est_une_erreur \
); \
GET_ARGUMENT_L("erreur_nom_absent_IloadF_image=""enaIlF=" \
,IloadF_image_____un_nom_absent_est_une_erreur \
); \
/* Afin de pouvoir autoriser des noms absents (sans que cela soit une erreur...). Cela fut */ \
/* introduit le 20080212100203 (principalement pour 'v $xci/somExt_02.01$K IloadF_image' */ \
/* qui recoit de tres nombreuses 'imageF' comme Arguments...). */ \
\
GET_ARGUMENT_L("convert_Iload_image=""cIl=" \
,Iload_image_____tenter_les_conversions_de_nom \
); \
GET_ARGUMENT_L("convert_Iacces_image=""cIa=" \
,Iacces_image_____tenter_les_conversions_de_nom \
); \
GET_ARGUMENT_L("convert_IloadF_image=""cIlF=" \
,IloadF_image_____tenter_les_conversions_de_nom \
); \
/* Afin de pouvoir convertir des noms en valeurs numeriques (etat par defaut...). */ \
\
GET_ARGUMENT_P("valeur_error_Iload_image=""valeur_erreur_Iload_image=""veIl=" \
,Iload_image_____valeur_initiale_si_erreur \
); \
GET_ARGUMENT_P("valeur_error_Iacces_image=""valeur_erreur_Iacces_image=""veIa=" \
,Iacces_image_____valeur_initiale_si_erreur \
); \
GET_ARGUMENT_F("valeur_error_IloadF_image=""valeur_erreur_IloadF_image=""veIlF=" \
,IloadF_image_____valeur_initiale_si_erreur \
); \
/* Ces arguments ont ete introduits le 20021004151854. */ \
\
GET_ARGUMENT_L("convertir_si_erreur_Iload_image=""cseIl=" \
,Iload_image_____tenter_une_conversion_standard_en_cas_d_erreur \
); \
GET_ARGUMENT_L("conversion_avec_renormalisation_si_erreur_Iload_image=""crseIl=" \
,Iload_image_____faire_la_conversion_standard_avec_renormalisation \
); \
GET_ARGUMENT_N("conversion_brutale_si_erreur_Iload_image=""cbseIl=" \
,Iload_image_____faire_la_conversion_standard_avec_renormalisation \
); \
/* Ces arguments ont ete introduits le 20080916174849 et modifies le 20080917104757... */ \
\
GET_ARGUMENT_L("convertir_si_erreur_IloadF_image=""cseIlF=" \
,IloadF_image_____tenter_une_conversion_standard_en_cas_d_erreur \
); \
GET_ARGUMENT_F("niveau_minimal_si_erreur_IloadF_image=""nmseIlF=" \
,IloadF_image_____niveau_minimal_lors_d_une_conversion_standard \
); \
GET_ARGUMENT_F("niveau_maximal_si_erreur_IloadF_image=""nMseIlF=" \
,IloadF_image_____niveau_maximal_lors_d_une_conversion_standard \
); \
/* Ces arguments ont ete introduits le 20080916135822. */ \
\
GET_ARGUMENT_L("valider_IloadF_image=""vIlF=" \
,IloadF_image_____valider_les_genere_Float \
); \
GET_ARGUMENT_F("seuil_inferieur_IloadF_image=""siIlF=" \
,IloadF_image_____seuil_inferieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_epsilon_IloadF_image=""seIlF=" \
,IloadF_image_____seuil_epsilon___de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_superieur_IloadF_image=""ssIlF=" \
,IloadF_image_____seuil_superieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_L("editer_niveaux_invalides_IloadF_image=""eniIlF=" \
,IloadF_image_____editer_les_niveaux_invalides \
); \
/* Ces arguments ont ete introduits le 20030211092913 et completes le 20030301095032. */ \
\
GET_ARGUMENT_L("valider_IloadJ_image=""vIlJ=" \
,IloadJ_image_____valider_les_genere_Float \
); \
GET_ARGUMENT_F("seuil_inferieur_IloadJ_image=""siIlJ=" \
,IloadJ_image_____seuil_inferieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_epsilon_IloadJ_image=""seIlJ=" \
,IloadJ_image_____seuil_epsilon___de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_superieur_IloadJ_image=""ssIlJ=" \
,IloadJ_image_____seuil_superieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_L("editer_niveaux_invalides_IloadJ_image=""eniIlJ=" \
,IloadJ_image_____editer_les_niveaux_invalides \
); \
/* Ces arguments ont ete introduits le 20030211092913 et completes le 20030301095032. */ \
\
GET_ARGUMENT_L("valider_IloadF_image_and_delete=""vIlFd=" \
,IloadF_image_and_delete_____valider_les_genere_Float \
); \
GET_ARGUMENT_F("seuil_inferieur_IloadF_image_and_delete=""siIlFd=" \
,IloadF_image_and_delete_____seuil_inferieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_epsilon_IloadF_image_and_delete=""seIlFd=" \
,IloadF_image_and_delete_____seuil_epsilon___de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_superieur_IloadF_image_and_delete=""ssIlFd=" \
,IloadF_image_and_delete_____seuil_superieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_L("editer_niveaux_invalides_IloadF_image_and_delete=""eniIlFd=" \
,IloadF_image_and_delete_____editer_les_niveaux_invalides \
); \
/* Ces arguments ont ete introduits le 20030211092913 et completes le 20030301095032. */ \
\
GET_ARGUMENT_L("valider_IloadJ_image_and_delete=""vIlJd=" \
,IloadJ_image_and_delete_____valider_les_genere_Float \
); \
GET_ARGUMENT_F("seuil_inferieur_IloadJ_image_and_delete=""siIlJd=" \
,IloadJ_image_and_delete_____seuil_inferieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_epsilon_IloadJ_image_and_delete=""seIlJd=" \
,IloadJ_image_and_delete_____seuil_epsilon___de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_superieur_IloadJ_image_and_delete=""ssIlJd=" \
,IloadJ_image_and_delete_____seuil_superieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_L("editer_niveaux_invalides_IloadJ_image_and_delete=""eniIlJd=" \
,IloadJ_image_and_delete_____editer_les_niveaux_invalides \
); \
/* Ces arguments ont ete introduits le 20030211092913 et completes le 20030301095032. */ \
\
MARQUEUR________FinParametresImages; \
/* Argument fictif destine a marquer la fin des Parametres Generaux de nature "Image" */ \
/* (le 20010420143829) et qui doit imperativement etre le dernier... */ \
\
MARQUEUR________DebutParametresSpecifiques; \
/* Argument fictif destine a marquer le debut des Parametres Specifiques (20010421090617). */ \
\
BLOC(liste_de_recuperation); \
\
MARQUEUR________FinParametresSpecifiques; \
/* Argument fictif destine a marquer la fin des Parametres Specifiques (20010421090617). */ \
) \
,BLOC(VIDE;) \
,BLOC(VIDE;) \
); \
/* 'pasX', 'pasY',... sont recuperes en premiers par symetrie avec la version suivante (a */ \
/* savoir 'GESTION_DU_FORMAT_DES_IMAGES_VERSION_02'). */ \
\
ACTIONS_A_EFFECTUER_SYSTEMATIQUEMENT_APRES_GET_PARAMETRES; \
/* Actions a effectuer systematiquement apres 'GET_PARAMETRES(...)' introduites le */ \
/* 20030710091913. */ \
\
SET_ECHANTILLONNAGE(pasX,pasY); \
/* Et ce afin de forcer 'TEST_ECHANTILLONNAGE'... */ \
Eblock \
/* Procedure de recuperation d'une liste d'arguments avec recuperation implicite des */ \
/* arguments utiles pour la gestion des images : */ \
/* */ \
/* ((px,py),(tx,ty)). */ \
/* */
#Aif ( (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_01)) \
)
#Eif ( (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_01)) \
)
#if ( (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_02)) \
|| (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_03)) \
)
# ifdef GESTION_DES_IMAGES_STATIQUES_VERSION_01
# define L_AXE_OX_N_EST_PAS_BIEN_DEFINI \
I3OU(IFGT(dimX,K___dimX),IFLE(Xmax,Xmin),IZNE(Xmin))
# define L_AXE_OY_N_EST_PAS_BIEN_DEFINI \
I3OU(IFGT(dimY,K___dimY),IFLE(Ymax,Ymin),IZNE(Ymin))
# define L_AXE_OZ_N_EST_PAS_BIEN_DEFINI \
I3OU(IFGT(dimZ,K___dimZ),IFLE(Zmax,Zmin),IZNE(Zmin))
/* Procedures de validation de la definition des trois axes 'OX', 'OY' et 'OZ'... */
# define ACTION_INITIALE_SUR_LES_IMAGES_STATIQUES_GET_ARGUMENTSi \
Bblock \
/* Dans cette version, il n'y a rien a faire... */ \
Eblock \
/* Procedure de traitement eventuel des "objets" Statiques... */
# define ACTION_INITIALE_SUR_LES_IMAGES_STATIQUES_GET_ARGUMENTSv \
Bblock \
/* Dans cette version, il n'y a rien a faire... */ \
Eblock \
/* Procedure de traitement eventuel des "objets" Statiques... */
# Aifdef GESTION_DES_IMAGES_STATIQUES_VERSION_01
# Eifdef GESTION_DES_IMAGES_STATIQUES_VERSION_01
# ifdef GESTION_DES_IMAGES_STATIQUES_VERSION_02
# define L_AXE_OX_N_EST_PAS_BIEN_DEFINI \
IFOU(IFLE(Xmax,Xmin),IZNE(Xmin))
# define L_AXE_OY_N_EST_PAS_BIEN_DEFINI \
IFOU(IFLE(Ymax,Ymin),IZNE(Ymin))
# define L_AXE_OZ_N_EST_PAS_BIEN_DEFINI \
IFOU(IFLE(Zmax,Zmin),IZNE(Zmin))
/* Procedures de validation de la definition des trois axes 'OX', 'OY' et 'OZ'... */
/* ATTENTION, le 19971212181937 j'ai ajoute des tests de non nullite des minima des trois */
/* suite a un probleme dans 'v $xrk/rdn_walk.41$K _____.NORMALISE_OZ'. En effet, ce */
/* programme avait ete appele avec "Zmin=1" alors que la normalisation d'une longueur de */
/* 1.0 avait ete demandee ; or cette operation retranche le minimum de la coordonnee, */
/* d'ou ici 1-1=0, utilise ensuite dans une division... */
# define ACTION_INITIALE_SUR_LES_IMAGES_STATIQUES_GET_ARGUMENTSi \
Bblock \
BSaveModifyVariable(Positive \
,allocation_memoire_avec_validation_____increment_du_compteur_de_tous_les_Malo \
,ZERO \
); \
/* Introduit le 20180401073120 suite aux tests de comptage des allocations et desallocations */ \
/* memoire effectues a ces moments-la via 'v $xci/neutre$K'. Ainsi, avec : */ \
/* */ \
/* $xci/neutre$X NeRienFaire=VRAI editer_compteurs_de_reference=VRAI */ \
/* */ \
/* la valeur totale (6961) etait egale au cumul de tous les compteurs (6961), alors */ \
/* qu'avec : */ \
/* */ \
/* $xci/neutre$X NeRienFaire=FAUX editer_compteurs_de_reference=VRAI */ \
/* */ \
/* la valeur totale (4705) n'etait pas egale au cumul de tous les compteurs (4701). La */ \
/* difference (4 = 4705-4701) correspond aux 4 'allocation_memoire_avec_validation(...)' */ \
/* des 4 images {IFmageA,IFmageR,ImageA,ImageR}. D'ou cette remise a 0 de l'increment du */ \
/* compteur, pour voir. Et c'etait bien cela... */ \
\
G_STATIK(); \
/* Dans '$xcc/cpp$Z', on recuperera la liste des "objets" Statiques utilisees reellement, et */ \
/* grace aux declarations provenant de '$xiii/Images$DEF', on generera automatiquement ici, */ \
/* grace a 'G_STATIK()', les sequences d'allocation de la memoire dynamique necessaires a */ \
/* celles-ci, maintenant que les dimensions sont connues. ATTENTION, on notera un probleme */ \
/* non resolu : c'est celui de la liberation finale de cette memoire ; mais est-ce bien */ \
/* necessaire, puisque par definition, les "objets" Statiques sont persistantes... */ \
/* */ \
/* On notera donc que 'G_STATIK()', tout comme 'D_STATIK(...)', n'est pas une procedure */ \
/* definie ; elle n'est qu'un code arbitraire utilise par '$xcc/cpp$Z' pour generer le */ \
/* code d'allocation des "objets" Statiques... */ \
\
ESaveModifyVariable(Positive \
,allocation_memoire_avec_validation_____increment_du_compteur_de_tous_les_Malo \
); \
Eblock \
/* Procedure de traitement eventuel des "objets" Statiques... */
# define ACTION_INITIALE_SUR_LES_IMAGES_STATIQUES_GET_ARGUMENTSv \
Bblock \
/* On notera donc que 'DECLARATION_D_UNE_IMAGE_STATIQUE_CACHEE(...)', tout comme les deux */ \
/* pseudo-procedures 'D_STATIK(...)' et 'G_STATIK()' ne sont pas definies, et sont presentes */ \
/* uniquement pour '$xcc/cpp$Z'... */ \
\
DECLARATION_D_UNE_IMAGE_STATIQUE_CACHEE(ImageG); \
DECLARATION_D_UNE_IMAGE_STATIQUE_CACHEE(Marqueur); \
DECLARATION_D_UNE_IMAGE_STATIQUE_CACHEE(Masque); \
/* Pour les memes raisons que ci-dessous, il semble plus prudent de declarer ces quelques */ \
/* images statiques qui sont en general cachees... */ \
\
DECLARATION_D_UNE_IMAGE_STATIQUE_CACHEE(Z_Buffer); \
/* Dans cette version, il faut declarer explicitement le 'Z-Buffer', car en effet, sinon */ \
/* l'image de nom 'Z_Buffer' ne sera pas recuperee par '$xcc/cpp$Z' via 'D_STATIK(...)', */ \
/* alors qu'elle peut tres bien etre utilisee dans l'une des bibliotheques referencees */ \
/* (par exemple dans 'v $xiii/vecteurs$FON') sans etre referencee directement dans ce module */ \
/* (c'est le cas, par exemple, de 'v $xci/grille.01$K'). */ \
DECLARATION_D_UNE_IMAGE_STATIQUE_CACHEE(Z_Buffer_accumule); \
/* Ceci a ete introduit un peu tardivement le 20010829095919 (ayant ete oublie lors de */ \
/* l'introduction de 'Z_Buffer_accumule' le 20010722100154...). */ \
\
DECLARATION_D_UNE_IMAGE_STATIQUE_CACHEE(Iassociation_de_voisinage_____X); \
DECLARATION_D_UNE_IMAGE_STATIQUE_CACHEE(Iassociation_de_voisinage_____Y); \
/* Introduit le 20101011165744 pour 'v $xci/interpole.12$K 20101011165628'... */ \
Eblock \
/* Procedure de traitement eventuel des "objets" Statiques qui sont utilisees dans les */ \
/* librairies sans etre explicitement referencees dans les '$K's... */
# Aifdef GESTION_DES_IMAGES_STATIQUES_VERSION_02
# Eifdef GESTION_DES_IMAGES_STATIQUES_VERSION_02
# define COEFFICIENT_DE_FORME_DE_L_ESPACE_TRIDIMENSIONNEL \
FQUATRE \
/* Coefficient qui permet de tester les trop grandes disparites entre les axes 'OX', 'OY' */ \
/* et 'OZ' ; une valeur unite ('FU'), par exemple, permettrait de verifier que l'espace */ \
/* est cubique (c'est-a-dire que les trois dimensions sont egales...). La valeur arbitraire */ \
/* choisie permet d'eviter les erreurs lors de l'utilisation du mode 'Suq' avec la plus */ \
/* grande extension de l'axe 'OZ' (soit 'EXTENSION_EXTREME_DES_DIMENSIONS_DES_AXES_OZ(...)'. */ \
/* */ \
/* Le 20140105182900, je suis passe de 'FLOT(SEIZE)' a 'FQUATRE' car cette valeur correspond */ \
/* mieux aux usages : */ \
/* */ \
/* v $xci/accumule.41$K coefficient_de_forme_de_l_espace_tridimensionnel */ \
/* v $xci/accumule.42$K coefficient_de_forme_de_l_espace_tridimensionnel */ \
/* v $xci/densite_3D.11$K coefficient_de_forme_de_l_espace_tridimensionnel */ \
/* v $xci/ombrage.11$K coefficient_de_forme_de_l_espace_tridimensionnel */
/* */
# define ENTREE_ARGUMENT_pasZ \
"pz="
# define ENTREE_ARGUMENTS_pasX_pasY_pasZ \
Bblock \
ENTREE_ARGUMENTS_pasX_pasY; \
GET_ARGUMENT_I(ENTREE_ARGUMENT_pasZ,pasZ); \
Eblock
# define ENTREE_ARGUMENT_translationZ \
"tz="
/* Entree de l'ARGUMENT {pasZ}. */
/* */
/* Ne pas oublier 'v $xiii/Images$DEF ENTREE_ARGUMENT_translation' (le 20170713094944)... */
# ifndef __VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI
/* Introduit le 20170712134325... */
# define ENTREE_ARGUMENTS_translationX_translationY_translationZ \
Bblock \
ENTREE_ARGUMENTS_translationX_translationY; \
GET_ARGUMENT_I(ENTREE_ARGUMENT_translationZ,translationZ); \
Eblock
/* Entree de l'ARGUMENT {translationZ}. */
# Aifndef __VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI
# define ENTREE_ARGUMENTS_translationX_translationY_translationZ \
Bblock \
ENTREE_ARGUMENTS_translationX_translationY; \
GET_ARGUMENT_E(ENTREE_ARGUMENT_translationZ,translationZ); \
/* Malgre '__VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI', les arguments {"tx=","ty=","tz=} */ \
/* sont ici definis afin de les "bloquer" de facon a ce qu'aucun '$K's ne les definissent */ \
/* avec un autre sens... */ \
Eblock
# Eifndef __VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI
/* Entree des ARGUMENTs {pasZ,translationZ}. */
# define gINITIALISATION_DES_INTERPOLATIONS_____compatibilite_20090225 \
gINITIALISATION_DES_INTERPOLATIONS_BILINEAIRE_ET_BICUBIQUE_____compatibilite_20090225 \
/* Pour raccourcir une ligne qui va suivre... */
# define GET_ARGUMENTSi(nombre_d_arguments_y_compris_le_nom,liste_de_recuperation) \
Bblock \
DEFV(Logical,INIT(le_format_des_images_a_ete_defini,FAUX)); \
/* Le format des images etant modifiable en 'GESTION_DU_FORMAT_DES_IMAGES_VERSION_02', il */ \
/* faut attendre qu'il ait ete completement defini pour pouvoir traiter les initialisations */ \
/* des parametres par les procedures 'PROCISS_ARGUMENT_I(...)' et 'PROCISS_ARGUMENT_F(...)'. */ \
\
INITIALISATION_DU_FORMAT_DES_IMAGES_DANS_GET_ARGUMENTSi; \
/* Initialisation explicite du format des images introduit le 20020122102707. */ \
\
ACTIONS_A_EFFECTUER_SYSTEMATIQUEMENT_AVANT_GET_PARAMETRES(nombre_d_arguments_y_compris_le_nom); \
/* Actions a effectuer systematiquement apres 'GET_PARAMETRES(...)' introduites le */ \
/* 20030710091913. */ \
\
GET_PARAMETRES(nombre_d_arguments_y_compris_le_nom \
,arguments \
,BLOC(GET_ARGUMENTS_DE_CONTROLE_DE_PORTEE_GENERALE; \
\
MARQUEUR________DebutParametresImages; \
/* Argument fictif destine a marquer le debut des Parametres Generaux de nature "Image" */ \
/* (le 20010420143829) et qui doit imperativement etre le premier... */ \
\
GET_ARGUMENT_L("ValiderAxes=",valider_les_axes_OX_OY_OZ); \
GET_ARGUMENT_F("CoefficientFormeEspaceTriDimensionnel=""CFETD=" \
,coefficient_de_forme_de_l_espace_tridimensionnel \
); \
/* Le 20020912135959, l'entree de 'valider_les_axes_OX_OY_OZ' a ete mise juste avant */ \
/* l'entree de {Xmin,Xmax,Ymin,Ymax,Zmin,Zmax} alors qu'anterieurement, il etait juste */ \
/* derriere de 'ETes' qui suit. En effet, a l'entree de {Xmin,Xmax,Ymin,Ymax,Zmin,Zmax} */ \
/* certaines validations inhibables par 'valider_les_axes_OX_OY_OZ' pourraient etre */ \
/* introduites ulterieurement... */ \
/* */ \
/* Cela fut complete par 'coefficient_de_forme_de_l_espace_tridimensionnel' le */ \
/* 20140103185613... */ \
\
Test(IFEQ(programme_principal_____indicateur_de_rerentree \
,PREMIERE_ENTREE_DANS_LE_PROGRAMME_PRINCIPAL \
) \
) \
Bblock \
/* Cas de la premiere entree dans le programme principal : le format des images peut etre */ \
/* defini... */ \
\
/* ATTENTION : il est absolument imperatif que les entrees suivantes (relatives aux */ \
/* {X,Y,Z}{min,max}) figurent avant : */ \
/* */ \
/* DebutParametresSpecifiques */ \
/* BLOC(liste_de_recuperation); */ \
/* FinParametresSpecifiques */ \
/* */ \
/* et ce a cause des eventuelles 'GIT_ARGUMENT_?(...)' qui pourraient y figurer et qui */ \
/* utiliseraient des fonctions du type '_____?NORMALISE_O?(...)' et '_?DENORMALISE_O?(...)' */ \
/* qui demandent a ce que {{Xmin,Xmax},{Ymin,Ymax},{Zmin,Zmax}} soient definis avec leurs */ \
/* bonnes valeurs et non point leurs valeurs implicites... */ \
\
GET_ARGUMENT_I("Xmin_PremiereEntree=",Xmin); \
GET_ARGUMENT_I("Xmax_PremiereEntree=",Xmax); \
GET_ARGUMENT_I("Ymin_PremiereEntree=",Ymin); \
GET_ARGUMENT_I("Ymax_PremiereEntree=",Ymax); \
GET_ARGUMENT_I("Zmin_PremiereEntree=",Zmin); \
GET_ARGUMENT_I("Zmax_PremiereEntree=",Zmax); \
/* Les parametres "????_PremiereEntree" sont provisoires et sont lies uniquement au */ \
/* dispositif 'v $xcc/cpp$Z TiTrE_AtTeNdU' afin de ne pas etre consideres comme des */ \
/* doubles definitions des parametres "????_ReRentree" (introduits le 20050624153414). */ \
/* */ \
/* On notera au passage que l'on ne peut malheureusement ecrire simplement : */ \
/* */ \
/* Test(IFEQ(programme_principal_____indicateur_de_rerentree */ \
/* ,PREMIERE_ENTREE_DANS_LE_PROGRAMME_PRINCIPAL */ \
/* ) */ \
/* ) */ \
/* Bblock */ \
/* Eblock */ \
/* ATes */ \
/* Bblock */ \
/* PUSH_DIMENSIONS_2D; */ \
/* Eblock */ \
/* ETes */ \
/* */ \
/* GET_ARGUMENT_I("Xmin=",Xmin); */ \
/* GET_ARGUMENT_I("Xmax=",Xmax); */ \
/* GET_ARGUMENT_I("Ymin=",Ymin); */ \
/* GET_ARGUMENT_I("Ymax=",Ymax); */ \
/* GET_ARGUMENT_I("Zmin=",Zmin); */ \
/* GET_ARGUMENT_I("Zmax=",Zmax); */ \
/* */ \
/* Test(IFEQ(programme_principal_____indicateur_de_rerentree */ \
/* ,PREMIERE_ENTREE_DANS_LE_PROGRAMME_PRINCIPAL */ \
/* ) */ \
/* ) */ \
/* Bblock */ \
/* Eblock */ \
/* ATes */ \
/* Bblock */ \
/* PULL_DIMENSIONS_2D; */ \
/* Eblock */ \
/* ETes */ \
/* */ \
/* a cause de 'PUSH_DIMENSIONS_2D' qui debute par un 'Bblock' et de 'PULL_DIMENSIONS_2D' */ \
/* qui se termine par le 'Eblock' associe... */ \
/* */ \
/* */ \
/* Le 20170630123909 je rappelle qu'ici ne figurent pas explicitement : */ \
/* */ \
/* [1] Xmin= */ \
/* Xmax= */ \
/* Ymin= */ \
/* Ymax= */ \
/* Zmin= */ \
/* Zmax= */ \
/* */ \
/* mais : */ \
/* */ \
/* [2] Xmin_PremiereEntree= Xmin_ReRentree= */ \
/* Xmax_PremiereEntree= Xmax_ReRentree= */ \
/* Ymin_PremiereEntree= Ymin_ReRentree= */ \
/* Ymax_PremiereEntree= Ymax_ReRentree= */ \
/* Zmin_PremiereEntree= Zmin_ReRentree= */ \
/* Zmax_PremiereEntree= Zmax_ReRentree= */ \
/* */ \
/* et que 'v $xcc/cpp$Z DeGuIsEmEnT' et 'v $xcc/cpp$Z ReReNtReE' assurent les reecritures */ \
/* necessaires pour passer de [2] a [1]... */ \
\
GET_ARGUMENT_L \
("cHOMOTHETIE_Std_____compatibilite_20120210=""Ccompatibilite_20120210=" \
,cHOMOTHETIE_Std_AXES_____compatibilite_20120210 \
); \
GET_ARGUMENT_L \
("lHOMOTHETIE_Std_____compatibilite_20120210=""Lcompatibilite_20120210=" \
,lHOMOTHETIE_Std_AXES_____compatibilite_20120210 \
); \
/* Introduit le 20120210184544... */ \
\
/* ATTENTION : il est absolument imperatif que les entrees precedentes (relatives aux */ \
/* {X,Y,Z}{min,max}) figurent avant : */ \
/* */ \
/* DebutParametresSpecifiques */ \
/* BLOC(liste_de_recuperation); */ \
/* FinParametresSpecifiques */ \
/* */ \
/* et ce a cause des eventuelles 'GIT_ARGUMENT_?(...)' qui pourraient y figurer et qui */ \
/* utiliseraient des fonctions du type '_____?NORMALISE_O?(...)' et '_?DENORMALISE_O?(...)' */ \
/* qui demandent a ce que {{Xmin,Xmax},{Ymin,Ymax},{Zmin,Zmax}} soient definis avec leurs */ \
/* bonnes valeurs et non point leurs valeurs implicites... */ \
\
Eblock \
ATes \
Bblock \
/* Cas d'une "rerentree" dans le programme principal : dans ce cas le format des images */ \
/* doit rester tel qu'il est (voir 'Iload_image_avec_redimensionnement_eventuel(...)' qui */ \
/* le modifie eventuellement, il faut donc que ce travail ne soit pas perdu...). On notera */ \
/* deux choses : */ \
/* */ \
/* 1-il est impossible de rendre conditionnels les appels a 'PUSH_DIMENSIONS_2D' et a */ \
/* 'PULL_DIMENSIONS_2D' car en effet, le premier contient un 'Bblock' alors que le second */ \
/* contient le 'Eblock' associe (ils sont la a des fins de validation) ; cela explique donc */ \
/* en partie la redondance de ce code. */ \
/* */ \
/* 2-meme lorsque les arguments ne dimensionnement des images doivent etre ignores, il est */ \
/* essentiel que leurs valeurs soient interpretees a cause du dispositif de detection des */ \
/* aguments incomprehensibles ; les valeurs alors positionnees sont ensuite "abandonnees" */ \
/* grace aux sauvegardes 'PUSH_DIMENSIONS_2D'/'PULL_DIMENSIONS_2D'... */ \
PUSH_DIMENSIONS_2D; \
\
/* ATTENTION : il est absolument imperatif que les entrees suivantes (relatives aux */ \
/* {X,Y,Z}{min,max}) figurent avant : */ \
/* */ \
/* DebutParametresSpecifiques */ \
/* BLOC(liste_de_recuperation); */ \
/* FinParametresSpecifiques */ \
/* */ \
/* et ce a cause des eventuelles 'GIT_ARGUMENT_?(...)' qui pourraient y figurer et qui */ \
/* utiliseraient des fonctions du type '_____?NORMALISE_O?(...)' et '_?DENORMALISE_O?(...)' */ \
/* qui demandent a ce que {{Xmin,Xmax},{Ymin,Ymax},{Zmin,Zmax}} soient definis avec leurs */ \
/* bonnes valeurs et non point leurs valeurs implicites... */ \
\
GET_ARGUMENT_I("Xmin_ReRentree=",Xmin); \
GET_ARGUMENT_I("Xmax_ReRentree=",Xmax); \
GET_ARGUMENT_I("Ymin_ReRentree=",Ymin); \
GET_ARGUMENT_I("Ymax_ReRentree=",Ymax); \
GET_ARGUMENT_I("Zmin_ReRentree=",Zmin); \
GET_ARGUMENT_I("Zmax_ReRentree=",Zmax); \
/* Les parametres "????_ReRentree" sont provisoires et sont lies uniquement au */ \
/* dispositif 'v $xcc/cpp$Z TiTrE_AtTeNdU' afin de ne pas etre consideres comme des */ \
/* doubles definitions des parametres "????_PremiereEntree" (introduits le 20050624153414). */ \
/* */ \
/* Le 20170630123909 je rappelle qu'ici ne figurent pas explicitement : */ \
/* */ \
/* [1] Xmin= */ \
/* Xmax= */ \
/* Ymin= */ \
/* Ymax= */ \
/* Zmin= */ \
/* Zmax= */ \
/* */ \
/* mais : */ \
/* */ \
/* [2] Xmin_PremiereEntree= Xmin_ReRentree= */ \
/* Xmax_PremiereEntree= Xmax_ReRentree= */ \
/* Ymin_PremiereEntree= Ymin_ReRentree= */ \
/* Ymax_PremiereEntree= Ymax_ReRentree= */ \
/* Zmin_PremiereEntree= Zmin_ReRentree= */ \
/* Zmax_PremiereEntree= Zmax_ReRentree= */ \
/* */ \
/* et que 'v $xcc/cpp$Z DeGuIsEmEnT' et 'v $xcc/cpp$Z ReReNtReE' assurent les reecritures */ \
/* necessaires pour passer de [2] a [1]... */ \
\
/* ATTENTION : il est absolument imperatif que les entrees precedentes (relatives aux */ \
/* {X,Y,Z}{min,max}) figurent avant : */ \
/* */ \
/* DebutParametresSpecifiques */ \
/* BLOC(liste_de_recuperation); */ \
/* FinParametresSpecifiques */ \
/* */ \
/* et ce a cause des eventuelles 'GIT_ARGUMENT_?(...)' qui pourraient y figurer et qui */ \
/* utiliseraient des fonctions du type '_____?NORMALISE_O?(...)' et '_?DENORMALISE_O?(...)' */ \
/* qui demandent a ce que {{Xmin,Xmax},{Ymin,Ymax},{Zmin,Zmax}} soient definis avec leurs */ \
/* bonnes valeurs et non point leurs valeurs implicites... */ \
\
PULL_DIMENSIONS_2D; \
Eblock \
ETes \
\
ENTREE_ARGUMENTS_pasX_pasY_pasZ; \
ENTREE_ARGUMENTS_translationX_translationY_translationZ; \
/* A cause de '__VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI', cette forme "compacte" a ete */ \
/* introduite le 20170712135356... */ \
\
GET_ARGUMENT_L("UniquementSubstitutions=""us=",ne_faire_que_les_substitutions); \
GET_ARGUMENT_L("EtatFiltrageNiveaux=""efn=",etat_Filtrage_niveaux); \
GET_ARGUMENT_I("CodeCombinaisonNiveaux=""ccn=" \
,Fcombinaison_universelle_de_deux_niveaux_____code \
); \
GET_ARGUMENT_F("PonderationCombinaisonNiveaux=""pcn=" \
,FBARY_____ponderation_de_la_fonction \
); \
/* Introduit le 20170715093935 afin de controler l'ecriture des points. Ainsi, si l'on veut */ \
/* que lors de l'ecriture d'un point, il y ait combinaison d'une certaine facon avec la */ \
/* valeur anterieure, il faudra activer le dispositif en faisant : */ \
/* */ \
/* UniquementSubstitutions=FAUX */ \
/* EtatFiltrageNiveaux=VRAI */ \
/* */ \
/* en choisissant le mode de combinaison avec ('v $xiipf/fonction.2$DEF code_FVARIABLE') : */ \
/* */ \
/* CodeCombinaisonNiveaux=1 FNEUTRE1 */ \
/* =2 FNEUTRE2 */ \
/* =3 FNEUTRE */ \
/* =4 FADD */ \
/* =5 FBARY */ \
/* =6 FMOYENNE */ \
/* =7 FSUB */ \
/* =8 FMUL */ \
/* =10 FDIV */ \
/* =11 FMAX */ \
/* =12 FMIN */ \
/* =13 FMINMAX */ \
/* =14 FOR */ \
/* =15 FAND */ \
/* =16 FEOR */ \
/* */ \
/* avec, si besoin est : */ \
/* */ \
/* PonderationCombinaisonNiveaux=... */ \
/* */ \
\
GET_ARGUMENT_F("EpsilonAxes=",DENORMALISE_AXES_____epsilon); \
GET_ARGUMENT_F("EpsilonNiveaux=",GENP_____epsilon_des_fonctions_de_ce_type); \
GET_ARGUMENT_F("EpsilonLissageSubstitution=",epsilon_de_LISSAGE_LISTE_DE_SUBSTITUTION); \
/* Definition du format des images. On notera la presence de deux listes de recuperation */ \
/* afin de pouvoir gerer l'indicateur 'le_format_des_images_a_ete_defini' correctement... */ \
/* 'Xmin', 'Xmax',... sont recuperes en premiers, au cas ou leur "vraie" valeur serait */ \
/* necessaire dans 'BLOC(liste_de_recuperation)', par exemple dans des normalisations ou */ \
/* des denormalisations (voir le cas des 'GIT_ARGUMENT_X(...)'). ATTENTION : dans un tel */ \
/* cas, leur utilisation est faite avant de les valider dans les tests qui suivent... */ \
\
ACTIONS_A_EFFECTUER_POUR_LA_GESTION_DE_LA_NORMALISATION_DES_COORDONNEES; \
/* Introduit le 20060118095058... */ \
\
GET_ARGUMENT_L("Progression=",begin_end_____editer_la_progression); \
GET_ARGUMENT_I("PasProgression=",begin_end_____pas_d_edition_de_la_progression); \
/* Afin de pouvoir voir eventuellement la progression des parcours d'images... */ \
/* */ \
/* Je rappelle le 20190311100351 que c'est en general (toujours ?) {$Zmin,$Zmax} et non */ \
/* pas '$formatI' qui conditionnent l'edition de la progression si elle est demandee... */ \
\
GET_ARGUMENT_P("load_niveau_hors_image=""lnhi=",Niveau____hors_image); \
GET_ARGUMENT_P("load_niveau_hors_album=""lnha=",Niveau____hors_album); \
/* Ces arguments ont ete introduits le 20070213145252. */ \
\
GET_ARGUMENT_L("E_SUBSTITUTION=" \
,RECHERCHE_D_UNE_LISTE_DE_SUBSTITUTION_____signaler_erreurs \
); \
/* Afin de pouvoir voir eventuellement la progression des parcours d'images... */ \
\
GET_ARGUMENT_L \
(ARG__Fmise_a_jour_du_systeme_de_gestion_de_fichiers_____compatibilite_20121025 \
,Fmise_a_jour_du_systeme_de_gestion_de_fichiers_____compatibilite_20121025 \
); \
/* Introduit le 20121025182732... */ \
\
\
GET_ARGUMENT_L("Dpipe_Iload_fichier=",Iload_fichier_____tester_le_debordement_du_pipe); \
/* Afin de pouvoir ne pas tester le debordement des pipes dans 'Iload_fichier(...)' alors */ \
/* qu'il est teste par defaut et provoque une erreur. Ceci a ete introduit le 19980520185424 */ \
/* pour etre utilise dans des programmes tels 'v $xci/Sdisplay_RVB$K' qui peuvent recevoir */ \
/* des triplets d'images {$ROUGE,$VERTE,$BLEUE}, ou encore 'v $xciP/S_NIVEAU$K' qui peut */ \
/* transmettre des triplets de palettes {$ROUGE,$VERTE,$BLEUE}... */ \
GET_ARGUMENT_L("ErreurLecture=" \
,files_____editer_les_messages_d_erreur_de_lecture_des_fichiers \
); \
/* L'acces a cet argument a ete introduit le 20020626102936 (il etait inaccessible avant). */ \
\
GET_ARGUMENT_L("permuter_bits_Iload_image=""pbIl=" \
,Iload_image_____permuter_les_bits_de_l_image \
); \
GET_ARGUMENT_I("taille_paquets_bits_Iload_image=""tpbIl=" \
,Iload_image_____taille_des_paquets_de_bits \
); \
GET_ARGUMENT_I("translation_index_bits_Iload_image=""tibIl=" \
,Iload_image_____translation_des_index_de_bits \
); \
/* La permutation des bits dans 'Iload_image(...)' a ete introduite le 20130707184535... */ \
\
GET_ARGUMENT_L("erreur_nom_absent_Iload_image=""enaIl=" \
,Iload_image_____un_nom_absent_est_une_erreur \
); \
GET_ARGUMENT_L("erreur_nom_absent_Iacces_image=""enaIa=" \
,Iacces_image_____un_nom_absent_est_une_erreur \
); \
GET_ARGUMENT_L("erreur_nom_absent_IloadF_image=""enaIlF=" \
,IloadF_image_____un_nom_absent_est_une_erreur \
); \
/* Afin de pouvoir autoriser des noms absents (sans que cela soit une erreur...). Cela fut */ \
/* introduit le 20080212100203... */ \
\
GET_ARGUMENT_L("convert_Iload_image=""cIl=" \
,Iload_image_____tenter_les_conversions_de_nom \
); \
GET_ARGUMENT_L("convert_Iacces_image=""cIa=" \
,Iacces_image_____tenter_les_conversions_de_nom \
); \
GET_ARGUMENT_L("convert_IloadF_image=""cIlF=" \
,IloadF_image_____tenter_les_conversions_de_nom \
); \
/* Afin de pouvoir convertir des noms en valeurs numeriques (etat par defaut...). */ \
\
GET_ARGUMENT_P("valeur_error_Iload_image=""valeur_erreur_Iload_image=""veIl=" \
,Iload_image_____valeur_initiale_si_erreur \
); \
GET_ARGUMENT_P("valeur_error_Iacces_image=""valeur_erreur_Iacces_image=""veIa=" \
,Iacces_image_____valeur_initiale_si_erreur \
); \
GET_ARGUMENT_F("valeur_error_IloadF_image=""valeur_erreur_IloadF_image=""veIlF=" \
,IloadF_image_____valeur_initiale_si_erreur \
); \
/* Ces arguments ont ete introduits le 20021004151854. */ \
\
GET_ARGUMENT_L("convertir_si_erreur_Iload_image=""cseIl=" \
,Iload_image_____tenter_une_conversion_standard_en_cas_d_erreur \
); \
GET_ARGUMENT_L("conversion_avec_renormalisation_si_erreur_Iload_image=""crseIl=" \
,Iload_image_____faire_la_conversion_standard_avec_renormalisation \
); \
GET_ARGUMENT_N("conversion_brutale_si_erreur_Iload_image=""cbseIl=" \
,Iload_image_____faire_la_conversion_standard_avec_renormalisation \
); \
/* Ces arguments ont ete introduits le 20080916174849 et modifies le 20080917104757... */ \
\
GET_ARGUMENT_L("forcer_redimensionnement_Iload_image=""frIl=" \
,Iload_image_____forcer_un_redimensionnement_meme_en_l_absence_d_erreur \
); \
GET_ARGUMENT_L("redimensionnement_si_erreur_Iload_image=""rseIl=" \
,Iload_image_____tenter_un_redimensionnement_en_cas_d_erreur \
); \
GET_ARGUMENT_I("methode_redimensionnement_si_erreur_Iload_image=""mrseIl=" \
,Iload_image_____methode_de_redimensionnement_a_utiliser \
); \
GET_ARGUMENT_L("avertir_redimensionnement_si_erreur_Iload_image=""arseIl=" \
,Iload_image_____avertir_s_il_y_a_redimensionnement_en_cas_d_erreur \
); \
/* Ces arguments ont ete introduits le 20090418234528 et complete le 20090422092647, puis */ \
/* le 20090502093745 en ce qui concerne le redimensionnement... */ \
\
GET_ARGUMENT_L("convertir_si_erreur_IloadF_image=""cseIlF=" \
,IloadF_image_____tenter_une_conversion_standard_en_cas_d_erreur \
); \
GET_ARGUMENT_F("niveau_minimal_si_erreur_IloadF_image=""nmseIlF=" \
,IloadF_image_____niveau_minimal_lors_d_une_conversion_standard \
); \
GET_ARGUMENT_F("niveau_maximal_si_erreur_IloadF_image=""nMseIlF=" \
,IloadF_image_____niveau_maximal_lors_d_une_conversion_standard \
); \
/* Ces arguments ont ete introduits le 20080916135822. */ \
\
GET_ARGUMENT_L("forcer_redimensionnement_IloadF_image=""frIlF=" \
,IloadF_image_____forcer_un_redimensionnement_meme_en_l_absence_d_erreur \
); \
GET_ARGUMENT_L("redimensionnement_si_erreur_IloadF_image=""rseIlF=" \
,IloadF_image_____tenter_un_redimensionnement_en_cas_d_erreur \
); \
GET_ARGUMENT_I("methode_redimensionnement_si_erreur_IloadF_image=""mrseIlF=" \
,IloadF_image_____methode_de_redimensionnement_a_utiliser \
); \
GET_ARGUMENT_L("avertir_redimensionnement_si_erreur_IloadF_image=""arseIlF=" \
,IloadF_image_____avertir_s_il_y_a_redimensionnement_en_cas_d_erreur \
); \
/* Ces arguments ont ete introduits le 20090418234528 et complete le 20090422092647, puis */ \
/* le 20090502093745 en ce qui concerne le redimensionnement... */ \
\
GET_ARGUMENT_L("valider_IloadF_image=""vIlF=" \
,IloadF_image_____valider_les_genere_Float \
); \
GET_ARGUMENT_F("seuil_inferieur_IloadF_image=""siIlF=" \
,IloadF_image_____seuil_inferieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_epsilon_IloadF_image=""seIlF=" \
,IloadF_image_____seuil_epsilon___de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_superieur_IloadF_image=""ssIlF=" \
,IloadF_image_____seuil_superieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_L("editer_niveaux_invalides_IloadF_image=""eniIlF=" \
,IloadF_image_____editer_les_niveaux_invalides \
); \
/* Ces arguments ont ete introduits le 20030211092913 et completes le 20030301095032. */ \
\
GET_ARGUMENT_L("valider_IloadJ_image=""vIlJ=" \
,IloadJ_image_____valider_les_genere_Float \
); \
GET_ARGUMENT_F("seuil_inferieur_IloadJ_image=""siIlJ=" \
,IloadJ_image_____seuil_inferieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_epsilon_IloadJ_image=""seIlJ=" \
,IloadJ_image_____seuil_epsilon___de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_superieur_IloadJ_image=""ssIlJ=" \
,IloadJ_image_____seuil_superieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_L("editer_niveaux_invalides_IloadJ_image=""eniIlJ=" \
,IloadJ_image_____editer_les_niveaux_invalides \
); \
/* Ces arguments ont ete introduits le 20030211092913 et completes le 20030301095032. */ \
\
GET_ARGUMENT_L("valider_IloadF_image_and_delete=""vIlFd=" \
,IloadF_image_and_delete_____valider_les_genere_Float \
); \
GET_ARGUMENT_F("seuil_inferieur_IloadF_image_and_delete=""siIlFd=" \
,IloadF_image_and_delete_____seuil_inferieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_epsilon_IloadF_image_and_delete=""seIlFd=" \
,IloadF_image_and_delete_____seuil_epsilon___de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_superieur_IloadF_image_and_delete=""ssIlFd=" \
,IloadF_image_and_delete_____seuil_superieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_L("editer_niveaux_invalides_IloadF_image_and_delete=""eniIlFd=" \
,IloadF_image_and_delete_____editer_les_niveaux_invalides \
); \
/* Ces arguments ont ete introduits le 20030211092913 et completes le 20030301095032. */ \
\
GET_ARGUMENT_L("valider_IloadJ_image_and_delete=""vIlJd=" \
,IloadJ_image_and_delete_____valider_les_genere_Float \
); \
GET_ARGUMENT_F("seuil_inferieur_IloadJ_image_and_delete=""siIlJd=" \
,IloadJ_image_and_delete_____seuil_inferieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_epsilon_IloadJ_image_and_delete=""seIlJd=" \
,IloadJ_image_and_delete_____seuil_epsilon___de_validation_des_genere_Float \
); \
GET_ARGUMENT_F("seuil_superieur_IloadJ_image_and_delete=""ssIlJd=" \
,IloadJ_image_and_delete_____seuil_superieur_de_validation_des_genere_Float \
); \
GET_ARGUMENT_L("editer_niveaux_invalides_IloadJ_image_and_delete=""eniIlJd=" \
,IloadJ_image_and_delete_____editer_les_niveaux_invalides \
); \
/* Ces arguments ont ete introduits le 20030211092913 et completes le 20030301095032. */ \
\
GET_ARGUMENT_L("permuter_bits_Istore=""pbIs=" \
,Istore_image_____permuter_les_bits_de_l_image \
); \
GET_ARGUMENT_I("taille_paquets_bits_Istore=""tpbIs=" \
,Istore_image_____taille_des_paquets_de_bits \
); \
GET_ARGUMENT_I("translation_index_bits_Istore=""tibIs=" \
,Istore_image_____translation_des_index_de_bits \
); \
/* La permutation des bits dans 'Istore_image(...)' a ete introduite le 20130707184535... */ \
\
GET_ARGUMENT_L("renormaliser_Istore=""rIs=" \
,Istore_image_____renormaliser_l_image \
); \
GET_ARGUMENT_P("niveau_minimal_renormalisation_Istore=""nmrIs=" \
,Istore_image_____niveau_minimal_de_renormalisation \
); \
GET_ARGUMENT_P("niveau_maximal_renormalisation_Istore=""nMrIs=" \
,Istore_image_____niveau_maximal_de_renormalisation \
); \
/* La renormalisation dans 'Istore_image(...)' a ete introduite le 20161128150521... */ \
\
GET_ARGUMENT_L("complementer_Istore=""cIs=" \
,Istore_image_____complementer_l_image \
); \
/* La complementation dans 'Istore_image(...)' a ete introduite le 20161129102525... */ \
\
GET_ARGUMENT_L("faciliter_NOM_FICHIER=" \
,files_____faciliter_l_acces_au_directory_images \
); \
/* Introduit le 20020514153041 afin de pouvoir controler le "fonctionnement" de la variable */ \
/* 'v $xiii/files$FON NOM_FICHIER'. */ \
\
GET_ARGUMENT_F("translation_Afloat_std=""tAfs=" \
,Afloat_std_____translation_d_arrondi_au_plus_proche_entier \
); \
GET_ARGUMENT_F("translation_Ifloat_std=""tIfs=" \
,Ifloat_std_____translation_d_arrondi_au_plus_proche_entier \
); \
/* Introduit le 20020315122536 ('v $xiii/conversion$FON 20020315122536'). On notera que des */ \
/* valeurs nulles pour ces deux parametres permettent d'assurer la compatibilite avec les */ \
/* generations anterieures a cette date... */ \
\
GET_ARGUMENT_L("INTERPOLATIONS_____compatibilite_20090225=" \
,gINITIALISATION_DES_INTERPOLATIONS_____compatibilite_20090225 \
); \
/* Introduit le 20090225133610 afin de garantir la compatibilite anterieure... */ \
\
GET_ARGUMENT_I("VOISINAGE_POINT_BILINEAIRE_pasX=""VPBL_px=" \
,VOISINAGE_POINT_BILINEAIRE_____pasX \
); \
GET_ARGUMENT_I("VOISINAGE_POINT_BILINEAIRE_pasY=""VPBL_py=" \
,VOISINAGE_POINT_BILINEAIRE_____pasY \
); \
GET_ARGUMENT_I("VOISINAGE_POINT_BICUBIQUE_pasX=""VPBC_px=" \
,VOISINAGE_POINT_BICUBIQUE_____pasX \
); \
GET_ARGUMENT_I("VOISINAGE_POINT_BICUBIQUE_pasY=""VPBC_py=" \
,VOISINAGE_POINT_BICUBIQUE_____pasY \
); \
/* Introduits le 20160329122414... */ \
\
MARQUEUR________FinParametresImages; \
/* Argument fictif destine a marquer la fin des Parametres Generaux et de nature "Image" */ \
/* (le 20010420143829) et qui doit imperativement etre le dernier... */ \
) \
,BLOC(EGAL(le_format_des_images_a_ete_defini,VRAI); \
/* Le format des images etant modifiable en 'GESTION_DU_FORMAT_DES_IMAGES_VERSION_02', il */ \
/* faut attendre qu'il ait ete completement defini pour pouvoir traiter les initialisations */ \
/* des parametres par les procedures 'PROCISS_ARGUMENT_I(...)' et 'PROCISS_ARGUMENT_F(...)'. */ \
) \
,BLOC( \
MARQUEUR________DebutParametresSpecifiques; \
/* Argument fictif destine a marquer le debut des Parametres Specifiques (20010421090617). */ \
\
BLOC(liste_de_recuperation); \
/* Autres definitions... */ \
/* */ \
/* ATTENTION, il est tres important de mettre 'liste_de_recuperation' apres l'entree de */ \
/* '$formatI' car, en effet, certaines valeurs initiales de parametres peuvent en dependre */ \
/* via 'GIT_ARGUMENT_?(...)'... */ \
\
MARQUEUR________FinParametresSpecifiques; \
/* Argument fictif destine a marquer la fin des Parametres Specifiques (20010421090617). */ \
) \
); \
\
ACTIONS_A_EFFECTUER_SYSTEMATIQUEMENT_APRES_GET_PARAMETRES; \
/* Actions a effectuer systematiquement apres 'GET_PARAMETRES(...)' introduites le */ \
/* 20030710091913. */ \
\
Test(IL_FAUT(valider_les_axes_OX_OY_OZ)) \
/* Ce test a ete ajoute le 19980324104621 afin de permettre de manipuler des fichiers */ \
/* "textes" comme des images definies par : */ \
/* */ \
/* Xmin = 0 */ \
/* Xmax = LongueurFichierTexte-1 */ \
/* */ \
/* Ymin = 0 */ \
/* Ymax = 0 */ \
/* */ \
/* ainsi, on pourra, par exemple, faire une sorte de "ou" entre deux textes a l'aide de la */ \
/* commande 'v $xci/maximum$K'. On notera au passage que le code du '$K_BLANC' est le plus */ \
/* faible des codes utiles, ce qui fait que ce caractere joue en quelque sorte le role du */ \
/* zero. Ceci est exploite par exemple dans 'v $xiMo/transparents$Z', commande nouvelle */ \
/* introduite le 19980422143225. */ \
Bblock \
Test(L_AXE_OX_N_EST_PAS_BIEN_DEFINI) \
Bblock \
PRINT_ERREUR("la definition de l'axe 'OX' est mauvaise"); \
CAL1(Prer2("l'axe 'OX' demande est defini par [%d,%d]\n",Xmin,Xmax)); \
EGAL(Xmin,k___Xmin); \
EGAL(Xmax,k___Xmax); \
/* Et restauration de l'axe 'OX' standard... */ \
CAL1(Prer2("l'axe 'OX' est donc redefini selon [%d,%d]\n",Xmin,Xmax)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(L_AXE_OY_N_EST_PAS_BIEN_DEFINI) \
Bblock \
PRINT_ERREUR("la definition de l'axe 'OY' est mauvaise"); \
CAL1(Prer2("l'axe 'OY' demande est defini par [%d,%d]\n",Ymin,Ymax)); \
EGAL(Ymin,k___Ymin); \
EGAL(Ymax,k___Ymax); \
/* Et restauration de l'axe 'OY' standard... */ \
CAL1(Prer2("l'axe 'OY' est donc redefini selon [%d,%d]\n",Ymin,Ymax)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(L_AXE_OZ_N_EST_PAS_BIEN_DEFINI) \
Bblock \
PRINT_ERREUR("la definition de l'axe 'OZ' est mauvaise"); \
CAL1(Prer2("l'axe 'OZ' demande est defini par [%d,%d]\n",Zmin,Zmax)); \
EGAL(Zmin,k___Zmin); \
EGAL(Zmax,k___Zmax); \
/* Et restauration de l'axe 'OZ' standard... */ \
CAL1(Prer2("l'axe 'OZ' est donc redefini selon [%d,%d]\n",Zmin,Zmax)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IFGT(bDIV(FLOT(MAX3(dimX,dimY,dimZ)) \
,FLOT(MIN3(dimX,dimY,dimZ)) \
) \
,coefficient_de_forme_de_l_espace_tridimensionnel \
) \
) \
/* Ce test a ete rajoute a cause de difficultes avec le programme 'v $xrv/champs_5.30$K' */ \
/* lorsqu'il y a peu d'images a empiler orthogonalement a 'OZ' ; on a alors affaire a */ \
/* un espace tres plat ('dimZ' etant tres inferieur a 'dimX' et a 'dimY') ; les rotations */ \
/* (et par exemple 'ROTATION_OX') donnent alors des resultats visuellement bizarres... */ \
/* */ \
/* La raison a cela semble etre liee au fait que dans les programmes de ce type, les */ \
/* dimensions {dimX,dimY,dimZ} designent aussi bien les dimensions de l'"objet" a deplacer */ \
/* (rotation, translation et zoom) dans l'espace, que les dimensions de l'espace absolu */ \
/* dans lequel on visualise celui-ci. D'autre part, le 19961021150710, j'ai decouvert */ \
/* que dans le cas de '$xrv/champs_5.30$K', lors de rotations, par exemple, certains points */ \
/* pouvaient d'approcher trop pres de l'observateur ; cela a conduit a l'introduction de */ \
/* 'FACTEUR_D_ELOIGNEMENT_EN_Z_D_UN_OBSERVATEUR_LOINTAIN'... */ \
/* */ \
/* Le 20050622153457, en testant le programme 'v $xrs/project3D.11$K', j'ai note aussi */ \
/* les consequences de cela, par exemple, sur les procedures '_____lNORMALISE_O?(...)'. */ \
/* En particulier, l'usage 'v $xrv/champs_5.1C$I _____lNORMALISE_OZ' conduit, lorsque */ \
/* 'dimZ' est petit (il valait 8 dans ce test...), a des corrections d'anti-aliasing */ \
/* aberrantes. Cela a conduit a la mise a jour 'v $xrv/champs_5.1C$I 20050622154321... */ \
Bblock \
PRINT_ATTENTION("l'espace est tres 'distordu', c'est-a-dire est tres different d'un cube"); \
CAL1(Prer3("ses dimensions sont (%d,%d,%d)\n",dimX,dimY,dimZ)); \
CAL1(Prer0("pour chaque axe trop court, il est donc suggere :\n")); \
CAL1(Prer0("1-soit d'introduire (s'il n'existe pas encore) un facteur specifique ")); \
CAL1(Prer0("de dilatation et de l'utiliser,\n")); \
CAL1(Prer1("2-soit d'utiliser l'option 'ValiderAxes=%s' pour supprimer cette verification.\n" \
,C_FAUX____ \
) \
); \
/* Voir par exemple a ce propos 'v $xrv/champs_5.30$K facteur_du_Z.FACTEUR_DU_Z' qui */ \
/* montre que cette notion de "facteur de dilatation" est "locale" aux programmes qui */ \
/* en ont besoin et qu'il ne s'agit donc pas d'un dispositif general et commun... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
SET_ECHANTILLONNAGE(pasX,pasY); \
/* Et ce afin de forcer 'TEST_ECHANTILLONNAGE'... */ \
\
ACTION_INITIALE_SUR_LES_IMAGES_STATIQUES_GET_ARGUMENTSi; \
/* Action initiale eventuelle sur les images Statiques... */ \
Eblock \
/* Procedure de recuperation d'une liste d'arguments avec recuperation implicite des */ \
/* arguments utiles pour la gestion des images : */ \
/* */ \
/* ((Xmin,Xmax),(Ymin,Ymax),(Zmin,Zmax),(px,py),(tx,ty)). */ \
/* */
#Aif ( (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_02)) \
|| (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_03)) \
)
#Eif ( (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_02)) \
|| (defined(GESTION_DU_FORMAT_DES_IMAGES_VERSION_03)) \
)
#define GET_ARGUMENTSv(nombre_d_arguments_y_compris_le_nom,liste_de_recuperation) \
Bblock \
GET_ARGUMENTSi(nombre_d_arguments_y_compris_le_nom,liste_de_recuperation); \
/* Recuperation des arguments suivant 'GESTION_DU_FORMAT_DES_IMAGES_VERSION_01' ou */ \
/* 'GESTION_DU_FORMAT_DES_IMAGES_VERSION_02'... */ \
\
ACTION_INITIALE_SUR_LES_IMAGES_STATIQUES_GET_ARGUMENTSv; \
/* Action initiale eventuelle sur les images Statiques... */ \
Eblock \
/* Procedure de recuperation d'une liste d'arguments avec recuperation implicite des */ \
/* arguments utiles pour la gestion des images : */ \
/* */ \
/* ([(Xmin,Xmax),(Ymin,Ymax),(Zmin,Zmax),](px,py),(tx,ty)). */ \
/* */ \
/* et gestion de certaines images statiques (celles qui sont utilisees dans les librairies */ \
/* sans etre explicitement referencees dans les '$K's). Ceci fut introduit le 20101011190940 */ \
/* afin de separer cette possibilite de celle qui consiste en plus a initialiser les */ \
/* differentes echelles Graphiques (ce que fait 'GET_ARGUMENTSg(...)'). */
#define GET_ARGUMENTSg(nombre_d_arguments_y_compris_le_nom,liste_de_recuperation) \
Bblock \
GET_ARGUMENTSv(nombre_d_arguments_y_compris_le_nom,liste_de_recuperation); \
/* Recuperation des arguments suivant 'GESTION_DU_FORMAT_DES_IMAGES_VERSION_01' ou */ \
/* 'GESTION_DU_FORMAT_DES_IMAGES_VERSION_02'... */ \
\
SK(INTER_POINT); \
/* Definition de l'echelle globale, */ \
SX(INTER_POINT); \
SY(INTER_POINT); \
SZ(INTER_POINT); \
/* Definition de l'echelle sur les axes 'OX', 'OY' et 'OZ'. */ \
/* */ \
/* Je comprends (un peu tard...) pourquoi on execute ici ces initialisations. Cela vient */ \
/* des definitions de 'SX(...)', 'SY(...)' et 'SZ(...)' qui utilisent respectivement */ \
/* '_____cNORMALISE_OX(...)', '_____cNORMALISE_OY(...)' et '_____cNORMALISE_OZ(...)', */ \
/* ces procedures ne fonctionnant correctement qu'apres la definition des trois axes */ \
/* dans 'GET_ARGUMENTSv(...)'. Il en est de meme pour 'SK(...)' qui utiliset {dimX,dimY} */ \
/* via la definition de 'PLUS_PETITE_IMAGE_CARREE_CIRCONSCRITE'... */ \
Eblock \
/* Procedure de recuperation d'une liste d'arguments avec recuperation implicite des */ \
/* arguments utiles pour la gestion des images : */ \
/* */ \
/* ([(Xmin,Xmax),(Ymin,Ymax),(Zmin,Zmax),](px,py),(tx,ty)). */ \
/* */ \
/* et mise a jour des echelles graphiques 'SK', 'SX', 'SY' et 'SZ' (ce qui est essentiel */ \
/* dans le cas de 'GESTION_DU_FORMAT_DES_IMAGES_VERSION_02') ; l'utilisation de cette */ \
/* procedure n'a de sens que si un */ \
/* */ \
/* #include image_image_VECTEURS_EXT */ \
/* */ \
/* a ete fait ou pour declarer certaines images statiques... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A F I N D ' E D I T E R L E S V A L E U R S R E S U L T A N T */
/* D E S F O N C T I O N S ' Fconversion?(...) ' : */
/* */
/*************************************************************************************************************************************/
#define EDITER_LES_VALEURS_APRES_Fconversion \
VRAI
#define NE_PAS_EDITER_LES_VALEURS_APRES_Fconversion \
NOTL(EDITER_LES_VALEURS_APRES_Fconversion)
/* Valeurs possibles de 'editer_la_valeur_des_parametres_d_une_commande'... */
#define EDITER_LE_NOM_DES_PARAMETRES_NON_GENERES_D_UNE_COMMANDE \
VRAI
#define NE_PAS_EDITER_LE_NOM_DES_PARAMETRES_NON_GENERES_D_UNE_COMMANDE \
NOTL(EDITER_LE_NOM_DES_PARAMETRES_NON_GENERES_D_UNE_COMMANDE)
/* Valeurs possibles de 'editer_le_nom_des_parametres_non_generes_d_une_commande'... */
#define EDITER_LE_NOM_DES_SYMBOLES_APRES_Fconversion \
VRAI
#define NE_PAS_EDITER_LE_NOM_DES_SYMBOLES_APRES_Fconversion \
NOTL(EDITER_LE_NOM_DES_SYMBOLES_APRES_Fconversion)
/* Valeurs possibles de 'editer_le_nom_des_parametres_d_une_commande'... */
#define EDITER_LES_SYNONYMES_APRES_Fconversion \
VRAI
#define NE_PAS_EDITER_LES_SYNONYMES_APRES_Fconversion \
NOTL(EDITER_LES_SYNONYMES_APRES_Fconversion)
/* Valeurs possibles de 'editer_les_synonymes_des_parametres_d_une_commande'... */
#define GROUPER_LES_SYNONYMES_APRES_Fconversion \
VRAI
#define NE_PAS_GROUPER_LES_SYNONYMES_APRES_Fconversion \
NOTL(GROUPER_LES_SYNONYMES_APRES_Fconversion)
/* Valeurs possibles de 'grouper_les_synonymes_des_parametres_d_une_commande' (introduites */
/* le 20070330091147). */
#define LONGUEUR_MAXIMALE_DES_VECTEURS_DANS_EDITER_LES_VALEURS_APRES_Fconversion \
TROIS \
/* Nombre d'elements edites par defaut dans le cas des vecteurs lorsque */ \
/* 'IL_FAUT(editer_la_valeur_des_parametres_d_une_commande)'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R E V E N T I O N D ' U N P R O B L E M E S U R L A G E S T I O N */
/* D E L A P I L E D E S A U V E G A R D E E T D ' A L L O C A T I O N */
/* D E S V A R I A B L E S D Y N A M I Q U E S : */
/* */
/*************************************************************************************************************************************/
#if ( (defined(SYSTEME_DPX5000_SPIX_CC)) \
)
# TestADef BUG_SYSTEME_DPX_LC_PILE_1 \
/* Il y a apparemment un probleme dans la bibliotheque contenant les fonctions mathematiques */ \
/* qui fait que lorsque la pile est appelee a franchir une frontiere de page, pour arriver */ \
/* sur une page non encore allouee, l'allocation ne se fait pas, ce qui provoque une trappe */ \
/* 'Segmentation fault'. Ce probleme se rencontre, par exemple, avec une fonction recursive */ \
/* qui appelerait la fonction 'cos' avant de se rappeler elle-meme... */
#Aif ( (defined(SYSTEME_DPX5000_SPIX_CC)) \
)
#Eif ( (defined(SYSTEME_DPX5000_SPIX_CC)) \
)
#if ( (! defined(BUG_SYSTEME_DPX_LC_PILE_1)) \
)
# define INITIALISATION_DE_LA_PILE_DE_SAUVEGARDE_ET_D_ALLOCATION(longueur_de_la_pile) \
Bblock \
BLOC(VIDE;); \
Eblock \
/* Procedure d'initialisation de la pile de sauvegarde et d'allocation des variables */ \
/* locales... */
#Aif ( (! defined(BUG_SYSTEME_DPX_LC_PILE_1)) \
)
# define INITIALISATION_DE_LA_PILE_DE_SAUVEGARDE_ET_D_ALLOCATION(longueur_de_la_pile) \
Bblock \
BLOC(CALS(initialisation_de_la_pile_de_sauvegarde_et_d_allocation(longueur_de_la_pile))); \
Eblock \
/* Procedure d'initialisation de la pile de sauvegarde et d'allocation des variables */ \
/* locales. On notera que l'argument 'longueur_de_la_pile' n'est pas en realite le nombre */ \
/* de mots a initialiser dans la pile, mais lui est proportionnel... */
#Eif ( (! defined(BUG_SYSTEME_DPX_LC_PILE_1)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R E C O N S T I T U T I O N D E L A C O M M A N D E C O U R A N T E : */
/* */
/*************************************************************************************************************************************/
#define RECONSTITUTION_DE_LA_COMMANDE_COURANTE(commande_courante) \
Bblock \
DEFV(Int,INIT(numero_d_argument_courant,UNDEF)); \
/* Donne en permanence le numero de l'argument courant. */ \
\
EGAp(commande_courante,chain_Acopie(C_VIDE)); \
/* Initialisation de la commande courante. */ \
\
gPARCOURS_DE_LA_LISTE_DES_ARGUMENTS(nombre_d_arguments \
,BLOC(EGAL(commande_courante \
,chain_Aconcaten3(commande_courante \
,ITb1(arguments \
,INDX(numero_d_argument_courant \
,NUMERO_ARGUMENT_COMMANDE \
) \
) \
,COND(IFLT(compteur_des_arguments \
,nombre_d_arguments \
) \
,C_BLANC \
,C_VIDE \
) \
) \
); \
/* Recuperation des arguments de la commande courante les uns apres les autres et dans */ \
/* l'ordre d'appel. On notera que le nom de la commande est considere comme etant le */ \
/* premier argument ('NUMERO_ARGUMENT_COMMANDE') et est donc bien recupere ici... */ \
) \
); \
Eblock \
/* Regeneration de la commande courante. On notera la presence d'un espace ('C_BLANC') */ \
/* derriere le dernier argument qui fut en fait supprime le 20060313145232 avec la mise */ \
/* en place de 'C_VIDE' lors de la derniere iteration... */
#define RECONSTITUTION_DE_LA_COMMANDE_COURANTE_AVEC_QUOTAGE(commande_courante) \
Bblock \
DEFV(Int,INIT(numero_d_argument_courant,UNDEF)); \
/* Donne en permanence le numero de l'argument courant. */ \
\
EGAp(commande_courante,chain_Acopie(C_VIDE)); \
/* Initialisation de la commande courante. */ \
\
gPARCOURS_DE_LA_LISTE_DES_ARGUMENTS(nombre_d_arguments \
,BLOC(EGAL(commande_courante \
,chain_Aconcaten3(commande_courante \
,COND(IFEQ(numero_d_argument_courant \
,NUMERO_ARGUMENT_COMMANDE \
) \
,chain_Aconcaten1 \
(ITb1(arguments \
,INDX(numero_d_argument_courant \
,NUMERO_ARGUMENT_COMMANDE \
) \
) \
) \
,chain_Aconcaten9 \
(C_VERITABLE_QUOTE \
,C_VERITABLE_APOSTROPHE \
,C_VERITABLE_QUOTE \
,C_VERITABLE_APOSTROPHE \
,ITb1(arguments \
,INDX(numero_d_argument_courant \
,NUMERO_ARGUMENT_COMMANDE \
) \
) \
,C_VERITABLE_APOSTROPHE \
,C_VERITABLE_QUOTE \
,C_VERITABLE_APOSTROPHE \
,C_VERITABLE_QUOTE \
) \
) \
,COND(IFLT(compteur_des_arguments \
,nombre_d_arguments \
) \
,C_BLANC \
,C_VIDE \
) \
) \
); \
/* Recuperation des arguments de la commande courante les uns apres les autres et dans */ \
/* l'ordre d'appel. On notera que le nom de la commande est considere comme etant le */ \
/* premier argument ('NUMERO_ARGUMENT_COMMANDE') et est donc bien recupere ici... */ \
/* Les "vrais" arguments sont encadres par des '$K_QS's et des '$K_QD's afin d'en */ \
/* faciliter la gestion (par exemple : 'v $xci/genere$K commande_de_generation_corrigee'). */ \
/* On notera que l'on trouvera ainsi : */ \
/* */ \
/* '"ARGUMENT=PARTIE1 PARTIE2..."' */ \
/* */ \
/* dans le cas d'un argument ("ARGUMENT=") dont la valeur "PARTIE1 PARTIE2..." contient */ \
/* des espaces (au passage cette syntaxe est aussi celle que l'on rencontre lorsqu'il */ \
/* n'y a pas d'espaces -cas general en fait-...), et non pas : */ \
/* */ \
/* ARGUMENT='"PARTIE1 PARTIE2..."' */ \
/* */ \
/* comme on pourrait le souhaiter. En tout cas, je ne sais pas faire autrement et de toute */ \
/* facon cela marche parfaitement dans 'v $xci/genere$K commande_de_generation_corrigee' ou */ \
/* il est essentiel que les structures "ARGUMENT=VALEUR" soit traitees en une fois (qu'il */ \
/* y ait des espaces ou pas) par 'v $xig/fonct$vv$DEF gPARCOURS_DE_LA_LISTE_DES_ARGUMENTS'. */ \
/* */ \
/* Avant le 20070110091012, la sequence de "quotage" des arguments ci-dessus etait : */ \
/* */ \
/* ,ch_Aconc5(C_VERITABLE_APOSTROPHE \ */ \
/* ,C_VERITABLE_QUOTE \ */ \
/* ,ITb1(arguments \ */ \
/* ,INDX(numero_d_argument_courant \ */ \
/* ,NUMERO_ARGUMENT_COMMANDE \ */ \
/* ) \ */ \
/* ) \ */ \
/* ,C_VERITABLE_QUOTE \ */ \
/* ,C_VERITABLE_APOSTROPHE \ */ \
/* ) \ */ \
/* */ \
/* avec : */ \
/* */ \
/* #define ch_Aconc5(chaineA1,chaineA2,chaineA3,chaineA4,chaineA5) \ */ \
/* chain_Aconcaten5(chaineA1,chaineA2,chaineA3,chaineA4,chaineA5) */ \
/* */ \
/* Le 20070110091012, le "quotage" des arguments a donc ete modifie de facon a produire : */ \
/* */ \
/* "'"'ARGUMENT=PARTIE1 PARTIE2...'"'" */ \
/* */ \
/* de facon a resoudre le probleme decrit dans 'v $xci/genere$K 20070109101142'... */ \
) \
); \
Eblock \
/* Regeneration de la commande courante avec quotage des arguments. Cette procedure fut */ \
/* introduite le 20061225152154... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* Q U E L Q U E S P R I M I T I V E S U T I L E S A L A G E N E R A T I O N D E C O M M A N D E S : */
/* */
/*************************************************************************************************************************************/
#define gGENERATION_NOM_D_UNE_COMMANDE(directory_de_la_commande,nom_relatif_au_directory_de_la_commande,postfixe) \
EGAs(chain_Aconcaten4(directory_de_la_commande \
,cSEPARATEUR_DES_PATHS \
,nom_relatif_au_directory_de_la_commande \
,postfixe \
) \
) \
/* Generation du nom absolu d'une commande quelconque (introduit le 20060313094131...). */
#define GENERATION_NOM_D_UNE_COMMANDE_X(directory_de_la_commande,nom_relatif_au_directory_de_la_commande) \
gGENERATION_NOM_D_UNE_COMMANDE(directory_de_la_commande \
,nom_relatif_au_directory_de_la_commande \
,GvarDefaut("X",".x") \
) \
/* Generation du nom absolu d'une commande '$X'. Le 20020228164122, suite a l'introduction */ \
/* de 'v $xil/defi_K2$vv$DEF Direct_xci' et de 'v $xil/defi_K2$vv$DEF Direct__xT', il a */ \
/* fallu passer de 'Gvar(directory_de_la_commande)' a 'directory_de_la_commande' qui doit */ \
/* etre alors defini "a l'exterieur" par un 'GvarDefaut(...)' que l'on ne peut evidemment */ \
/* utiliser ici, 'GENERATION_NOM_D_UNE_COMMANDE(...)' ne connaissant pas la valeur par */ \
/* defaut. Par contre, il a ete possible d'introduire 'GvarDefaut(...)' pour "X"... */ \
/* */ \
/* Le 20060313094131 le nom de cette procedure 'GENERATION_NOM_D_UNE_COMMANDE(...)' a ete */ \
/* change en 'GENERATION_NOM_D_UNE_COMMANDE_X(...)' afin de permettre l'introduction de */ \
/* 'GENERATION_NOM_D_UNE_COMMANDE_Z(...)' a cette date... */
#define GENERATION_NOM_D_UNE_COMMANDE_Z(directory_de_la_commande,nom_relatif_au_directory_de_la_commande) \
gGENERATION_NOM_D_UNE_COMMANDE(directory_de_la_commande \
,nom_relatif_au_directory_de_la_commande \
,GvarDefaut("Z",".z") \
) \
/* Generation du nom absolu d'une commande '$Z' (introduit le 20060313094131...). */
#define GENERATION_DE_CAL1_CAL2_CAL3_CAL4 \
EGAs(chain_Aconcaten12(C_BLANC,"CAL1=",ETAT_LOGIQUE(CAL1_____executer) \
,C_BLANC,"CAL2=",ETAT_LOGIQUE(CAL2_____executer) \
,C_BLANC,"CAL3=",ETAT_LOGIQUE(CAL3_____executer) \
,C_BLANC,"CAL4=",ETAT_LOGIQUE(CAL4_____executer) \
) \
) \
/* Generation des differents "CALi="... */
#define GENERATION_DE_formatI \
EGAs(chain_Aconcaten2(C_BLANC \
,Gvar("formatI") \
) \
) \
/* Generation de la variable '$formatI'. */
#define GENERATION_DE_formatI_Sdu \
EGAs(chain_Aconcaten2(C_BLANC \
,Gvar("format_Sdu") \
) \
) \
/* Generation de la variable '$formatI' en mode 'Sdu'. Cette definition n'etait utile qu'a */ \
/* 'v $xci/filtre.01$K GENERATION_DE_formatI_', mais le 20120906183527 les extensions de */ \
/* format ont ete, via 'v $xci/filtre.01$K GENERATION_DE_formatI_Sxu', gerees de facon */ \
/* beaucoup plus generales. Cette definition est malgre tout conservee, on ne sait jamais... */
#define GENERATION_DE_formatR \
EGAs(chain_Aconcaten12(C_BLANC,"XminR=",EGAs(chain_Aentier(Xmin)) \
,C_BLANC,"XmaxR=",EGAs(chain_Aentier(Xmax)) \
,C_BLANC,"YminR=",EGAs(chain_Aentier(Ymin)) \
,C_BLANC,"YmaxR=",EGAs(chain_Aentier(Ymax)) \
) \
) \
/* Generation de la variable '$formatR'. */
#define GENERATION_DE_formatR_Sdu \
EGAs(chain_Aconcaten2(C_BLANC \
,Gvar("formatR_Sdu") \
) \
) \
/* Generation de la variable '$formatR' en mode 'Sdu'. Cette definition n'etait utile qu'a */ \
/* 'v $xci/filtre.01$K GENERATION_DE_formatR_', mais le 20120906183527 les extensions de */ \
/* format ont ete, via 'v $xci/filtre.01$K GENERATION_DE_formatR_Sxu', gerees de facon */ \
/* beaucoup plus generales. Cette definition est malgre tout conservee, on ne sait jamais... */
#ifndef __VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI
/* Introduit le 20170712134325... */
# define GENERATION_DE_PasX_PasY_TraX_TraY \
EGAs(chain_Aconcaten12(C_BLANC,ENTREE_ARGUMENT_pasX,EGAs(chain_Aentier(PasX)) \
,C_BLANC,ENTREE_ARGUMENT_pasY,EGAs(chain_Aentier(PasY)) \
,C_BLANC,ENTREE_ARGUMENT_translationX,EGAs(chain_Aentier(TraX)) \
,C_BLANC,ENTREE_ARGUMENT_translationY,EGAs(chain_Aentier(TraY)) \
) \
) \
/* Generation de {PasX,PasY,TraX,TraY}. */
#Aifndef __VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI
# define GENERATION_DE_PasX_PasY_TraX_TraY \
EGAs(chain_Aconcaten6(C_BLANC,ENTREE_ARGUMENT_pasX,EGAs(chain_Aentier(PasX)) \
,C_BLANC,ENTREE_ARGUMENT_pasY,EGAs(chain_Aentier(PasY)) \
) \
) \
/* Generation de {PasX,PasY,TraX,TraY}. */
#Eifndef __VERSION__INDEXATION_SIMPLIFIEE_A_PRIORI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A C C E L E R A T E U R D ' U N E F O N C T I O N A ' N ' A R G U M E N T S : */
/* */
/*************************************************************************************************************************************/
#define ACCELERATEUR_DE_FONCTIONS_A_N_ARGUMENTS__PREMIERE_ENTREE \
INDEX0
#define ACCELERATEUR_DE_FONCTIONS_A_N_ARGUMENTS__PONDERATEUR \
UN
/* Parametres fondamentaux. */
/* */
/* Concernant la valeur de 'ACCELERATEUR_DE_FONCTIONS_A_N_ARGUMENTS__PONDERATEUR', on lira */
/* avec interet 'v $xiipf/fonction.2$FON 20120314091930'. Cela a provoque le remplacement */
/* ci-dessus de 'SEPT' par 'UN'... */
#define GENERATION_DE_L_ACCELERATEUR_DE_FONCTIONS_A_N_ARGUMENTS(accelerateur,nombre_d_entrees,listes_Arguments) \
/* Procedure introduite le 20120309181426... */ \
\
/* Avant le 20120310142011, il y avait ici : */ \
/* */ \
/* DEFV(Common,DEFV(Logical,INIT(accelerateur __@@__ _____utiliser_l_accelerateur,VRAI))); */ \
/* */ \
/* qui est supprime a cette date a cause de 'v $xcg/gen$EXT$Z'... */ \
/* */ \
/* Indique si l'accelerateur doit etre utilise ou pas (introduit le 20120310070411). */ \
/* */ \
/* Je note le 20120310132303 que cet indicateur pourrait aussi bien etre 'Local' car, en */ \
/* effet, 'v $xcg/gen$EXT$Z' ne peut l'atteindre. C'est pour cela que fut introduit */ \
/* 'v $xig/common$STR ACCELERATEUR_DE_FONCTIONS_A_N_ARGUMENTS____utiliser'le 20120310093347. */ \
/* Le 20120310142011, je le supprime a cause de cela... */ \
\
DEFV(Local,DEFV(Logical,INIT(accelerateur __@@__ _____initialiser_l_accelerateur,VRAI))); \
/* Indique si l'accelerateur doit etre initialise... */ \
\
DEFV(Local,DEFV(Logical,DdTb1(POINTERl \
,accelerateur __@@__ _____entree_valide \
,nombre_d_entrees \
,ADRESSE_NON_ENCORE_DEFINIE \
) \
) \
); \
/* Indique si l'entree courante est valide. */ \
\
DEFV(Local,DEFV(Int,DdTb1(POINTERi \
,accelerateur __@@__ _____identite_de_la_fonction \
,nombre_d_entrees \
,ADRESSE_NON_ENCORE_DEFINIE \
) \
) \
); \
/* Donne l'identite de l'objet (introduit le 20120316173122 afin de permettre a plusieurs */ \
/* fonctions d'utiliser le meme accelerateur...). */ \
\
DEFV(Local,DEFV(Int,DdTb1(POINTERi \
,accelerateur __@@__ _____identite_de_l_objet \
,nombre_d_entrees \
,ADRESSE_NON_ENCORE_DEFINIE \
) \
) \
); \
/* Donne l'identite de l'objet (introduit le 20120316160204 afin de lever une possible */ \
/* ambiguite lorsque cette identiete, avant cette date, etait "melangee" dans la clef */ \
/* de "hash-coding"...). */ \
\
BLOC(listes_Arguments); \
/* Donne les N (N=1,2,...) arguments de l'entree courante (si elle est valide...). */ \
\
DEFV(Local,DEFV(Float,DdTb1(POINTERf \
,accelerateur __@@__ _____valeur_de_la_fonction \
,nombre_d_entrees \
,ADRESSE_NON_ENCORE_DEFINIE \
) \
) \
); \
/* Donne la valeur de la fonction de l'entree courante (si elle est valide...). */
#define ACCELERATEUR_DE_FONCTIONS_A_N_ARGUMENTS(acc,ut,n_e,p_e,d_e,se_all,se_ini,p_Args,t_iden,se_maj,se_fal,val_f,se_cf,fonc,obj) \
/* Procedure introduite le 20120309181426... */ \
/* */ \
/* L'argument 'fonc' a ete introduit le 20120316154449, mais reste inutilise a cette */ \
/* date jusqu'au 20120316173122 ou il fut utilise... */ \
/* */ \
/* Definition des abbreviations utilisees pour les differents arguments : */ \
/* */ \
/* acc : accelerateur */ \
/* ut : utiliser */ \
/* n_e : nombre_d_entrees */ \
/* p_e : premiere_entree */ \
/* d_e : derniere_entree */ \
/* se_all : sequence_allocation */ \
/* se_ini : sequence_initialisation */ \
/* p_Args : polynome_Arguments */ \
/* t_iden : test_identite */ \
/* se_maj : sequence_mise_a_jour */ \
/* se_fal : sequence_desallocation ("FermerALlocateur") */ \
/* val_f : valeur_de_la_fonction */ \
/* se_cf : calcul_de_la_fonction */ \
/* fonc : fonction */ \
/* obj : objet */ \
/* */ \
/* Evidemment, cela est necessaire afin de reduire la longueur de la ligne de definition */ \
/* de 'ACCELERATEUR_DE_FONCTIONS_A_N_ARGUMENTS(...)' ci-dessus. */ \
/* */ \
/* Au passage, on notera que 'se_cf' (soit 'calcul_de_la_fonction') doit contenir entre */ \
/* autres choses : */ \
/* */ \
/* Bblock */ \
/* (...) */ \
/* EGAL(val_f,...); */ \
/* (...) */ \
/* Eblock */ \
/* */ \
/* mais que cela ne permet pas de se debarasser de 'val_f' (soit 'valeur_de_la_fonction') */ \
/* puisque 'val_f' est necessaire pour la mise a jour '_____valeur_de_la_fonction'... */ \
Bblock \
Test(IFET(IL_FAUT(ACCELERATEUR_DE_FONCTIONS_A_N_ARGUMENTS____utiliser) \
,IL_FAUT(ut) \
) \
) \
/* Test introduit le 20120310070411... */ \
Bblock \
Test(IL_FAUT(acc __@@__ _____initialiser_l_accelerateur)) \
Bblock \
DEFV(Int,INIT(index_d_initialisation,UNDEF)); \
\
MdTb1(acc __@@__ _____entree_valide,n_e,Logical,ADRESSE_NON_ENCORE_DEFINIE); \
MdTb1(acc __@@__ _____identite_de_la_fonction,n_e,Int,ADRESSE_NON_ENCORE_DEFINIE); \
MdTb1(acc __@@__ _____identite_de_l_objet,n_e,Int,ADRESSE_NON_ENCORE_DEFINIE); \
MdTb1(acc __@@__ _____valeur_de_la_fonction,n_e,Float,ADRESSE_NON_ENCORE_DEFINIE); \
\
BLOC(se_all); \
/* Allocation de la memoire necessaire... */ \
\
DoIn(index_d_initialisation,p_e,d_e,I) \
Bblock \
EGAL(IdTb1(acc __@@__ _____entree_valide,INDX(index_d_initialisation,p_e),n_e),INVALIDE); \
EGAL(IdTb1(acc __@@__ _____identite_de_la_fonction,INDX(index_d_initialisation,p_e),n_e),UNDEF); \
EGAL(IdTb1(acc __@@__ _____identite_de_l_objet,INDX(index_d_initialisation,p_e),n_e),UNDEF); \
\
BLOC(se_ini); \
/* Initialisation des differentes listes des Arguments. */ \
\
EGAL(IdTb1(acc __@@__ _____valeur_de_la_fonction,INDX(index_d_initialisation,p_e),n_e),FLOT__UNDEF); \
/* Initialisation de l'accelerateur... */ \
Eblock \
EDoI \
\
EGAL(acc __@@__ _____initialiser_l_accelerateur,FAUX); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
begin_nouveau_block \
Bblock \
DEFV(Logical,INIT(le_calcul_de_la_fonction_peut_etre_accelere,FAUX)); \
/* A priori, l'acceleration est impossible... */ \
\
DEFV(Int,INIT(identite_de_la_fonction,INTE(IDENTITE(fonc)))); \
/* Definition et calcul de l'identite de la fonction... */ \
/* */ \
/* Jusqu'au 20120316225418, il y avait ci-dessus : */ \
/* */ \
/* DEFV(tf,INIT(afPOINTEUR(adresse_de_la_fonction),aFONCTION(fonc))); */ \
/* */ \
/* ('tf' designant le 'type_fonction', soit donc 'genere_p' et 'genere_Float' en ce qui */ \
/* concerne 'FAload_point_coordonnees_01(...)' et 'FAload_point_coordonnees_01(...)' */ \
/* respectivement), mais cela donnait le message : */ \
/* */ \
/* warning: initialization from incompatible pointer type */ \
/* */ \
/* de meme, au passage, que le simple programme : */ \
/* */ \
/* int fonction(char caractere) */ \
/* { */ \
/* int (*adresses)()=fonction; */ \
/* } */ \
/* */ \
/* le probleme disparaissant si le 'char' est remplace par n'importe quel autre type... */ \
/* */ \
/* La solution fut trouvee le 20120316225418 : 'afPOINTEUR(''')' et 'aFONCTION(...)' */ \
/* furent simplement remplaces par 'IDENTITE(...)'. */ \
/* */ \
/* On notera le 'INTE(...)' obligatoire pour eviter le message : */ \
/* */ \
/* warning: initialization makes integer from pointer without a cast */ \
/* */ \
DEFV(Int,INIT(identite_de_l_objet,INTE(IDENTITE(obj)))); \
/* Definition et calcul de l'identite de l'objet... */ \
/* */ \
/* On notera le 'INTE(...)' obligatoire pour eviter le message : */ \
/* */ \
/* warning: initialization makes integer from pointer without a cast */ \
/* */ \
\
DEFV(Float,INIT(codage_des_arguments,FLOT__UNDEF)); \
DEFV(Int,INIT(index_d_acceleration,UNDEF)); \
/* Parametres essentiels... */ \
\
EGAL(codage_des_arguments \
,AXPB(FLOT(n_e) \
,p_Args \
,ADD2(FLOT(identite_de_la_fonction) \
,FLOT(identite_de_l_objet) \
) \
) \
); \
/* Calcul d'une fonction des 'N' arguments et de 'identite_de_l_objet'. Cette derniere */ \
/* composante" permet l'exploitation de plusieurs objets differents "simultanement" avec */ \
/* la meme fonction ('v $xiii/di_album$FON FAload_point_coordonnees_01' pour les fonctions */ \
/* du tye 'Iaccumulation_tri_dimensionnelle...(...)'). Le 20120317092022 fut ajoutee */ \
/* 'identite_de_la_fonction' au cas ou plusieurs fonctions "partageraient" le meme */ \
/* accelerateur... */ \
EGAL(index_d_acceleration \
,ADD2(REST(INTE(ABSO(codage_des_arguments)) \
,n_e \
) \
,p_e \
) \
); \
/* Conversion de la fonction des N (N=1,2,...) arguments en un index de "hash-coding"... */ \
\
Test(IFEXff(index_d_acceleration,p_e,d_e)) \
/* Test introduit le 20120929145125 suite a un probleme vu avec 'v $xiirv/STRU.H1' (lors */ \
/* d'une tentative de regeneration, des lignes verticales contenant des points parasites */ \
/* apparaissaient, ces points parasites etant au nombre de 989). Le probleme venait en */ \
/* fait de 'v $xiipf/fonction.2$FON 20120929165544'... */ \
Bblock \
PRINT_ERREUR("l'index d'acceleration est en dehors de ses bornes"); \
CAL1(Prer3("(l'index vaut %d et ses bornes sont [%d,%d])\n" \
,index_d_acceleration \
,p_e,d_e \
) \
); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(EST_VALIDE(IdTb1(acc __@@__ _____entree_valide,index_d_acceleration,n_e))) \
Bblock \
Test(IFEQ(IdTb1(acc __@@__ _____identite_de_l_objet,index_d_acceleration,n_e) \
,identite_de_l_objet \
) \
) \
Bblock \
Test(IFEQ(IdTb1(acc __@@__ _____identite_de_la_fonction,index_d_acceleration,n_e) \
,identite_de_la_fonction \
) \
) \
Bblock \
Test(t_iden) \
Bblock \
EGAL(le_calcul_de_la_fonction_peut_etre_accelere,VRAI); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(EST_VRAI(le_calcul_de_la_fonction_peut_etre_accelere)) \
Bblock \
EGAL(val_f,IdTb1(acc __@@__ _____valeur_de_la_fonction,index_d_acceleration,n_e)); \
/* Dans le cas ou c'est bien 'fonction(Argument1,Argument2,...)' qui est memorise */ \
/* dans l'accelerateur, sa valeur a deja ete calculee... */ \
Eblock \
ATes \
Bblock \
BLOC(se_cf); \
/* Dans le cas contraire, il faut calculer 'fonction(Argument1,Argument2,...)'... */ \
/* */ \
/* Au passage, on notera que 'se_cf' (soit 'calcul_de_la_fonction') doit contenir entre */ \
/* autres choses : */ \
/* */ \
/* Bblock */ \
/* (...) */ \
/* EGAL(val_f,...); */ \
/* (...) */ \
/* Eblock */ \
/* */ \
/* mais que cela ne permet pas de se debarasser de 'val_f' (soit 'valeur_de_la_fonction') */ \
/* puisque 'val_f' est necessaire pour la mise a jour '_____valeur_de_la_fonction'... */ \
\
EGAL(IdTb1(acc __@@__ _____entree_valide,index_d_acceleration,n_e),VALIDE); \
EGAL(IdTb1(acc __@@__ _____identite_de_la_fonction,index_d_acceleration,n_e) \
,identite_de_la_fonction \
); \
EGAL(IdTb1(acc __@@__ _____identite_de_l_objet,index_d_acceleration,n_e),identite_de_l_objet); \
\
BLOC(se_maj); \
/* Mise a jour des differentes listes des Arguments. */ \
\
EGAL(IdTb1(acc __@@__ _____valeur_de_la_fonction,index_d_acceleration,n_e),val_f); \
/* Puis, la valeur de 'fonction(Argument1,Argument2,...)' est memorisee... */ \
Eblock \
ETes \
Eblock \
end_nouveau_block \
\
Test(IL_FAUT(acc __@@__ _____fermer_l_accelerateur)) \
/* Test introduit le 20120311091641 en notant qu'a priori on ne passera certainement */ \
/* jamais par ici pour la bonne raison que l'on ne sait pas, en general, quand est le */ \
/* dernier appel. C'est introduit malgre tout par "symetrie"... */ \
Bblock \
BLOC(se_fal); \
\
FdTb1(acc __@@__ _____valeur_de_la_fonction,n_e,Float,ADRESSE_NON_ENCORE_DEFINIE); \
FdTb1(acc __@@__ _____identite_de_l_objet,n_e,Int,ADRESSE_NON_ENCORE_DEFINIE); \
FdTb1(acc __@@__ _____identite_de_la_fonction,n_e,Int,ADRESSE_NON_ENCORE_DEFINIE); \
FdTb1(acc __@@__ _____entree_valide,n_e,Logical,ADRESSE_NON_ENCORE_DEFINIE); \
/* Desallocation de la memoire necessaire... */ \
\
EGAL(acc __@@__ _____initialiser_l_accelerateur,VRAI); \
EGAL(acc __@@__ _____fermer_l_accelerateur,FAUX); \
/* Au cas ou l'accelerateur serait malgre tout de nouveau appele par la suite... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
BLOC(se_cf); \
/* Dans ce cas, la fonction est calculee sans tentative d'acceleration... */ \
Eblock \
ETes \
Eblock