/*************************************************************************************************************************************/
/* */
/* C O N V E R S I O N D E C A R A C T E R E S C O D E S E N ' UTF-8 ' : */
/* */
/* */
/* Definition du codage 'UTF-8' : */
/* */
/* Ce code utilise 1, 2, 3 ou 4 octets et ce suivant la */
/* la valeur du premier d'entre-eux. Soit 'K1' celui-ci, */
/* on a alors (en hexa-decimal) : */
/* */
/* K1 dans [00,7F] : 1 octet {K1}, */
/* */
/* */
/* K1 dans [C2-DF] : 2 octets {K1,K2}, */
/* - - */
/* */
/* K1 dans [E0-EF] : 3 octets {K1,K2,K3}, */
/* - - */
/* */
/* K1 dans [F0-F4] : 4 octets {K1,K2,K3,K4}. */
/* - - */
/* */
/* */
/* Nota important : a cause de 'v $xiMd/xcp_____conversion_UTF_8$K.$m4', */
/* la suite des deux caracteres "&#" introduisant le code hexa-decimal */
/* sur 4 ou 5 chiffres est remplace dans les commentaires de ce '$K', */
/* ainsi que partout ailleurs ou c'est possible, par la chaine "ZZ". */
/* */
/* */
/* Code du caractere : K1 (Base16) : K1 (Base2) : K2 (Base2) : K3 (Base2) : K4 (Base2) : */
/* ----------------- ----------- ---------- ---------- ---------- ---------- */
/* */
/* ZZx0000; --> ZZx007F; 00 --> 7F 0bbb.bbbb */
/* */
/* ZZx0080; --> ZZx07FF; C2 --> DF 110b.bbbb 10bb.bbbb */
/* */
/* ZZx0800; --> ZZxFFFF; E0 --> EF 1110.bbbb 10bb.bbbb 10bb.bbbb */
/* */
/* ZZx10000; --> ZZx10FFFF; F0 --> F3 1111.00bb 10bb.bbbb 10bb.bbbb 10bb.bbbb */
/* F4 1111.0100 1000.bbbb 10bb.bbbb 10bb.bbbb */
/* */
/* */
/* Avec les notations suivantes : le caractere "." est un separateur entre */
/* les 2 groupes de 4 bits contenus dans un octet. Quant au caractere "b", */
/* il represente un bit quelconque ("0" ou "1"). */
/* */
/* Une suite de "b"s convertie en une valeur hexadecimale de 4 ou 5 chiffres */
/* definit le code "ZZx1234[5];" du caractere correspondant, utilisable directement */
/* en '$HTML'... */
/* */
/* (voir le WikiPedia de 'UTF8'). */
/* */
/* */
/* Author of '$xcp/conversion_UTF_8$K' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 20241104113136). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N T E R F A C E ' listG ' : */
/* */
/* */
/* :Debut_listG: */
/* :Fin_listG: */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I R E C T I V E S S P E C I F I Q U E S D E C O M P I L A T I O N : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I C H I E R S D ' I N C L U D E S : */
/* */
/*************************************************************************************************************************************/
#include INCLUDES_MINI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P A R A M E T R E S : */
/* */
/*************************************************************************************************************************************/
#define MODE_UTF_8 \
VRAI \
/* S'agit-il du mode 'UTF-8' ('VRAI') ou du mode 'ASCII' ('FAUX') ? */
#define EDITER_LE_MODE_ASCII_EN_HEXADECIMAL \
FAUX \
/* En mode 'ASCII' faut-il editer en hexadecimal ('VRAI') ou des caracteres ('FAUX') ? */
#define LONGUEUR_APPROXIMATIVE_DES_LIGNES \
CENT \
/* Longueur approximative des lignes a generer... */
#define GENERER_LES_CODES_NON_DEFINIS \
FAUX \
/* Faut-il generer ('VRAI') les codes non reconnus ou bien interrompre le processus */ \
/* ('FAUX') ? Ceci fut introduit le 20250207103836... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* M A C R O S U T I L E S : */
/* */
/*************************************************************************************************************************************/
#define GET_CARACTERE_SUIVANT(caractere_suivant) \
Bblock \
Test(GetcharT(caractere_suivant)) \
Bblock \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la fin du fichier est rencontree trop tot"); \
Exit(PROBLEMES); \
Eblock \
ETes \
Eblock
#define DEBUT_CODES_CARACTERES_1_ \
0x00
#define FIN___CODES_CARACTERES_1_ \
0x7F
#define MASQUE_CARACTERES_1__1 \
0x7F
/* Cas {K1} : */
/* */
/* 0bbb.bbbb */
/* --- ---- */
/* 7 F */
/* */
#define DEBUT_CODES_CARACTERES_2_ \
0xC2
#define FIN___CODES_CARACTERES_2_ \
0xDF
#define MASQUE_CARACTERES_2__1 \
0x1F
#define MASQUE_CARACTERES_2__2 \
0x3F
/* Cas {K1,K2} : */
/* */
/* 110b.bbbb 10bb.bbbb */
/* - ---- -- ---- */
/* 1 F 3 F */
/* */
#define DEBUT_CODES_CARACTERES_3_ \
0xE0
#define FIN___CODES_CARACTERES_3_ \
0xEF
#define MASQUE_CARACTERES_3__1 \
0x0F
#define MASQUE_CARACTERES_3__2 \
0x3F
#define MASQUE_CARACTERES_3__3 \
0x3F
/* Cas {K1,K2,K3} : */
/* */
/* 1110.bbbb 10bb.bbbb 10bb.bbbb */
/* ---- -- ---- -- ---- */
/* 0 F 3 F 3 F */
/* */
#define DEBUT_CODES_CARACTERES_41 \
0xF0
#define FIN___CODES_CARACTERES_41 \
0xF3
#define MASQUE_CARACTERES_41_1 \
0x03
#define MASQUE_CARACTERES_41_2 \
0x3F
#define MASQUE_CARACTERES_41_3 \
0x3F
#define MASQUE_CARACTERES_41_4 \
0x3F
/* Cas {K1,K2,K3,K4} : */
/* */
/* 1111.00bb 10bb.bbbb 10bb.bbbb 10bb.bbbb */
/* -- -- ---- -- ---- -- ---- */
/* 0 3 3 F 3 F 3 F */
/* */
#define DEBUT_CODES_CARACTERES_42 \
0xF4
#define FIN___CODES_CARACTERES_42 \
0xF4
#define MASQUE_CARACTERES_42_1 \
0x00
#define MASQUE_CARACTERES_42_2 \
0x0F
#define MASQUE_CARACTERES_42_3 \
0x3F
#define MASQUE_CARACTERES_42_4 \
0x3F
/* Cas {K1,K2,K3,K4} : */
/* */
/* 1111.0100 1000.bbbb 10bb.bbbb 10bb.bbbb */
/* ---- -- ---- -- ---- */
/* 0 0 0 F 3 F 3 F */
/* */
#define CODE_A_DEFINIR_ULTERIEUREMENT \
"<CodeNonReconnu>"
#define EXTENSION_xiMoG(code_xiMoG) \
chain_Aconcaten3(C_SLASH,code_xiMoG,C_SLASH)
#define EXTENSION_M4(code_M4) \
chain_Aconcaten3(C_VERITABLE_ANTI_QUOTE,code_M4,C_VERITABLE_APOSTROPHE)
DEFV(Local,DEFV(Positive,INIT(compteur_de_caracteres_quelconques,ZERO)));
DEFV(Local,DEFV(Positive,INIT(compteur_de_caracteres_K_QD,ZERO)));
/* Differents compteurs de caracteres... */
#define EDITION_DU_CODE(code_xiMoG) \
Bblock \
Test(IFNE_chaine(code_xiMoG,C_VIDE)) \
/* Test introduit le 20241211101916 pour le code '0xA0'... */ \
Bblock \
CAL2(Prin1("%s",code_xiMoG)); \
/* On utilise 'Prin1(...)' de facon a n'utiliser que 'STREAM_OUT'... */ \
INCR(compteur_de_caracteres_quelconques,chain_Xtaille(code_xiMoG)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
#define CODAGE_AVEC_EXTENSION(code_hexadecimal,code_xiMoG) \
Ca1e(code_hexadecimal) \
Bblock \
EDITION_DU_CODE(EXTENSION_xiMoG(code_xiMoG)); \
Eblock \
ECa1
#define CODAGE_SANS_EXTENSION(code_hexadecimal,code_xiMoG) \
Ca1e(code_hexadecimal) \
Bblock \
EDITION_DU_CODE(code_xiMoG); \
Eblock \
ECa1
#define TRAITEMENT_DES_CODES_STANDARDS \
Bblock \
DEFV(CHAR,INIT(DTb0(conversion_caractere_chaine),"?")); \
\
INCR(compteur_de_caracteres_K_QD,COND(IFEQ(caractere_courant__,K_QUOTE),I,ZERO)); \
/* Comptage des 'K_QUOTE's afin de faire des decoupages corrects des lignes qui, en */ \
/* particulier ne doivent pas avoir lieu a l'interieur d'une chaine '"..."'. */ \
\
Test(I3ET(IFGE(compteur_de_caracteres_quelconques,longueur_approximative_des_lignes) \
,IFEQ(caractere_courant__,K_BLANC) \
,EST_PAIR(compteur_de_caracteres_K_QD) \
) \
) \
Bblock \
EGAL(caractere_courant__,K_LF); \
/* Introduction d'un changement de ligne lorsque cela est necessaire et possible... */ \
CLIR(compteur_de_caracteres_quelconques); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
EGAL(ITb0(conversion_caractere_chaine,PREMIER_CARACTERE),caractere_courant__); \
/* Conversion du caractere courant en une petite chaine... */ \
EDITION_DU_CODE(conversion_caractere_chaine); \
Eblock
#define TRAITEMENT_DU_CODE_ADDITION \
Bblock \
EDITION_DU_CODE(EXTENSION_xiMoG("AdDiTiOn")); \
Eblock
#define TRAITEMENT_DU_CODE_VIRGULE \
Bblock \
EDITION_DU_CODE(EXTENSION_xiMoG("ViRgUlE")); \
Eblock
#define TRAITEMENT_DES_CODES_ASCII \
Bblock \
Choi(caractere_courant__) \
Bblock \
CODAGE_AVEC_EXTENSION(0xE0,"aG"); \
CODAGE_AVEC_EXTENSION(0xE1,"aA"); \
CODAGE_AVEC_EXTENSION(0xE2,"aC"); \
CODAGE_AVEC_EXTENSION(0xE4,"aT"); \
CODAGE_AVEC_EXTENSION(0xE6,"aE"); \
CODAGE_AVEC_EXTENSION(0xE7,"cC"); \
CODAGE_AVEC_EXTENSION(0xE8,"eG"); \
CODAGE_AVEC_EXTENSION(0xE9,"eA"); \
CODAGE_AVEC_EXTENSION(0xEA,"eC"); \
CODAGE_AVEC_EXTENSION(0xEB,"eT"); \
CODAGE_AVEC_EXTENSION(0xEE,"iC"); \
CODAGE_AVEC_EXTENSION(0xEF,"iT"); \
CODAGE_AVEC_EXTENSION(0xF4,"oC"); \
CODAGE_AVEC_EXTENSION(0xF6,"oT"); \
CODAGE_AVEC_EXTENSION(0x9C,"oE"); \
CODAGE_AVEC_EXTENSION(0xF9,"uG"); \
CODAGE_AVEC_EXTENSION(0xFB,"uC"); \
CODAGE_AVEC_EXTENSION(0xFC,"uT"); \
CODAGE_AVEC_EXTENSION(0xC1,"Aa"); \
CODAGE_AVEC_EXTENSION(0xC0,"Ag"); \
CODAGE_AVEC_EXTENSION(0xC9,"Ea"); \
CODAGE_AVEC_EXTENSION(0xCA,"Ec"); \
CODAGE_AVEC_EXTENSION(0xC8,"Eg"); \
CODAGE_AVEC_EXTENSION(0xD4,"Oc"); \
CODAGE_AVEC_EXTENSION(0x23,"Er"); \
/* Ceci est un peu etrange : lors d'un copier-coller d'un "o dans l'e" d'un texte WORD, */ \
/* le resultat est le caractere '#' dont le code est '0x23', d'ou cette substitution qui */ \
/* est un peu ennuyeuse au cas ou un caractere '#' figurerait reellement dans le WORD. */ \
/* Cela s'est vu dans 'v $xiMd/SIlVousPlaitDessineMoiLInfini.01$FRANCAIS$m4 d.un.trou.noir' */ \
/* aux environs du 20241211121320... */ \
/* */ \
/* Le 20241212080916, je crois avoir compris : le caractere '#' apparait lors du */ \
/* copier-coller de certains caracteres dans un WORD et non pas uniquement avec le */ \
/* "o dans l'e". La solution est donc de le coder avec un code inexistant dans */ \
/* 'v $xiMoG/MotsClefs.1$vv$sed' de facon a le reperer lors du 'Gserveur' ce qui permet */ \
/* de corriger ensuite manuellement. Je choisis "Er" pour "Error"... */ \
CODAGE_SANS_EXTENSION(0xA0,C_VIDE); \
CODAGE_SANS_EXTENSION(0xAB,C_VERITABLE_QUOTE); \
/* Il s'agit de la quote "ouvrante"... */ \
CODAGE_SANS_EXTENSION(0xBB,C_VERITABLE_QUOTE); \
/* Il s'agit de la quote "fermante"... */ \
\
Ca1e(K_PLUS) \
Bblock \
TRAITEMENT_DU_CODE_ADDITION; \
Eblock \
ECa1 \
\
Ca1e(K_VIRGULE) \
Bblock \
TRAITEMENT_DU_CODE_VIRGULE; \
Eblock \
ECa1 \
\
Defo \
Bblock \
TRAITEMENT_DES_CODES_STANDARDS; \
Eblock \
EDef \
Eblock \
ECho \
Eblock
#define EDITION_D_UN_CODE_2(caractere_1,caractere_2,code_a_generer) \
CAge(IFET(IFEQ(INTE(caractere_courant__),caractere_1) \
,IFEQ(INTE(caractere_suivant_1),caractere_2) \
) \
) \
Bblock \
EDITION_DU_CODE(code_a_generer); \
Eblock \
ECAg
#define EDITION_D_UN_CODE_3(caractere_1,caractere_2,caractere_3,code_a_generer) \
CAge(I3ET(IFEQ(INTE(caractere_courant__),caractere_1) \
,IFEQ(INTE(caractere_suivant_1),caractere_2) \
,IFEQ(INTE(caractere_suivant_2),caractere_3) \
) \
) \
Bblock \
EDITION_DU_CODE(code_a_generer); \
Eblock \
ECAg
#define EDITION_D_UN_CODE_4(caractere_1,caractere_2,caractere_3,caractere_4,code_a_generer) \
CAge(I4ET(IFEQ(INTE(caractere_courant__),caractere_1) \
,IFEQ(INTE(caractere_suivant_1),caractere_2) \
,IFEQ(INTE(caractere_suivant_2),caractere_3) \
,IFEQ(INTE(caractere_suivant_3),caractere_4) \
) \
) \
Bblock \
EDITION_DU_CODE(code_a_generer); \
Eblock \
ECAg
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T I O N D E S C O D E S N O N R E C O N N U S : */
/* */
/*************************************************************************************************************************************/
BFonctionV
#define NOMBRE_MINIMAL_DE_CHIFFRES_HEXADECIMAUX \
QUATRE \
/* Constante arbitraire faisant partie de la norme 'UTF-8'... */
DEFV(Common,DEFV(FonctionV,Generation_des_codes_non_reconnus(Nombre_de_composantes,ListeDesCodes,ListeDesMasques)))
/* Fonction inspiree de 'v $xtc/UTF_8.01$vv$c'... */
DEFV(Argument,DEFV(Int,Nombre_de_composantes));
DEFV(Argument,DEFV(CHAR,DTb0(ListeDesCodes)));
DEFV(Argument,DEFV(CHAR,DTb0(ListeDesMasques)));
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Int,INIT(CumulDesMasques,MASQUE_VIDE));
DEFV(Int,INIT(CumulDesCodes,MASQUE_VIDE));
DEFV(Int,INIT(DecalageCourant,ZERO));
DEFV(Int,INIT(index,UNDEF));
DEFV(CHAR,DTb1(code_genere,chain_taille("ZZx12345;")));
/* Le code donne en exemple ("ZZx12345;") correspond a la plus grande longueur possible... */
/*..............................................................................................................................*/
DoDe(index,PREMIER_CARACTERE,LSTX(PREMIER_CARACTERE,Nombre_de_composantes),I);
Bblock
DEFV(Positive,INIT(MasqueCourant,ITb0(ListeDesMasques,INDX(index,PREMIER_CARACTERE))));
DEFV(Positive,INIT(CodeCourant,ITb0(ListeDesCodes,INDX(index,PREMIER_CARACTERE))));
EGAL(CumulDesMasques,OUIN(CumulDesMasques,DECG(MasqueCourant,DecalageCourant)));
EGAL(CumulDesCodes,OUIN(CumulDesCodes,DECG(ETLO(CodeCourant,MasqueCourant),DecalageCourant)));
INCR(DecalageCourant,INTE(LO2X(FLOT(MASK_TO_P2(MasqueCourant)))));
Eblock
EDoD
CALS(SPrin2(code_genere
,"&#x%0*lX;"
,SHOR(MAX2(NOMBRE_MINIMAL_DE_CHIFFRES_HEXADECIMAUX
,DIVI(INTE(LO2X(FLOT(MASK_TO_P2(CumulDesMasques)))),NBITHX)
)
)
,CumulDesCodes
)
);
/* On notera que le "field width specifier '*'" attend un type 'int', d'ou le 'SHOR(...)'. */
EDITION_DU_CODE(code_genere);
RETU_VIDE
Eblock
EFonctionV
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N V E R S I O N D E C A R A C T E R E S C O D E S E N ' UTF-8 ' : */
/* */
/*************************************************************************************************************************************/
BCommande(nombre_d_arguments,arguments)
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
DEFV(Logical,INIT(mode_UTF_8,MODE_UTF_8));
/* S'agit-il du mode 'UTF-8' ('VRAI') ou du mode 'ASCII' ('FAUX') ? */
DEFV(Logical,INIT(editer_le_mode_ascii_en_hexadecimal,EDITER_LE_MODE_ASCII_EN_HEXADECIMAL));
/* En mode 'ASCII' faut-il editer en hexadecimal ('VRAI') ou des caracteres ('FAUX') ? */
DEFV(Positive,INIT(longueur_approximative_des_lignes,LONGUEUR_APPROXIMATIVE_DES_LIGNES));
/* Longueur approximative des lignes a generer... */
DEFV(Logical,INIT(generer_les_codes_non_definis,GENERER_LES_CODES_NON_DEFINIS));
/* Faut-il generer ('VRAI') les codes non reconnus ou bien interrompre le processus */
/* ('FAUX') ? Ceci fut introduit le 20250207103836... */
/*..............................................................................................................................*/
EGAL(Prme_____changer_le_stream,VRAI);
EGAL(Prer_____changer_le_stream,VRAI);
/* Et ce afin que toutes les sorties utilisent le meme "stream"... */
GET_ARGUMENTS_(nombre_d_arguments
,BLOC(GET_ARGUMENT_L("UTF_8=""U8=",mode_UTF_8);
GET_ARGUMENT_N("ASCII=""AS=",mode_UTF_8);
GET_ARGUMENT_L("hexadecimal=""hexa=",editer_le_mode_ascii_en_hexadecimal);
GET_ARGUMENT_I("longueur_lignes=""ll=",longueur_approximative_des_lignes);
GET_ARGUMENT_L("generer_codes=",generer_les_codes_non_definis);
)
);
begin_nouveau_block
Bblock
DEFV(CHAR,INIT(caractere_courant__,K_UNDEF));
/* Caractere courant. */
Tant(GetcharT(caractere_courant__))
Bblock
/* Le caractere courant de l'entree courante est recupere ; et on boucle */
/* sur cette recuperation tant que l'on n'est pas au bout du fichier. */
Test(IL_FAUT(mode_UTF_8))
/* Cas du mode 'UTF-8' : */
Bblock
Test(INCLff(INTE(caractere_courant__)
,DEBUT_CODES_CARACTERES_1_
,FIN___CODES_CARACTERES_1_
)
)
Bblock
Choi(caractere_courant__)
Bblock
Ca1e(K_PLUS)
Bblock
TRAITEMENT_DU_CODE_ADDITION;
Eblock
ECa1
Ca1e(K_VIRGULE)
Bblock
TRAITEMENT_DU_CODE_VIRGULE;
Eblock
ECa1
Defo
Bblock
/* Tous les caracteres "standards" sont transmis integralement, sauf 'K_BLANC' lorsqu'il */
/* y a decoupage des lignes trop longues... */
TRAITEMENT_DES_CODES_STANDARDS;
/* Et ce afin d'unifier toutes les sorties... */
Eblock
EDef
Eblock
ECho
Eblock
ATes
Bblock
Eblock
ETes
Test(INCLff(INTE(caractere_courant__)
,DEBUT_CODES_CARACTERES_2_
,FIN___CODES_CARACTERES_2_
)
)
Bblock
DEFV(CHAR,INIT(caractere_suivant_1,K_UNDEF));
GET_CARACTERE_SUIVANT(caractere_suivant_1);
CHoi(VRAI)
/* Le 'VRAI' est du au fait que les expressions logiques des 'CAge(...)' doivent etre */
/* vraies lorsqu'un double code est reconnu... */
Bblock
EDITION_D_UN_CODE_2(0xC2,0xB2,EXTENSION_M4("MiseEnExposant(2)"));
EDITION_D_UN_CODE_2(0xC2,0xB3,EXTENSION_M4("MiseEnExposant(3)"));
EDITION_D_UN_CODE_2(0xC3,0x80,EXTENSION_xiMoG("Ag"));
EDITION_D_UN_CODE_2(0xC3,0x81,EXTENSION_xiMoG("Aa"));
EDITION_D_UN_CODE_2(0xC3,0x88,EXTENSION_xiMoG("Eg"));
EDITION_D_UN_CODE_2(0xC3,0x89,EXTENSION_xiMoG("Ea"));
EDITION_D_UN_CODE_2(0xC3,0x8A,EXTENSION_xiMoG("Ec"));
EDITION_D_UN_CODE_2(0xC3,0x94,EXTENSION_xiMoG("Oc"));
EDITION_D_UN_CODE_2(0xC3,0x97,"×");
EDITION_D_UN_CODE_2(0xC3,0x9C,EXTENSION_xiMoG("oE"));
EDITION_D_UN_CODE_2(0xC3,0xA0,EXTENSION_xiMoG("aG"));
EDITION_D_UN_CODE_2(0xC3,0xA1,EXTENSION_xiMoG("aA"));
EDITION_D_UN_CODE_2(0xC3,0xA2,EXTENSION_xiMoG("aC"));
EDITION_D_UN_CODE_2(0xC3,0xA4,EXTENSION_xiMoG("aT"));
EDITION_D_UN_CODE_2(0xC3,0xA6,EXTENSION_xiMoG("aE"));
EDITION_D_UN_CODE_2(0xC3,0xA7,EXTENSION_xiMoG("cC"));
EDITION_D_UN_CODE_2(0xC3,0xA8,EXTENSION_xiMoG("eG"));
EDITION_D_UN_CODE_2(0xC3,0xA9,EXTENSION_xiMoG("eA"));
EDITION_D_UN_CODE_2(0xC3,0xAA,EXTENSION_xiMoG("eC"));
EDITION_D_UN_CODE_2(0xC3,0xAB,EXTENSION_xiMoG("eT"));
EDITION_D_UN_CODE_2(0xC3,0xAE,EXTENSION_xiMoG("iC"));
EDITION_D_UN_CODE_2(0xC3,0xAF,EXTENSION_xiMoG("iT"));
EDITION_D_UN_CODE_2(0xC3,0xB2,"ò");
EDITION_D_UN_CODE_2(0xC3,0xB3,"ó");
EDITION_D_UN_CODE_2(0xC3,0xB4,EXTENSION_xiMoG("oC"));
EDITION_D_UN_CODE_2(0xC3,0xB6,EXTENSION_xiMoG("oT"));
EDITION_D_UN_CODE_2(0xC3,0xB9,EXTENSION_xiMoG("uG"));
EDITION_D_UN_CODE_2(0xC3,0xBB,EXTENSION_xiMoG("uC"));
EDITION_D_UN_CODE_2(0xC3,0xBC,EXTENSION_xiMoG("uT"));
EDITION_D_UN_CODE_2(0xC5,0x93,EXTENSION_xiMoG("oE"));
EDITION_D_UN_CODE_2(0xCB,0x86,"ˆ");
EDITION_D_UN_CODE_2(0xCB,0x8A,"ˊ");
EDITION_D_UN_CODE_2(0xCB,0x8B,"ˋ");
EDITION_D_UN_CODE_2(0xCF,0x80,"π");
EDITION_D_UN_CODE_2(0xCF,0x81,"ρ");
EDITION_D_UN_CODE_2(0xCF,0x82,"ς");
EDITION_D_UN_CODE_2(0xCF,0x83,"σ");
EDITION_D_UN_CODE_2(0xCF,0x84,"τ");
EDITION_D_UN_CODE_2(0xCF,0x85,"υ");
EDITION_D_UN_CODE_2(0xCF,0x86,"φ");
EDITION_D_UN_CODE_2(0xCF,0x87,"χ");
EDITION_D_UN_CODE_2(0xCF,0x88,"ψ");
EDITION_D_UN_CODE_2(0xCF,0x89,"ω");
DEfo
Bblock
Test(IL_FAUT(generer_les_codes_non_definis))
/* Test introduit le 20250207103836... */
Bblock
DEFV(CHAR,INIS(DTb0(ListeDesCodes)
,IstructL02(caractere_courant__
,caractere_suivant_1
)
)
);
DEFV(CHAR,INIS(DTb0(ListeDesMasques)
,IstructL02(MASQUE_CARACTERES_2__1
,MASQUE_CARACTERES_2__2
)
)
);
CALS(Generation_des_codes_non_reconnus(DEUX,ListeDesCodes,ListeDesMasques));
Eblock
ATes
Bblock
PRINT_ERREUR("un double code de type 2 n'est pas reconnu");
CAL1(Prer4("(ce double code de type 2 vaut /0x%*X 0x%*X/)"
,NHXOC,INTE(caractere_courant__)
,NHXOC,INTE(caractere_suivant_1)
)
);
Exit(PROBLEMES);
Eblock
ETes
Eblock
EDEf
Eblock
ECho
Eblock
ATes
Bblock
Eblock
ETes
Test(INCLff(INTE(caractere_courant__)
,DEBUT_CODES_CARACTERES_3_
,FIN___CODES_CARACTERES_3_
)
)
Bblock
DEFV(CHAR,INIT(caractere_suivant_1,K_UNDEF));
DEFV(CHAR,INIT(caractere_suivant_2,K_UNDEF));
GET_CARACTERE_SUIVANT(caractere_suivant_1);
GET_CARACTERE_SUIVANT(caractere_suivant_2);
CHoi(VRAI)
/* Le 'VRAI' est du au fait que les expressions logiques des 'CAge(...)' doivent etre */
/* vraies lorsqu'un triple code est reconnu... */
Bblock
EDITION_D_UN_CODE_3(0xE0,0x20,0x74,EXTENSION_xiMoG("aG"));
EDITION_D_UN_CODE_3(0xE2,0x63,0x65,EXTENSION_xiMoG("aC"));
EDITION_D_UN_CODE_3(0xE2,0x80,0x8B,EXTENSION_M4("Mathematiques_RACX"));
EDITION_D_UN_CODE_3(0xE2,0x80,0x99,EXTENSION_xiMoG("QuOtE_SiMpLe"));
EDITION_D_UN_CODE_3(0xE2,0x80,0x94,"—");
EDITION_D_UN_CODE_3(0xE2,0x82,0x80,EXTENSION_M4("MiseEnIndice(0)"));
EDITION_D_UN_CODE_3(0xE2,0x82,0x81,EXTENSION_M4("MiseEnIndice(1)"));
EDITION_D_UN_CODE_3(0xE2,0x82,0x82,EXTENSION_M4("MiseEnIndice(2)"));
EDITION_D_UN_CODE_3(0xE2,0x82,0x83,EXTENSION_M4("MiseEnIndice(3)"));
EDITION_D_UN_CODE_3(0xE2,0x82,0x84,EXTENSION_M4("MiseEnIndice(4)"));
EDITION_D_UN_CODE_3(0xE2,0x82,0x85,EXTENSION_M4("MiseEnIndice(5)"));
EDITION_D_UN_CODE_3(0xE2,0x82,0x86,EXTENSION_M4("MiseEnIndice(6)"));
EDITION_D_UN_CODE_3(0xE2,0x82,0x87,EXTENSION_M4("MiseEnIndice(7)"));
EDITION_D_UN_CODE_3(0xE2,0x82,0x88,EXTENSION_M4("MiseEnIndice(8)"));
EDITION_D_UN_CODE_3(0xE2,0x82,0x89,EXTENSION_M4("MiseEnIndice(9)"));
EDITION_D_UN_CODE_3(0xE2,0x84,0xB5,EXTENSION_M4("Mathematiques_ALEF"));
EDITION_D_UN_CODE_3(0xE2,0x88,0x92,"−");
EDITION_D_UN_CODE_3(0xE2,0x89,0xA0,EXTENSION_M4("Mathematiques_NE"));
EDITION_D_UN_CODE_3(0xE2,0x89,0xA5,EXTENSION_M4("Mathematiques_GE"));
EDITION_D_UN_CODE_3(0xEE,0x80,0xA0,CODE_A_DEFINIR_ULTERIEUREMENT);
DEfo
Bblock
Test(IL_FAUT(generer_les_codes_non_definis))
/* Test introduit le 20250207103836... */
Bblock
DEFV(CHAR,INIS(DTb0(ListeDesCodes)
,IstructL03(caractere_courant__
,caractere_suivant_1
,caractere_suivant_2
)
)
);
DEFV(CHAR,INIS(DTb0(ListeDesMasques)
,IstructL03(MASQUE_CARACTERES_3__1
,MASQUE_CARACTERES_3__2
,MASQUE_CARACTERES_3__3
)
)
);
CALS(Generation_des_codes_non_reconnus(TROIS,ListeDesCodes,ListeDesMasques));
Eblock
ATes
Bblock
PRINT_ERREUR("un triple code de type 3 n'est pas reconnu");
CAL1(Prer6("(ce triple code de type 3 vaut /0x%*X 0x%*X 0x%*X/)"
,NHXOC,INTE(caractere_courant__)
,NHXOC,INTE(caractere_suivant_1)
,NHXOC,INTE(caractere_suivant_2)
)
);
/* La presence des 'INTE(...)'s est du aux formats 'X' (qui deviennent en fait des 'lX' */
/* dans 'v $ xig/xxxx$FON Ftraitement_des_formats_de_sortie') et qui faisait en l'absence */
/* des 'INTE(...)'s apparaitre le dernier caractere sous la forme '7FFF000000xx'... */
Exit(PROBLEMES);
Eblock
ETes
Eblock
EDEf
Eblock
ECHo
Eblock
ATes
Bblock
Eblock
ETes
Test(INCLff(INTE(caractere_courant__)
,DEBUT_CODES_CARACTERES_41
,FIN___CODES_CARACTERES_41
)
)
Bblock
DEFV(CHAR,INIT(caractere_suivant_1,K_UNDEF));
DEFV(CHAR,INIT(caractere_suivant_2,K_UNDEF));
DEFV(CHAR,INIT(caractere_suivant_3,K_UNDEF));
GET_CARACTERE_SUIVANT(caractere_suivant_1);
GET_CARACTERE_SUIVANT(caractere_suivant_2);
GET_CARACTERE_SUIVANT(caractere_suivant_3);
CHoi(VRAI)
/* Le 'VRAI' est du au fait que les expressions logiques des 'CAge(...)' doivent etre */
/* vraies lorsqu'un quadruple code est reconnu... */
Bblock
EDITION_D_UN_CODE_4(0xF0,0x9D,0x94,0xA0,"c");
EDITION_D_UN_CODE_4(0xF0,0x9F,0x98,0x8A,"😊");
DEfo
Bblock
Test(IL_FAUT(generer_les_codes_non_definis))
/* Test introduit le 20250207103836... */
Bblock
DEFV(CHAR,INIS(DTb0(ListeDesCodes)
,IstructL04(caractere_courant__
,caractere_suivant_1
,caractere_suivant_2
,caractere_suivant_3
)
)
);
DEFV(CHAR,INIS(DTb0(ListeDesMasques)
,IstructL04(MASQUE_CARACTERES_41_1
,MASQUE_CARACTERES_41_2
,MASQUE_CARACTERES_41_3
,MASQUE_CARACTERES_41_4
)
)
);
CALS(Generation_des_codes_non_reconnus(QUATRE,ListeDesCodes,ListeDesMasques));
Eblock
ATes
Bblock
PRINT_ERREUR("un quadruple code de type 41 n'est pas reconnu");
CAL1(Prer8("(ce quadruple code de type 41 vaut /0x%*X 0x%*X 0x%*X 0x%*X/)"
,NHXOC,INTE(caractere_courant__)
,NHXOC,INTE(caractere_suivant_1)
,NHXOC,INTE(caractere_suivant_2)
,NHXOC,INTE(caractere_suivant_3)
)
);
Exit(PROBLEMES);
Eblock
ETes
Eblock
EDEf
Eblock
ECHo
Eblock
ATes
Bblock
Eblock
ETes
Test(INCLff(INTE(caractere_courant__)
,DEBUT_CODES_CARACTERES_42
,FIN___CODES_CARACTERES_42
)
)
Bblock
DEFV(CHAR,INIT(caractere_suivant_1,K_UNDEF));
DEFV(CHAR,INIT(caractere_suivant_2,K_UNDEF));
DEFV(CHAR,INIT(caractere_suivant_3,K_UNDEF));
GET_CARACTERE_SUIVANT(caractere_suivant_1);
GET_CARACTERE_SUIVANT(caractere_suivant_2);
GET_CARACTERE_SUIVANT(caractere_suivant_3);
CHoi(VRAI)
/* Le 'VRAI' est du au fait que les expressions logiques des 'CAge(...)' doivent etre */
/* vraies lorsqu'un quadruple code est reconnu... */
Bblock
DEfo
Bblock
Test(IL_FAUT(generer_les_codes_non_definis))
/* Test introduit le 20250207103836... */
Bblock
DEFV(CHAR,INIS(DTb0(ListeDesCodes)
,IstructL04(caractere_courant__
,caractere_suivant_1
,caractere_suivant_2
,caractere_suivant_3
)
)
);
DEFV(CHAR,INIS(DTb0(ListeDesMasques)
,IstructL04(MASQUE_CARACTERES_42_1
,MASQUE_CARACTERES_42_2
,MASQUE_CARACTERES_42_3
,MASQUE_CARACTERES_42_4
)
)
);
CALS(Generation_des_codes_non_reconnus(QUATRE,ListeDesCodes,ListeDesMasques));
Eblock
ATes
Bblock
PRINT_ERREUR("un quadruple code de type 42 n'est pas reconnu");
CAL1(Prer8("(ce quadruple code de type 42 vaut /0x%*X 0x%*X 0x%*X 0x%*X/)"
,NHXOC,INTE(caractere_courant__)
,NHXOC,INTE(caractere_suivant_1)
,NHXOC,INTE(caractere_suivant_2)
,NHXOC,INTE(caractere_suivant_3)
)
);
Exit(PROBLEMES);
Eblock
ETes
Eblock
EDEf
Eblock
ECHo
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
/* Cas du mode 'ASCII' : */
Bblock
Test(IL_FAUT(editer_le_mode_ascii_en_hexadecimal))
Bblock
CAL2(Prin2("%02X = '%c'\n",caractere_courant__,caractere_courant__));
Eblock
ATes
TRAITEMENT_DES_CODES_ASCII;
ETes
Eblock
ETes
Eblock
ETan
Eblock
end_nouveau_block
RETU_Commande;
Eblock
ECommande