lcrzo_data(3)

NAME
lcrzo_data - bibliotheque lcrzo : manipulation de tableaux de donnees

CONTENU
/*    Bibliotheque reseau de Laurent Constantin (lcrzo)
                 Module lcrzo_data
  Les fonctions presentes dans ce module permettent gerer des
tableaux de donnees.
*/
/*-------------------------------------------------------------*/
/* ces typedefs sont utilises pour :
   lcrzo_data : tableau de donnees
   lcrzo_constdata : tableau de donnees non modifiables
   lcrzo_string : chaine de caracteres
   lcrzo_conststring : chaine de caracteres non modifiables
*/
typedef lcrzo_uint8* lcrzo_data;
typedef const lcrzo_uint8*  lcrzo_constdata;
typedef char* lcrzo_string;
typedef const char* lcrzo_conststring;
/*-------------------------------------------------------------*/
/**********************************************
 * Note sur les chaines mixtes :              *
 * Une chaine mixte permet de representer des *
 * donnees de maniere claire en utilisant de  *
 * l'hexadecimal et du texte.                 *
 * L'hexa est utilise sans "0x" ou "0h"       *
 * Le texte est inclus entre apostrophes "'"  *
 * Le caractere ' est double ('')             *
 * Par exemple :                              *
 *   'hello' : donnee "hello"                 *
 *   'a' 'b' : donnee "ab"                    *
 *   41 'b'  : donnee "Ab" (car 'A'==0x41)    *
 *   'man'00 : donnee "man" terminant par 0x00*
 *   'a''b'  : donnee "a'b"                   *
 * Exemples reels :                           *
 *  'salut' 0D 0A 'ceci est apres le newline' *
 *  'un' 09 'deux' 0D 0A                      *
 **********************************************/
typedef char* lcrzo_hexa;
typedef const char* lcrzo_consthexa;
typedef char* lcrzo_mixed;
typedef const char* lcrzo_constmixed;
typedef char* lcrzo_base64;
typedef const char* lcrzo_constbase64;
/*-------------------------------------------------------------*/
/**********************************************
 * Note sur les tailles :                     *
 *   les tailles sont toujours en octet       *
 **********************************************/
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_alloc
   Description :
     Alloue une zone de memoire.
   Parametre(s) d'entree :
     allocsize : taille de ce tableau
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pptr : pointeur qui sera alloue (la memoire
             devra etre liberee par l'utilisateur
	     avec 'lcrzo_data_free(*pdataout)' ou
             'free(*pdataout)').
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_alloc(lcrzo_int32 allocsize, lcrzo_data *pptr);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_realloc
   Description :
     Realloue une zone de memoire.
   Parametre(s) d'entree :
     newallocsize : nouvelle taille de ce tableau
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pptr : pointeur qui sera realloue (la memoire
             devra etre liberee par l'utilisateur
	     avec 'lcrzo_data_free(*pdataout)' ou
             'free(*pdataout)').
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_realloc(lcrzo_int32 newallocsize, lcrzo_data *pptr);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_free
   Description :
     Libere une zone de memoire.
   Parametre(s) d'entree :
     ptr : pointeur sur la zone memoire a allouer
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_free(lcrzo_data ptr);
/*-------------------------------------------------------------*/
/**********************************************
 * Note sur les indices :                     *
 * Les indices permettent d'acceder a des     *
 * intervalles de donnees.                    *
 * Par exemple, si on a 4 octets de donnees   *
 * contenant 'ABCD', on peut les representer  *
 * ainsi :                                    *
 *       +---+---+---+---+                    *
 *       | A | B | C | D |                    *
 *       +---+---+---+---+                    *
 * Les indices sont associes avec les         *
 * angles :                                   *
 *       1   2   3   4   5                    *
 *      -5  -4  -3  -2  -1                    *
 * Donc :                                     *
 *   intervalle [1,5]   est 'ABCD'            *
 *   intervalle [2,3]   est 'B'               *
 *   intervalle [3,3]   est '' (tableau vide) *
 *   intervalle [1,-1]  est 'ABCD'            *
 *   intervalle [2,-3]  est 'B'               *
 *   intervalle [3,1]   est 'BA'              *
 *   intervalle [-1,1]  est 'DCBA'            *
 *   intervalle [-2,-3] est 'C'               *
 *   etc.                                     *
 * Note : l'indice 0 (zero) est invalide      *
 **********************************************/
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_init_data
   Description :
     Initialise un tableau de donnees, avec un tableau de donnees
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     dataoutmaxsize : taille maximale qui peut etre stockee
                      dans dataout
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra une copie de datain
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKDATATRUNCATED : dataoutmaxsize a ete atteint
                                 avant d'avoir pu stocker les
				 donnees dans dataout
*/
int lcrzo_data_init_data(lcrzo_constdata datain,
			 lcrzo_int32 datainsize,
			 lcrzo_int32 dataoutmaxsize,
			 lcrzo_data dataout,
			 lcrzo_int32 *pdataoutsize);
/* Nom : lcrzo_data_initm_data
   Description :
     Alloue une zone de memoire et l'initialise avec un
     tableau de donnees
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pdataout : pointeur qui sera alloue (la memoire
                 devra etre liberee par l'utilisateur
		 avec 'free(*pdataout)').
		 Cette memoire allouee recevra une copie de
		 datain
     *pdataoutsize : taille atteinte par *pdataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_initm_data(lcrzo_constdata datain,
			  lcrzo_int32 datainsize,
			  lcrzo_data *pdataout,
			  lcrzo_int32 *pdataoutsize);
/* Nom : lcrzo_data_append_data
   Description :
     Complete un tableau de donnees, avec un tableau de donnees
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     dataoutcurrentsize : taille courante de dataout
     dataoutmaxsize : taille maximale qui peut etre stockee
                      dans dataout
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               datain sera concatene a dataout
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKDATATRUNCATED : dataoutmaxsize a ete atteint
                                 avant d'avoir pu stocker les
				 donnees dans dataout
*/
int lcrzo_data_append_data(lcrzo_constdata datain,
			    lcrzo_int32 datainsize,
			    lcrzo_int32 dataoutcurrentsize,
			    lcrzo_int32 dataoutmaxsize,
			    lcrzo_data dataout,
			    lcrzo_int32 *pdataoutsize);
/* Nom : lcrzo_data_appendm_data
   Description :
     Realloue une zone de memoire et la complete avec un
     tableau de donnees
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     dataoutcurrentsize : taille courante de *pdataout
   Parametre(s) d'entree-sortie :
     *pdataout : pointeur qui sera realloue (la memoire
                 devra etre liberee par l'utilisateur
                 avec 'free(*pdataout)').
                 datain sera concatene a *pdataout
   Parametre(s) de sortie :
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_appendm_data(lcrzo_constdata datain,
			    lcrzo_int32 datainsize,
			    lcrzo_int32 dataoutcurrentsize,
			    lcrzo_data *pdataout,
			    lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_init_range
   Description :
     Initialise un tableau de donnees, avec un intervalle de
     tableau de donnees
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     datainstartindex : indice de depart de l'intervalle a copier
     datainendindex : indice de fin de l'intervalle a copier
     dataoutmaxsize : taille maximale qui peut etre stockee
                      dans dataout
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra une copie de l'intervalle de
               datain
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKDATATRUNCATED : dataoutmaxsize a ete atteint
                                 avant d'avoir pu stocker les
                                 donnees dans dataout
*/
int lcrzo_data_init_range(lcrzo_constdata datain,
			  lcrzo_int32 datainsize,
			  lcrzo_int32 datainstartindex,
			  lcrzo_int32 datainendindex,
			  lcrzo_int32 dataoutmaxsize,
			  lcrzo_data dataout,
			  lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_range, mais alloue de la memoire. Lisez
   l'aide de lcrzo_data_initm_data pour avoir une explication
   du parametre utilise lorsque l'on alloue (pdataout)*/
int lcrzo_data_initm_range(lcrzo_constdata datain,
			   lcrzo_int32 datainsize,
			   lcrzo_int32 datainstartindex,
			   lcrzo_int32 datainendindex,
			   lcrzo_data *pdataout,
			   lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_range, mais concatene. Lisez l'aide
   de lcrzo_data_append_data pour avoir une explication du
   parametre utilise lors d'une concatenation (dataoutcurrentsize)*/
int lcrzo_data_append_range(lcrzo_constdata datain,
			    lcrzo_int32 datainsize,
			    lcrzo_int32 datainstartindex,
			    lcrzo_int32 datainendindex,
			    lcrzo_int32 dataoutcurrentsize,
			    lcrzo_int32 dataoutmaxsize,
			    lcrzo_data dataout,
			    lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_range, mais concatene */
int lcrzo_data_appendm_range(lcrzo_constdata datain,
			     lcrzo_int32 datainsize,
			     lcrzo_int32 datainstartindex,
			     lcrzo_int32 datainendindex,
			     lcrzo_int32 dataoutcurrentsize,
			     lcrzo_data *pdataout,
			     lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_init_fill
   Description :
     Initialise un tableau de donnees, avec un remplissage de
     donnees
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     fillingsize : taille de remplissage
     dataoutmaxsize : taille maximale qui peut etre stockee
                      dans dataout
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra un remplissage base sur datain
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKDATATRUNCATED : dataoutmaxsize a ete atteint
                                 avant d'avoir pu stocker les
                                 donnees dans dataout
*/
int lcrzo_data_init_fill(lcrzo_constdata datain,
                         lcrzo_int32 datainsize,
                         lcrzo_int32 fillingsize,
                         lcrzo_int32 dataoutmaxsize,
                         lcrzo_data dataout,
                         lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_fill, mais alloue de la memoire. Lisez
   l'aide de lcrzo_data_initm_data pour avoir une explication
   du parametre utilise lorsque l'on alloue (pdataout)*/
int lcrzo_data_initm_fill(lcrzo_constdata datain,
			  lcrzo_int32 datainsize,
			  lcrzo_int32 fillingsize,
			  lcrzo_data *pdataout,
			  lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_fill, mais concatene. Lisez l'aide
   de lcrzo_data_append_data pour avoir une explication du
   parametre utilise lors d'une concatenation (dataoutcurrentsize)*/
int lcrzo_data_append_fill(lcrzo_constdata datain,
                           lcrzo_int32 datainsize,
                           lcrzo_int32 fillingsize,
                           lcrzo_int32 dataoutcurrentsize,
                           lcrzo_int32 dataoutmaxsize,
                           lcrzo_data dataout,
                           lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_fill, mais concatene */
int lcrzo_data_appendm_fill(lcrzo_constdata datain,
			    lcrzo_int32 datainsize,
			    lcrzo_int32 fillingsize,
			    lcrzo_int32 dataoutcurrentsize,
			    lcrzo_data *pdataout,
			    lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_init_c
   Description :
     Initialise un tableau de donnees, avec un remplissage de
     caracteres
   Parametre(s) d'entree :
     c : caractere a utiliser pour le remplissage
     fillingsize : taille de remplissage
     dataoutmaxsize : taille maximale qui peut etre stockee
                      dans dataout
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra un remplissage de c
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKDATATRUNCATED : dataoutmaxsize a ete atteint
                                 avant d'avoir pu stocker les
                                 donnees dans dataout
*/
int lcrzo_data_init_char(lcrzo_uint8 c,
			 lcrzo_int32 fillingsize,
			 lcrzo_int32 dataoutmaxsize,
			 lcrzo_data dataout,
			 lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_char, mais alloue de la memoire. Lisez
   l'aide de lcrzo_data_initm_data pour avoir une explication
   du parametre utilise lorsque l'on alloue (pdataout)*/
int lcrzo_data_initm_char(lcrzo_uint8 c,
			  lcrzo_int32 fillingsize,
			  lcrzo_data *pdataout,
			  lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_char, mais concatene. Lisez l'aide
   de lcrzo_data_append_data pour avoir une explication du
   parametre utilise lors d'une concatenation (dataoutcurrentsize)*/
int lcrzo_data_append_char(lcrzo_uint8 c,
			   lcrzo_int32 fillingsize,
			   lcrzo_int32 dataoutcurrentsize,
			   lcrzo_int32 dataoutmaxsize,
			   lcrzo_data dataout,
			   lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_char, mais concatene */
int lcrzo_data_appendm_char(lcrzo_uint8 c,
			    lcrzo_int32 fillingsize,
			    lcrzo_int32 dataoutcurrentsize,
			    lcrzo_data *pdataout,
			    lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_init_rand
   Description :
     Initialise un tableau de donnees, avec un remplissage de
     caracteres aleatoires
   Parametre(s) d'entree :
     minvalue : valeur minimale des caracteres aleatoires
     maxvalue : valeur maximale des caracteres aleatoires
     fillingsize : taille de remplissage
     dataoutmaxsize : taille maximale qui peut etre stockee
                      dans dataout
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra un remplissage de caracteres
	       aleatoires compris entre minvalue et maxvalue
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKDATATRUNCATED : dataoutmaxsize a ete atteint
                                 avant d'avoir pu stocker les
                                 donnees dans dataout
*/
int lcrzo_data_init_rand(lcrzo_uint8 minvalue,
			 lcrzo_uint8 maxvalue,
			 lcrzo_int32 fillingsize,
			 lcrzo_int32 dataoutmaxsize,
			 lcrzo_data dataout,
			 lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_rand, mais alloue de la memoire. Lisez
   l'aide de lcrzo_data_initm_data pour avoir une explication
   du parametre utilise lorsque l'on alloue (pdataout)*/
int lcrzo_data_initm_rand(lcrzo_uint8 minvalue,
			  lcrzo_uint8 maxvalue,
			  lcrzo_int32 fillingsize,
			  lcrzo_data *pdataout,
			  lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_rand, mais concatene. Lisez l'aide
   de lcrzo_data_append_data pour avoir une explication du
   parametre utilise lors d'une concatenation (dataoutcurrentsize)*/
int lcrzo_data_append_rand(lcrzo_uint8 minvalue,
			   lcrzo_uint8 maxvalue,
			   lcrzo_int32 fillingsize,
			   lcrzo_int32 dataoutcurrentsize,
			   lcrzo_int32 dataoutmaxsize,
			   lcrzo_data dataout,
			   lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_rand, mais concatene */
int lcrzo_data_appendm_rand(lcrzo_uint8 minvalue,
			    lcrzo_uint8 maxvalue,
			    lcrzo_int32 fillingsize,
			    lcrzo_int32 dataoutcurrentsize,
			    lcrzo_data *pdataout,
			    lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_init_int
   Description :
     Initialise un tableau de donnees, avec un entier
   Parametre(s) d'entree :
     integer : entier a utiliser
     format : format (printf) a utiliser sur 'integer'
              Ce format doit respecter :
                 "%[0+-.]{0,1}[1-9]{0,2}[l]{0,1}[douxX]"
              Par exemple : "%d", "%3x", "%08lX", etc.
     dataoutmaxsize : taille maximale qui peut etre stockee
                      dans dataout
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra l'entier selon le format
	       'format'
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKDATATRUNCATED : dataoutmaxsize a ete atteint
                                 avant d'avoir pu stocker les
                                 donnees dans dataout
*/
int lcrzo_data_init_int(lcrzo_int32 integer,
			lcrzo_conststring format,
			lcrzo_int32 dataoutmaxsize,
			lcrzo_data dataout,
			lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_int, mais alloue de la memoire. Lisez
   l'aide de lcrzo_data_initm_data pour avoir une explication
   du parametre utilise lorsque l'on alloue (pdataout)*/
int lcrzo_data_initm_int(lcrzo_int32 integer,
			 lcrzo_conststring format,
			 lcrzo_data *pdataout,
			 lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_int, mais concatene. Lisez l'aide
   de lcrzo_data_append_data pour avoir une explication du
   parametre utilise lors d'une concatenation (dataoutcurrentsize)*/
int lcrzo_data_append_int(lcrzo_int32 integer,
			  lcrzo_conststring format,
			  lcrzo_int32 dataoutcurrentsize,
			  lcrzo_int32 dataoutmaxsize,
			  lcrzo_data dataout,
			  lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_int, mais concatene */
int lcrzo_data_appendm_int(lcrzo_int32 integer,
			   lcrzo_conststring format,
			   lcrzo_int32 dataoutcurrentsize,
			   lcrzo_data *pdataout,
			   lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_init_text
   Description :
     Initialise un tableau de donnees, avec du texte
   Parametre(s) d'entree :
     text : texte a utiliser
     dataoutmaxsize : taille maximale qui peut etre stockee
                      dans dataout
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra le texte
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKDATATRUNCATED : dataoutmaxsize a ete atteint
                                 avant d'avoir pu stocker les
                                 donnees dans dataout
*/
int lcrzo_data_init_text(lcrzo_conststring text,
			 lcrzo_int32 dataoutmaxsize,
			 lcrzo_data dataout,
			 lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_text, mais alloue de la memoire. Lisez
   l'aide de lcrzo_data_initm_data pour avoir une explication
   du parametre utilise lorsque l'on alloue (pdataout)*/
int lcrzo_data_initm_text(lcrzo_conststring text,
			  lcrzo_data *pdataout,
			  lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_text, mais concatene. Lisez l'aide
   de lcrzo_data_append_data pour avoir une explication du
   parametre utilise lors d'une concatenation (dataoutcurrentsize)*/
int lcrzo_data_append_text(lcrzo_conststring text,
			   lcrzo_int32 dataoutcurrentsize,
			   lcrzo_int32 dataoutmaxsize,
			   lcrzo_data dataout,
			   lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_text, mais concatene */
int lcrzo_data_appendm_text(lcrzo_conststring text,
			    lcrzo_int32 dataoutcurrentsize,
			    lcrzo_data *pdataout,
			    lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_init_coretext
   Description :
     Initialise un tableau de donnees, avec du texte.
     Ce texte est purge avant emploi : les espaces, tabulations,
     et sauts de lignes en debut ou fin de chaine sont supprimes
   Parametre(s) d'entree :
     text : texte a purger, puis a utiliser
     dataoutmaxsize : taille maximale qui peut etre stockee
                      dans dataout
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra le texte purge
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKDATATRUNCATED : dataoutmaxsize a ete atteint
                                 avant d'avoir pu stocker les
                                 donnees dans dataout
*/
int lcrzo_data_init_coretext(lcrzo_conststring text,
			     lcrzo_int32 dataoutmaxsize,
			     lcrzo_data dataout,
			     lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_coretext, mais alloue de la memoire. Lisez
   l'aide de lcrzo_data_initm_data pour avoir une explication
   du parametre utilise lorsque l'on alloue (pdataout)*/
int lcrzo_data_initm_coretext(lcrzo_conststring text,
			      lcrzo_data *pdataout,
			      lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_coretext, mais concatene. Lisez l'aide
   de lcrzo_data_append_data pour avoir une explication du
   parametre utilise lors d'une concatenation (dataoutcurrentsize)*/
int lcrzo_data_append_coretext(lcrzo_conststring text,
			       lcrzo_int32 dataoutcurrentsize,
			       lcrzo_int32 dataoutmaxsize,
			       lcrzo_data dataout,
			       lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_coretext, mais concatene */
int lcrzo_data_appendm_coretext(lcrzo_conststring text,
				lcrzo_int32 dataoutcurrentsize,
				lcrzo_data *pdataout,
				lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_init_hexa
   Description :
     Initialise un tableau de donnees, avec des donnees
     representees sous forme hexadecimale
   Parametre(s) d'entree :
     hexa : chaine hexa ("45D2" signifie les 2 octets 0x45 0xD2)
     dataoutmaxsize : taille maximale qui peut etre stockee
                      dans dataout
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra les donnees equivalentes
	       a la chaine hexa
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKDATATRUNCATED : dataoutmaxsize a ete atteint
                                 avant d'avoir pu stocker les
                                 donnees dans dataout
*/
int lcrzo_data_init_hexa(lcrzo_consthexa hexa,
			 lcrzo_int32 dataoutmaxsize,
			 lcrzo_data dataout,
			 lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_hexa, mais alloue de la memoire. Lisez
   l'aide de lcrzo_data_initm_data pour avoir une explication
   du parametre utilise lorsque l'on alloue (pdataout)*/
int lcrzo_data_initm_hexa(lcrzo_consthexa hexa,
			  lcrzo_data *pdataout,
			  lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_hexa, mais concatene. Lisez l'aide
   de lcrzo_data_append_data pour avoir une explication du
   parametre utilise lors d'une concatenation (dataoutcurrentsize)*/
int lcrzo_data_append_hexa(lcrzo_consthexa hexa,
			   lcrzo_int32 dataoutcurrentsize,
			   lcrzo_int32 dataoutmaxsize,
			   lcrzo_data dataout,
			   lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_hexa, mais concatene */
int lcrzo_data_appendm_hexa(lcrzo_consthexa hexa,
			    lcrzo_int32 dataoutcurrentsize,
			    lcrzo_data *pdataout,
			    lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_init_mixed
   Description :
     Initialise un tableau de donnees, avec des donnees
     representees sous forme mixte
   Parametre(s) d'entree :
     mixed : chaine mixte (cf. le cadre, en haut de l'aide
             de ce module, decrivant ce qu'est une chaine mixte)
     dataoutmaxsize : taille maximale qui peut etre stockee
                      dans dataout
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra les donnees equivalentes
	       a la chaine mixte
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKDATATRUNCATED : dataoutmaxsize a ete atteint
                                 avant d'avoir pu stocker les
                                 donnees dans dataout
*/
int lcrzo_data_init_mixed(lcrzo_constmixed mixed,
			  lcrzo_int32 dataoutmaxsize,
			  lcrzo_data dataout,
			  lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_mixed, mais alloue de la memoire. Lisez
   l'aide de lcrzo_data_initm_data pour avoir une explication
   du parametre utilise lorsque l'on alloue (pdataout)*/
int lcrzo_data_initm_mixed(lcrzo_constmixed mixed,
			   lcrzo_data *pdataout,
			   lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_mixed, mais concatene. Lisez l'aide
   de lcrzo_data_append_data pour avoir une explication du
   parametre utilise lors d'une concatenation (dataoutcurrentsize)*/
int lcrzo_data_append_mixed(lcrzo_constmixed mixed,
			    lcrzo_int32 dataoutcurrentsize,
			    lcrzo_int32 dataoutmaxsize,
			    lcrzo_data dataout,
			    lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_mixed, mais concatene */
int lcrzo_data_appendm_mixed(lcrzo_constmixed mixed,
			     lcrzo_int32 dataoutcurrentsize,
			     lcrzo_data *pdataout,
			     lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_init_base64
   Description :
     Initialise un tableau de donnees, avec des donnees
     representees sous forme base64
   Parametre(s) d'entree :
     base64 : chaine en base64
     dataoutmaxsize : taille maximale qui peut etre stockee
                      dans dataout
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra les donnees equivalentes
	       a la chaine base64
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
     LCRZO_ERR_OKDATATRUNCATED : dataoutmaxsize a ete atteint
                                 avant d'avoir pu stocker les
                                 donnees dans dataout
*/
int lcrzo_data_init_base64(lcrzo_constbase64 base64,
			   lcrzo_int32 dataoutmaxsize,
			   lcrzo_data dataout,
			   lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_base64, mais alloue de la memoire. Lisez
   l'aide de lcrzo_data_initm_data pour avoir une explication
   du parametre utilise lorsque l'on alloue (pdataout)*/
int lcrzo_data_initm_base64(lcrzo_constbase64 base64,
			    lcrzo_data *pdataout,
			    lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_init_base64, mais concatene. Lisez l'aide
   de lcrzo_data_append_data pour avoir une explication du
   parametre utilise lors d'une concatenation (dataoutcurrentsize)*/
int lcrzo_data_append_base64(lcrzo_constbase64 base64,
			     lcrzo_int32 dataoutcurrentsize,
			     lcrzo_int32 dataoutmaxsize,
			     lcrzo_data dataout,
			     lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_base64, mais concatene */
int lcrzo_data_appendm_base64(lcrzo_constbase64 base64,
			      lcrzo_int32 dataoutcurrentsize,
			      lcrzo_data *pdataout,
			      lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_initm_text_stdin
   Description :
     Initialise un tableau de donnees, avec du texte entre
     par l'utilisateur
   Parametre(s) d'entree :
     message : message a afficher avant de demander a
               l'utilisateur l'entrer du texte
     defaulttext : texte a utiliser si l'utilisateur n'entre rien
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra le texte
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_initm_text_stdin(lcrzo_conststring message,
				lcrzo_conststring defaulttext,
				lcrzo_data *pdataout,
				lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_text_stdin, mais concatene */
int lcrzo_data_appendm_text_stdin(lcrzo_conststring message,
				  lcrzo_conststring defaulttext,
				  lcrzo_int32 dataoutcurrentsize,
				  lcrzo_data *pdataout,
				  lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_initm_coretext_stdin
   Description :
     Initialise un tableau de donnees, avec du texte entre
     par l'utilisateur.
     Ce texte est purge avant emploi : les espaces, tabulations,
     et sauts de lignes en debut ou fin de chaine sont supprimes
   Parametre(s) d'entree :
     message : message a afficher avant de demander a
               l'utilisateur l'entrer du texte
     defaultcoretext : texte a utiliser si l'utilisateur
                       n'entre rien
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra le texte
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_initm_coretext_stdin(lcrzo_conststring message,
				    lcrzo_conststring defaultcoretext,
				    lcrzo_data *pdataout,
				    lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_coretext_stdin, mais concatene */
int lcrzo_data_appendm_coretext_stdin(lcrzo_conststring message,
				      lcrzo_conststring defaultcoretext,
				      lcrzo_int32 dataoutcurrentsize,
				      lcrzo_data *pdataout,
				      lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_initm_text_passwd
   Description :
     Initialise un tableau de donnees, avec du texte entre
     par l'utilisateur. Ce texte ne s'affiche pas a l'ecran.
   Parametre(s) d'entree :
     message : message a afficher avant de demander a
               l'utilisateur l'entrer du texte
     defaulttext : texte a utiliser si l'utilisateur n'entre rien
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra le texte
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_initm_text_passwd(lcrzo_conststring message,
				 lcrzo_conststring defaulttext,
				 lcrzo_data *pdataout,
				 lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_text_passwd, mais concatene */
int lcrzo_data_appendm_text_passwd(lcrzo_conststring message,
				   lcrzo_conststring defaulttext,
				   lcrzo_int32 dataoutcurrentsize,
				   lcrzo_data *pdataout,
				   lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_initm_coretext_passwd
   Description :
     Initialise un tableau de donnees, avec du texte entre
     par l'utilisateur.
     Ce texte est purge avant emploi : les espaces, tabulations,
     et sauts de lignes en debut ou fin de chaine sont supprimes.
     Ce texte ne s'affiche pas a l'ecran.
   Parametre(s) d'entree :
     message : message a afficher avant de demander a
               l'utilisateur l'entrer du texte
     defaultcoretext : texte a utiliser si l'utilisateur
                       n'entre rien
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra le texte
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_initm_coretext_passwd(lcrzo_conststring message,
				     lcrzo_conststring defaultcoretext,
				     lcrzo_data *pdataout,
				     lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_coretext_passwd, mais concatene */
int lcrzo_data_appendm_coretext_passwd(lcrzo_conststring message,
				       lcrzo_conststring defaultcoretext,
				       lcrzo_int32 dataoutcurrentsize,
				       lcrzo_data *pdataout,
				       lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_initm_hexa_stdin
   Description :
     Initialise un tableau de donnees, avec des donnees
     representees sous forme hexadecimale, saisies
     par l'utilisateur
   Parametre(s) d'entree :
     message : message a afficher avant de demander a
               l'utilisateur l'entrer de l'hexa
     defaulthexa: hexa a utiliser si l'utilisateur n'entre rien
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra les donnees equivalentes
               a la chaine hexa
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_initm_hexa_stdin(lcrzo_conststring message,
				lcrzo_consthexa defaulthexa,
				lcrzo_data *pdataout,
				lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_hexa_stdin, mais concatene */
int lcrzo_data_appendm_hexa_stdin(lcrzo_conststring message,
				  lcrzo_consthexa defaulthexa,
				  lcrzo_int32 dataoutcurrentsize,
				  lcrzo_data *pdataout,
				  lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_initm_mixed_stdin
   Description :
     Initialise un tableau de donnees, avec des donnees
     representees sous forme mixte, saisies  par l'utilisateur
     (cf. le  cadre, en haut de l'aide de ce module, decrivant ce
     qu'est une chaine mixte)
   Parametre(s) d'entree :
     message : message a afficher avant de demander a
               l'utilisateur l'entrer du mixte
     defaultmixed: chaine mixte a utiliser si l'utilisateur
                   n'entre rien
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra les donnees equivalentes
               a la chaine mixte
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_initm_mixed_stdin(lcrzo_conststring message,
				 lcrzo_constmixed defaultmixed,
				 lcrzo_data *pdataout,
				 lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_mixed_stdin, mais concatene */
int lcrzo_data_appendm_mixed_stdin(lcrzo_conststring message,
				   lcrzo_constmixed defaultmixed,
				   lcrzo_int32 dataoutcurrentsize,
				   lcrzo_data *pdataout,
				   lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_initm_base64_stdin
   Description :
     Initialise un tableau de donnees, avec des donnees
     representees sous forme base64, saisies par l'utilisateur
   Parametre(s) d'entree :
     message : message a afficher avant de demander a
               l'utilisateur l'entrer du base64
     defaultbase64: base64 a utiliser si l'utilisateur n'entre rien
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     dataout : tableau de sortie.
               Ce tableau recevra les donnees equivalentes
               a la chaine base64
     *pdataoutsize : taille atteinte par dataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_initm_base64_stdin(lcrzo_conststring message,
				  lcrzo_constbase64 defaultbase64,
				  lcrzo_data *pdataout,
				  lcrzo_int32 *pdataoutsize);
/* idem lcrzo_data_initm_base64_stdin, mais concatene */
int lcrzo_data_appendm_base64_stdin(lcrzo_conststring message,
				    lcrzo_constbase64 defaultbase64,
				    lcrzo_int32 dataoutcurrentsize,
				    lcrzo_data *pdataout,
				    lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* un lcrzo_regexp est un tableau contenant les positions trouvees
   lors d'une recherche par expression reguliere (faites "man regexp"
   si vous ne savez pas ce qu'est une expression reguliere).
   L'element a l'indice 0 definit la place de l'expression globale
   trouvee.
   Les elements a l'indice 1, 2, etc. definissent les donnees
   trouvees entre '(' et ')'.
   Les elements dont la valeur est 0 indiquent la fin.
   Par exemple, si les donnees sont "papier" et l'expression
   reguliere est "a(.(i))", alors :
          +---+---+---+---+---+---+
	  | p | a | p | i | e | r |
	  +---+---+---+---+---+---+
	  1   2   3   4   5   6   7
	 -7  -6  -5  -4  -3  -2  -1
     'regexp[0]' indique "api", donc :
          regexp[0].startindex_negative == -6
	  regexp[0].startindex_positive == 2
	  regexp[0].endindex_negative == -3
	  regexp[0].endindex_positive == 5
     'regexp[1]' indique "pi", donc :
          regexp[0].startindex_negative == -5
	  regexp[0].startindex_positive == 3
	  regexp[0].endindex_negative == -3
	  regexp[0].endindex_positive == 5
     'regexp[2]' indique "i", donc :
          regexp[0].startindex_negative == -4
	  regexp[0].startindex_positive == 4
	  regexp[0].endindex_negative == -3
	  regexp[0].endindex_positive == 5
     tous les regexp[i] avec i>2 indiquent la fin, donc :
          regexp[0].startindex_negative == 0
	  regexp[0].startindex_positive == 0
	  regexp[0].endindex_negative == 0
	  regexp[0].endindex_positive == 0
*/
/* on ne peut pas avoir plus de 30 parentheses. Cela doit
   etre suffisant dans tous les cas, mais vous pouvez choisir
   une valeur plus grande.*/
#define LCRZO_REGEXP_MAXPAIRS 30
typedef struct
{ lcrzo_int32 startindex_negative;
  lcrzo_int32 startindex_positive;
  lcrzo_int32 endindex_negative;
  lcrzo_int32 endindex_positive;
} lcrzo_regexp[LCRZO_REGEXP_MAXPAIRS+1];
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_search_char
   Description :
     Cherche un caractere dans un tableau de donnees
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     searchcomplement : si 0, cherche c
                        sinon, cherche un caractere different de c
     datainstartindex : indice de depart de l'intervalle a chercher
                        La signification des 'indices' est donnee
			au debut de l'aide de ce module.
     datainendindex : indice de fin de l'intervalle a chercher
     c : caractere a chercher
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pfoundindex_negative : indice du caractere trouve
                             (negative, car compte depuis la fin)
     *pfoundindex_positive : indice du caractere trouve
                             (positive, car compte depuis le debut)
   Valeurs de retour normales :
     LCRZO_ERR_OK : l'element cherche a ete trouve
     LCRZO_ERR_OKSEARCHNOTFOUND : l'element cherche n'a pas ete trouve
*/
int lcrzo_data_search_char(lcrzo_constdata datain,
			   lcrzo_int32 datainsize,
			   lcrzo_bool searchcomplement,
			   lcrzo_int32 datainstartindex,
			   lcrzo_int32 datainendindex,
			   lcrzo_uint8 c,
			   lcrzo_int32 *pfoundindex_negative,
			   lcrzo_int32 *pfoundindex_positive);
/* Nom : lcrzo_data_search_nchar
   Description :
     Cherche un ensemble de caracteres dans un tableau de donnees
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     searchcomplement : si 0, cherche un caractere dans l'ensemble
                        sinon, cherche un caractere n'etant pas dans
			l'ensemble
     datainstartindex : indice de depart de l'intervalle a chercher
                        La signification des 'indices' est donnee
			au debut de l'aide de ce module.
     datainendindex : indice de fin de l'intervalle a chercher
     searchlist : tableau contenant l'ensemble des caracteres a
                  chercher. Par exemple, utilisez "aRt" pour chercher
		  'a', 'R' ou 't'
     searchlistsize : taille de ce tableau
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pfoundindex_negative : indice du caractere trouve
                             (negative, car compte depuis la fin)
     *pfoundindex_positive : indice du caractere trouve
                             (positive, car compte depuis le debut)
   Valeurs de retour normales :
     LCRZO_ERR_OK : l'element cherche a ete trouve
     LCRZO_ERR_OKSEARCHNOTFOUND : l'element cherche n'a pas ete trouve
*/
int lcrzo_data_search_nchar(lcrzo_constdata datain,
			    lcrzo_int32 datainsize,
			    lcrzo_bool searchcomplement,
			    lcrzo_int32 datainstartindex,
			    lcrzo_int32 datainendindex,
			    lcrzo_constdata searchlist,
			    lcrzo_int32 searchlistsize,
			    lcrzo_int32 *pfoundindex_negative,
			    lcrzo_int32 *pfoundindex_positive);
/* Nom : lcrzo_data_search_data
   Description :
     Cherche des donnees dans un tableau de donnees
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     searchcomplement : si 0, cherche un caractere dans l'ensemble
                        sinon, cherche un caractere n'etant pas dans
			l'ensemble
     datainstartindex : indice de depart de l'intervalle a chercher
                        La signification des 'indices' est donnee
			au debut de l'aide de ce module.
     datainendindex : indice de fin de l'intervalle a chercher
     searcheddata : donnees a chercher dans datain
     searcheddatasize : taille de searcheddata
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pstartfoundindex_negative : indice du caractere du debut des
                                  donnees trouvees
				  (negative, car compte depuis la fin)
     *pstartfoundindex_positive : indice du caractere du debut des
                                  donnees trouvees
				  (positive, car compte depuis le debut)
     *pendfoundindex_negative : indice du caractere de fin des
                                donnees trouvees
     *pendfoundindex_positive : indice du caractere de fin des
                                donnees trouvees
   Valeurs de retour normales :
     LCRZO_ERR_OK : l'element cherche a ete trouve
     LCRZO_ERR_OKSEARCHNOTFOUND : l'element cherche n'a pas ete trouve
*/
int lcrzo_data_search_data(lcrzo_constdata datain,
			   lcrzo_int32 datainsize,
			   lcrzo_bool searchcomplement,
			   lcrzo_int32 datainstartindex,
			   lcrzo_int32 datainendindex,
			   lcrzo_constdata searcheddata,
			   lcrzo_int32 searcheddatasize,
			   lcrzo_int32 *pstartfoundindex_negative,
			   lcrzo_int32 *pstartfoundindex_positive,
			   lcrzo_int32 *pendfoundindex_negative,
			   lcrzo_int32 *pendfoundindex_positive);
/* Nom : lcrzo_data_search_text
   Description :
     Cherche une chaine de caracteres dans un tableau de donnees
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     searchcomplement : si 0, cherche un caractere dans l'ensemble
                        sinon, cherche un caractere n'etant pas dans
			l'ensemble
     datainstartindex : indice de depart de l'intervalle a chercher
                        La signification des 'indices' est donnee
			au debut de l'aide de ce module.
     datainendindex : indice de fin de l'intervalle a chercher
     searchedstring : chaine a chercher dans datain
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pstartfoundindex_negative : indice du caractere du debut des
                                  donnees trouvees
				  (negative, car compte depuis la fin)
     *pstartfoundindex_positive : indice du caractere du debut des
                                  donnees trouvees
				  (positive, car compte depuis le debut)
     *pendfoundindex_negative : indice du caractere de fin des
                                donnees trouvees
     *pendfoundindex_positive : indice du caractere de fin des
                                donnees trouvees
   Valeurs de retour normales :
     LCRZO_ERR_OK : l'element cherche a ete trouve
     LCRZO_ERR_OKSEARCHNOTFOUND : l'element cherche n'a pas ete trouve
*/
int lcrzo_data_search_text(lcrzo_constdata datain,
			   lcrzo_int32 datainsize,
			   lcrzo_bool searchcomplement,
			   lcrzo_int32 datainstartindex,
			   lcrzo_int32 datainendindex,
			   lcrzo_conststring searchedtext,
			   lcrzo_int32 *pstartfoundindex_negative,
			   lcrzo_int32 *pstartfoundindex_positive,
			   lcrzo_int32 *pendfoundindex_negative,
			   lcrzo_int32 *pendfoundindex_positive);
/* Nom : lcrzo_data_search_re
   Description :
     Cherche une expression reguliere dans un tableau de donnees
     ("man regexp" pour savoir ce qu'est une expression reguliere)
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     searchcomplement : si 0, cherche un caractere dans l'ensemble
                        sinon, cherche un caractere n'etant pas dans
			l'ensemble
     datainstartindex : indice de depart de l'intervalle a chercher
                        La signification des 'indices' est donnee
			au debut de l'aide de ce module.
     datainendindex : indice de fin de l'intervalle a chercher
     regularexpression : expression reguliere a chercher dans datain
                         Par exemple : "a.", "f[A-Z]", etc.
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pstartfoundindex_negative : indice du caractere du debut des
                                  donnees trouvees
				  (negative, car compte depuis la fin)
     *pstartfoundindex_positive : indice du caractere du debut des
                                  donnees trouvees
				  (positive, car compte depuis le debut)
     *pendfoundindex_negative : indice du caractere de fin des
                                donnees trouvees
     *pendfoundindex_positive : indice du caractere de fin des
                                donnees trouvees
   Valeurs de retour normales :
     LCRZO_ERR_OK : l'element cherche a ete trouve
     LCRZO_ERR_OKSEARCHNOTFOUND : l'element cherche n'a pas ete trouve
*/
int lcrzo_data_search_re(lcrzo_constdata datain,
			 lcrzo_int32 datainsize,
			 lcrzo_bool searchcomplement,
			 lcrzo_int32 datainstartindex,
			 lcrzo_int32 datainendindex,
			 lcrzo_conststring regularexpression,
			 lcrzo_int32 *pstartfoundindex_negative,
			 lcrzo_int32 *pstartfoundindex_positive,
			 lcrzo_int32 *pendfoundindex_negative,
			 lcrzo_int32 *pendfoundindex_positive);
/* Nom : lcrzo_data_search_regexp
   Description :
     Cherche une expression reguliere dans un tableau de donnees
     ("man regexp" pour savoir ce qu'est une expression reguliere)
     Cette fonction est plus complexe que "lcrzo_data_search_re"
     car on retourne un tableau lcrzo_regexp complet.
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     searchcomplement : si 0, cherche un caractere dans l'ensemble
                        sinon, cherche un caractere n'etant pas dans
			l'ensemble
     datainstartindex : indice de depart de l'intervalle a chercher
                        La signification des 'indices' est donnee
			au debut de l'aide de ce module.
     datainendindex : indice de fin de l'intervalle a chercher
     regularexpression : expression reguliere a chercher dans datain
                         Par exemple : "a.", "f[A-Z]", etc.
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     arrayfoundindex : lcrzo_regexp contenant les indices des
                        donnees trouvees
   Valeurs de retour normales :
     LCRZO_ERR_OK : l'element cherche a ete trouve
     LCRZO_ERR_OKSEARCHNOTFOUND : l'element cherche n'a pas ete trouve
*/
int lcrzo_data_search_regexp(lcrzo_constdata datain,
			     lcrzo_int32 datainsize,
			     lcrzo_bool searchcomplement,
			     lcrzo_int32 datainstartindex,
			     lcrzo_int32 datainendindex,
			     lcrzo_conststring regularexpression,
			     lcrzo_regexp arrayfoundindex);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_token_char
   Description :
     Cette fonction trouve des donnes comprises entre des
     delimiteurs.
     Cette fonction a ete concue pour etre utilisee dans
     une boucle.
     Les delimiteurs sont des caracteres.
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     searchcomplement : si 0, cherche c
                        sinon, cherche un caractere different de c
     datainstartindex : indice de depart de l'intervalle a chercher
                        La signification des 'indices' est donnee
                        au debut de l'aide de ce module.
     datainendindex : indice de fin de l'intervalle a chercher
     c : caractere utilise comme delimiteur
   Parametre(s) d'entree-sortie :
     *pindexindicator : cette variable est utilisee en interne.
                        Elle doit etre affecte a zero lors du
			premier appel de la fonction
   Parametre(s) de sortie :
     *pstartfoundindex_negative : indice du caractere du debut des
                                  donnees trouvees
				  (negative, car compte depuis la fin)
     *pstartfoundindex_positive : indice du caractere du debut des
                                  donnees trouvees
				  (positive, car compte depuis le debut)
     *pendfoundindex_negative : indice du caractere de fin des
                                donnees trouvees
     *pendfoundindex_positive : indice du caractere de fin des
                                donnees trouvees
   Valeurs de retour normales :
     LCRZO_ERR_OK : on a trouve de donnees
     LCRZO_ERR_OKDATAEND : datainendindex a ete atteint
   Example :
     p=0;
     while (1)
     { ret=lcrzo_data_token_char("badbebcebe", 10, 0, +1, -1,
                                 'b', &p, NULL, &inf, NULL, &sup);
       if (ret==LCRZO_ERR_OKDATAEND) break;
       else if (ret!=LCRZO_ERR_OK)   return(ret);
       /maintenant, on peut utiliser inf et sup/
       ...
     }
     Dans cet exemple, la boucle va travailler sur
     "", "ad", "e", "ce" et "e".
*/
int lcrzo_data_token_char(lcrzo_constdata datain,
			  lcrzo_int32 datainsize,
			  lcrzo_bool searchcomplement,
			  lcrzo_int32 datainstartindex,
			  lcrzo_int32 datainendindex,
			  lcrzo_uint8 c,
			  lcrzo_int32 *pindexindicator,
			  lcrzo_int32 *pstartfoundindex_negative,
			  lcrzo_int32 *pstartfoundindex_positive,
			  lcrzo_int32 *pendfoundindex_negative,
			  lcrzo_int32 *pendfoundindex_positive);
/* Nom : lcrzo_data_token_nchar
   Description :
     Cette fonction trouve des donnes comprises entre des
     delimiteurs.
     Cette fonction a ete concue pour etre utilisee dans
     une boucle.
     Le delimiteur est un ensemble de caracteres.
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     searchcomplement : si 0, cherche c
                        sinon, cherche un caractere different de c
     datainstartindex : indice de depart de l'intervalle a chercher
                        La signification des 'indices' est donnee
                        au debut de l'aide de ce module.
     datainendindex : indice de fin de l'intervalle a chercher
     searchlist : tableau contenant l'ensemble des caracteres a
                  utiliser comme delimiteur
     searchlistsize : taille de ce tableau
   Parametre(s) d'entree-sortie :
     *pindexindicator : cette variable est utilisee en interne.
                        Elle doit etre affecte a zero lors du
			premier appel de la fonction
   Parametre(s) de sortie :
     *pstartfoundindex_negative : indice du caractere du debut des
                                  donnees trouvees
				  (negative, car compte depuis la fin)
     *pstartfoundindex_positive : indice du caractere du debut des
                                  donnees trouvees
				  (positive, car compte depuis le debut)
     *pendfoundindex_negative : indice du caractere de fin des
                                donnees trouvees
     *pendfoundindex_positive : indice du caractere de fin des
                                donnees trouvees
   Valeurs de retour normales :
     LCRZO_ERR_OK : on a trouve de donnees
     LCRZO_ERR_OKDATAEND : datainendindex a ete atteint
   Exemple :
     regardez l'aide de lcrzo_data_token_char
*/
int lcrzo_data_token_nchar(lcrzo_constdata datain,
			   lcrzo_int32 datainsize,
			   lcrzo_bool searchcomplement,
			   lcrzo_int32 datainstartindex,
			   lcrzo_int32 datainendindex,
			   lcrzo_constdata searchlist,
			   lcrzo_int32 searchlistsize,
			   lcrzo_int32 *pindexindicator,
			   lcrzo_int32 *pstartfoundindex_negative,
			   lcrzo_int32 *pstartfoundindex_positive,
			   lcrzo_int32 *pendfoundindex_negative,
			   lcrzo_int32 *pendfoundindex_positive);
/* Nom : lcrzo_data_token_data
   Description :
     Cette fonction trouve des donnes comprises entre des
     delimiteurs.
     Cette fonction a ete concue pour etre utilisee dans
     une boucle.
     Le delimiteur est un tableau de donnees.
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     searchcomplement : si 0, cherche c
                        sinon, cherche un caractere different de c
     datainstartindex : indice de depart de l'intervalle a chercher
                        La signification des 'indices' est donnee
                        au debut de l'aide de ce module.
     datainendindex : indice de fin de l'intervalle a chercher
     searcheddata : donnees a utiliser comme delimiteur
     searcheddatasize : taille de searcheddata
   Parametre(s) d'entree-sortie :
     *pindexindicator : cette variable est utilisee en interne.
                        Elle doit etre affecte a zero lors du
			premier appel de la fonction
   Parametre(s) de sortie :
     *pstartfoundindex_negative : indice du caractere du debut des
                                  donnees trouvees
				  (negative, car compte depuis la fin)
     *pstartfoundindex_positive : indice du caractere du debut des
                                  donnees trouvees
				  (positive, car compte depuis le debut)
     *pendfoundindex_negative : indice du caractere de fin des
                                donnees trouvees
     *pendfoundindex_positive : indice du caractere de fin des
                                donnees trouvees
   Valeurs de retour normales :
     LCRZO_ERR_OK : on a trouve de donnees
     LCRZO_ERR_OKDATAEND : datainendindex a ete atteint
   Exemple :
     regardez l'aide de lcrzo_data_token_char
*/
int lcrzo_data_token_data(lcrzo_constdata datain,
			  lcrzo_int32 datainsize,
			  lcrzo_bool searchcomplement,
			  lcrzo_int32 datainstartindex,
			  lcrzo_int32 datainendindex,
			  lcrzo_constdata searcheddata,
			  lcrzo_int32 searcheddatasize,
			  lcrzo_int32 *pindexindicator,
			  lcrzo_int32 *pstartfoundindex_negative,
			  lcrzo_int32 *pstartfoundindex_positive,
			  lcrzo_int32 *pendfoundindex_negative,
			  lcrzo_int32 *pendfoundindex_positive);
/* Nom : lcrzo_data_token_text
   Description :
     Cette fonction trouve des donnes comprises entre des
     delimiteurs.
     Cette fonction a ete concue pour etre utilisee dans
     une boucle.
     Le delimiteur est une chaine de caracteres.
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     searchcomplement : si 0, cherche c
                        sinon, cherche un caractere different de c
     datainstartindex : indice de depart de l'intervalle a chercher
                        La signification des 'indices' est donnee
                        au debut de l'aide de ce module.
     datainendindex : indice de fin de l'intervalle a chercher
     searchedtext : chaine a utiliser comme delimiteur
   Parametre(s) d'entree-sortie :
     *pindexindicator : cette variable est utilisee en interne.
                        Elle doit etre affecte a zero lors du
			premier appel de la fonction
   Parametre(s) de sortie :
     *pstartfoundindex_negative : indice du caractere du debut des
                                  donnees trouvees
				  (negative, car compte depuis la fin)
     *pstartfoundindex_positive : indice du caractere du debut des
                                  donnees trouvees
				  (positive, car compte depuis le debut)
     *pendfoundindex_negative : indice du caractere de fin des
                                donnees trouvees
     *pendfoundindex_positive : indice du caractere de fin des
                                donnees trouvees
   Valeurs de retour normales :
     LCRZO_ERR_OK : on a trouve de donnees
     LCRZO_ERR_OKDATAEND : datainendindex a ete atteint
   Exemple :
     regardez l'aide de lcrzo_data_token_char
*/
int lcrzo_data_token_text(lcrzo_constdata datain,
			  lcrzo_int32 datainsize,
			  lcrzo_bool searchcomplement,
			  lcrzo_int32 datainstartindex,
			  lcrzo_int32 datainendindex,
			  lcrzo_conststring searchedtext,
			  lcrzo_int32 *pindexindicator,
			  lcrzo_int32 *pstartfoundindex_negative,
			  lcrzo_int32 *pstartfoundindex_positive,
			  lcrzo_int32 *pendfoundindex_negative,
			  lcrzo_int32 *pendfoundindex_positive);
/* Nom : lcrzo_data_token_re
   Description :
     Cette fonction trouve des donnes comprises entre des
     delimiteurs.
     Cette fonction a ete concue pour etre utilisee dans
     une boucle.
     Le delimiteur est une expression reguliere.
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     searchcomplement : si 0, cherche c
                        sinon, cherche un caractere different de c
     datainstartindex : indice de depart de l'intervalle a chercher
                        La signification des 'indices' est donnee
                        au debut de l'aide de ce module.
     datainendindex : indice de fin de l'intervalle a chercher
     regularexpression : expression reguliere a utiliser comme delimiteur
   Parametre(s) d'entree-sortie :
     *pindexindicator : cette variable est utilisee en interne.
                        Elle doit etre affecte a zero lors du
			premier appel de la fonction
   Parametre(s) de sortie :
     *pstartfoundindex_negative : indice du caractere du debut des
                                  donnees trouvees
				  (negative, car compte depuis la fin)
     *pstartfoundindex_positive : indice du caractere du debut des
                                  donnees trouvees
				  (positive, car compte depuis le debut)
     *pendfoundindex_negative : indice du caractere de fin des
                                donnees trouvees
     *pendfoundindex_positive : indice du caractere de fin des
                                donnees trouvees
   Valeurs de retour normales :
     LCRZO_ERR_OK : on a trouve de donnees
     LCRZO_ERR_OKDATAEND : datainendindex a ete atteint
   Exemple :
     regardez l'aide de lcrzo_data_token_char
*/
int lcrzo_data_token_re(lcrzo_constdata datain,
			lcrzo_int32 datainsize,
			lcrzo_bool searchcomplement,
			lcrzo_int32 datainstartindex,
			lcrzo_int32 datainendindex,
			lcrzo_conststring regularexpression,
			lcrzo_int32 *pindexindicator,
			lcrzo_int32 *pstartfoundindex_negative,
			lcrzo_int32 *pstartfoundindex_positive,
			lcrzo_int32 *pendfoundindex_negative,
			lcrzo_int32 *pendfoundindex_positive);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_replacem_char
   Description :
     Remplace un caractere dans un tableau de donnees.
     Le tableau de sortie est alloue
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
     searchcomplement : si 0, remplace c
                        sinon, remplace un caractere different de c
     datainstartindex : indice de depart de l'intervalle a chercher
                        La signification des 'indices' est donnee
                        au debut de l'aide de ce module.
     datainendindex : indice de fin de l'intervalle a chercher
     maxnumberofreplacement : nombre maxi de remplacements a
                              effectuer. La valeur zero indique
			      qu'il n'y a pas de limite.
     c_toreplace : caractere a remplacer
     data_replacing : donnees a employer pour le remplacement
     data_replacingsize : taille de data_replacing
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pdataout : pointeur qui sera alloue (la memoire
                 devra etre liberee par l'utilisateur
                 avec 'free(*pdataout)').
                 Cette memoire allouee recevra une copie de
                 datain
     *pdataoutsize : taille atteinte par *pdataout
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_replacem_char(lcrzo_constdata datain,
			     lcrzo_int32 datainsize,
			     lcrzo_bool searchcomplement,
			     lcrzo_int32 datainstartindex,
			     lcrzo_int32 datainendindex,
			     lcrzo_int32 maxnumberofreplacement,
			     lcrzo_uint8 c_toreplace,
			     lcrzo_constdata data_replacing,
			     lcrzo_int32 data_replacingsize,
			     lcrzo_data *pdataout,
			     lcrzo_int32 *pdataoutsize);
/* idem, mais remplace un ensemble de caracteres */
int lcrzo_data_replacem_nchar(lcrzo_constdata datain,
			      lcrzo_int32 datainsize,
			      lcrzo_bool searchcomplement,
			      lcrzo_int32 datainstartindex,
			      lcrzo_int32 datainendindex,
			      lcrzo_int32 maxnumberofreplacement,
			      lcrzo_constdata searchlist,
			      lcrzo_int32 searchlistsize,
			      lcrzo_constdata data_replacing,
			      lcrzo_int32 data_replacingsize,
			      lcrzo_data *pdataout,
			      lcrzo_int32 *pdataoutsize);
/* idem, mais remplace des donnees */
int lcrzo_data_replacem_data(lcrzo_constdata datain,
			     lcrzo_int32 datainsize,
			     lcrzo_bool searchcomplement,
			     lcrzo_int32 datainstartindex,
			     lcrzo_int32 datainendindex,
			     lcrzo_int32 maxnumberofreplacement,
			     lcrzo_constdata searcheddata,
			     lcrzo_int32 searcheddatasize,
			     lcrzo_constdata data_replacing,
			     lcrzo_int32 data_replacingsize,
			     lcrzo_data *pdataout,
			     lcrzo_int32 *pdataoutsize);
/* idem, mais remplace une chaine texte */
int lcrzo_data_replacem_text(lcrzo_constdata datain,
			     lcrzo_int32 datainsize,
			     lcrzo_bool searchcomplement,
			     lcrzo_int32 datainstartindex,
			     lcrzo_int32 datainendindex,
			     lcrzo_int32 maxnumberofreplacement,
			     lcrzo_conststring searchedtext,
			     lcrzo_constdata data_replacing,
			     lcrzo_int32 data_replacingsize,
			     lcrzo_data *pdataout,
			     lcrzo_int32 *pdataoutsize);
/* idem, mais remplace les donnees correspondant a une
   expression reguliere*/
int lcrzo_data_replacem_re(lcrzo_constdata datain,
			   lcrzo_int32 datainsize,
			   lcrzo_bool searchcomplement,
			   lcrzo_int32 datainstartindex,
			   lcrzo_int32 datainendindex,
			   lcrzo_int32 maxnumberofreplacement,
			   lcrzo_conststring regularexpression,
			   lcrzo_constdata data_replacing,
			   lcrzo_int32 data_replacingsize,
			   lcrzo_data *pdataout,
			   lcrzo_int32 *pdataoutsize);
/*La 'chainederemplacement' peut contenir $1 a $9 pour indiquer
  les parametres matches dans l'expression ("$$" correspond au
  vrai caractere '$').
  Par exemple :
   expression="a(.)b",    chainederemplacement="A$1$1"
   expression="a(.)(b.)", chainederemplacement="A$2$1"
*/
int lcrzo_data_replacem_regexp(lcrzo_constdata datain,
			       lcrzo_int32 datainsize,
			       lcrzo_bool searchcomplement,
			       lcrzo_int32 datainstartindex,
			       lcrzo_int32 datainendindex,
			       lcrzo_int32 maxnumberofreplacement,
			       lcrzo_conststring regularexpression,
			       lcrzo_constdata data_replacing,
			       lcrzo_int32 data_replacingsize,
			       lcrzo_data *pdataout,
			       lcrzo_int32 *pdataoutsize);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_hexa_initm_data
   Description :
     Initialise une chaine hexa, avec un tableau de donnees.
     La chaine hexa est allouee
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *phexaout : chaine de sortie
                 La memoire devra etre liberee par l'utilisateur
                 avec 'free(*phexaaout)'
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_hexa_initm_data(lcrzo_constdata datain,
			  lcrzo_int32 datainsize,
			  lcrzo_hexa *phexaout);
/* Nom : lcrzo_mixed_initm_data
   Description :
     Initialise une chaine mixed, avec un tableau de donnees.
     La chaine mixed est allouee
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pmixedout : chaine de sortie
                 La memoire devra etre liberee par l'utilisateur
                 avec 'free(*pmixedaout)'
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_mixed_initm_data(lcrzo_constdata datain,
			   lcrzo_int32 datainsize,
			   lcrzo_mixed *pmixedout);
/* Nom : lcrzo_base64_initm_data
   Description :
     Initialise une chaine base64, avec un tableau de donnees.
     La chaine base64 est allouee
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pbase64out : chaine de sortie
                 La memoire devra etre liberee par l'utilisateur
                 avec 'free(*pbase64aout)'
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_base64_initm_data(lcrzo_constdata datain,
			    lcrzo_int32 datainsize,
			    lcrzo_base64 *pbase64out);
/*-------------------------------------------------------------*/
/* Nom : lcrzo_data_checksum
   Description :
     Calcule le checksum d'un tableau de donnees.
   Parametre(s) d'entree :
     datain : tableau contenant les donnees d'entree
     datainsize : taille de ce tableau
   Parametre(s) d'entree-sortie :
   Parametre(s) de sortie :
     *pchecksum : checksum de datain.
                  Note : ce checksum est dans l'ordre 'host'
		         (et non dans l'ordre 'network')
   Valeurs de retour normales :
     LCRZO_ERR_OK : ok
*/
int lcrzo_data_checksum(lcrzo_constdata data,
			lcrzo_int32 datasize,
			lcrzo_uint16 *pchecksum);

VOIR AUSSI
lcrzo(3), lcrzo_types(3), lcrzo_data(3), lcrzo_string(3), lcrzo_time(3), lcrzo_file(3), lcrzo_address(3), lcrzo_device(3), lcrzo_list(3), lcrzo_process(3), lcrzo_ipc(3), lcrzo_header(3), lcrzo_ipopt(3), lcrzo_tcpopt(3), lcrzo_packet(3), lcrzo_icmp(3), lcrzo_print(3), lcrzo_record(3), lcrzo_conf(3), lcrzo_spoof(3), lcrzo_sniff(3), lcrzo_sock(3), lcrzo_wait(3), lcrzo_global(3), lcrzo_error(3) lcrzo_misc(3),