#ifndef H_ED_STR_20021226104232 #define H_ED_STR_20021226104232 #ifdef __cplusplus extern "C" { #endif /* --------------------------------------------------------------------- (c) ED 1998-2008 Projet : CLIB Fonction : Traitements de chaines Module : STR Fichier : STR.H Creation : 06-08-1998 Modification : 01-05-2008 --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- Journal 1.39 du 01-05-2008 STR_sub_dyn() accepte et retourne les sous-chaines vides 1.38 du 28-04-2008 Simplification et securisation de STR_sub_dyn() 1.37 du 24-02-2008 Simplification STR_count() 1.36 du 14-04-2005 Ajout de STR_ext_dyn() 1.35 du 17-01-2005 Ajout de STR_replace () 1.34 du 05-04-2004 Mise au point de STR_safecopy () . (remplir la chaine de 0s) 1.33 du 01-12-2003 Ajout de STR_nicmp () 1.32 du 19-06-2003 Ajoute MEM_dup() 1.31 du 26-05-2003 STR_dup() accepte maintenant la chaine vide "". 1.30 du 12-05-2003 Ajout de STR_safecopy() 1.29 du 30-04-2003 Ajout de 'sign' dans STR_is_decimal 1.28 du 30-04-2003 Ajout de STR_is_decimal() . Mise au point STR_cat_dyn() 1.27 du 18-02-2003 Mise au point STR_SkipSpaces() et STR_SkipNoSpaces() 1.26 du 14-02-2003 Ajout de STR_remove_car() 1.25 du 03-02-2003 Ajout de STR_format() 1.24 du 28-12-2002 Ajout de STR_count_sub() 1.23 du 26-12-2002 Normalisation des interfaces pour etre compatible . avec certains compilateur qui ne connaisent pas la . norme... 1.22 du 09-12-2002 Ajout de STR_subst 1.21 du 13-07-2002 LCLint 1.20 du 11-03-2002 Ajout de STR_stringize_dyn() 1.19 du 18-02-2002 Ajout de STR_cat_dyn() STR_sub_dyn 1.18 du 15-12-2000 STR_no_accent() devient STR_no_accent_ibm() 1.17 du 16-10-2000 Simplification de STR_dup() 1.16 du 11-10-2000 Ajoute STR_SkipSpaces() et STR_SkipNoSpaces() 1.15 du 27-04-2000 Ajoute STR_no_accent() 1.14 du 14-04-2000 Changement de strategie de STR_debug(). . Suppresion memoire dynamique, passage de . l'adresse / longueur en parametre. . L'ancienne STR_debug() devient STR_debug_dyn() . Caracteres seuls en int au lieu de char 1.13 du 13-04-2000 Correction formatage dans STR_debug() 1.12 du 17-01-2000 Tailles en size_t au lieu de int 1.11 du 07-01-2000 Casting strict ANSI pour sprintf() 1.10 du 13-12-1999 Parametres de STR_findsz() const. 1.9 du 10-11-1999 Ameliorations dans STR_debug() 1.8 du 08-11-1999 Ajout de STR_toupper() et STR_tolower() 1.7 du 27-10-1999 Ajout de controles dans STR_debug() 1.6 du 13-10-1999 Remplace calloc/free par sys_calloc/sys_free 1.5 du 13-10-1999 Ajout de STR_dup() equivallent au strdup() de Borland. 1.4 du 06-10-1999 Suppression de STR_FindCar() car deja fait par . strchr() Laisse macro de compatibilite. 1.3 du 11-01-1999 Ajoute STS_cdbg() 1.2 du 11-01-1999 Mise au point de STR_FindCar() 1.1 du 07-09-1998 STR_find() devient STR_FindCar() . Ajoute STR_FindSz() 1.0 du 06-08-1998 Version operationelle 0.0 du 06-08-1998 Creation --------------------------------------------------------------------- */ #include /* macros ============================================================== */ /* constants =========================================================== */ /* types =============================================================== */ /* structures ========================================================== */ /* internal public data ================================================ */ /* internal public functions =========================================== */ /* entry points ======================================================== */ /* --------------------------------------------------------------------- STR_sver() --------------------------------------------------------------------- Role : Retourne une chaine "Version" --------------------------------------------------------------------- E : S : Pointeur de chaine ASCIIZ --------------------------------------------------------------------- */ const char *STR_sver (void); /* --------------------------------------------------------------------- STR_sid() --------------------------------------------------------------------- Role : Retourne une chaine "Identification" --------------------------------------------------------------------- E : S : Pointeur de chaine ASCIIZ --------------------------------------------------------------------- */ const char *STR_sid (void); /* --------------------------------------------------------------------- STR_DelBlanks() --------------------------------------------------------------------- Suppression des blancs dans une chaine LA CHAINE EST MODIFIEE !!! --------------------------------------------------------------------- E : Chaine initiale S : --------------------------------------------------------------------- */ void STR_DelBlanks (char *const s); /* --------------------------------------------------------------------- STR_SkipCrLf() --------------------------------------------------------------------- Elimine les CR/LF au debut de la chaine LA CHAINE EST MODIFIEE !!! --------------------------------------------------------------------- E : Chaine S : Debut de la chaine sans CR et LF --------------------------------------------------------------------- */ char *STR_SkipCrLf (char *const s); /* --------------------------------------------------------------------- STR_FindSz() --------------------------------------------------------------------- Role : Recherche d'une chaine dans un tableau de chaine --------------------------------------------------------------------- E : tableau E : nombre d'elements E : chaine S : rang ou -1 si pas trouve --------------------------------------------------------------------- */ int STR_FindSz (char const *const *const asz ,size_t const n ,char const *const s); /* --------------------------------------------------------------------- STR_cdbg() --------------------------------------------------------------------- Role : Renvoyer une chaine "debug" si le caractere est non imprimable, sinon, renvoyer NULL. --------------------------------------------------------------------- E : caractere (0-255) S : chaine debug ou NULL --------------------------------------------------------------------- */ char const *STR_cdbg (int const c); /* --------------------------------------------------------------------- STR_debug() --------------------------------------------------------------------- Role : Retourne la chaine debugee : Les codes non imprimables sont remplaces par des subsituts imprimables. En cas de debordement, la chaine se termine par "..." --------------------------------------------------------------------- E : chaine originale (n'est pas modifiee) E : chaine resultat E : longueur max de la chaine resultat S : 0=normal 1=tronque --------------------------------------------------------------------- */ int STR_debug (char *const des ,size_t const len ,char const *const src); /* --------------------------------------------------------------------- STR_debug_dyn() --------------------------------------------------------------------- Role : Retourne la chaine debugee : Les codes non imprimables sont remplaces par des subsituts imprimables. Liberation par sys_free() --------------------------------------------------------------------- E : chaine originale (n'est pas modifiee) S : chaine resultat ( *** a liberer *** ) --------------------------------------------------------------------- */ char *STR_debug_dyn (char const *const src); /* --------------------------------------------------------------------- MEM_dup() --------------------------------------------------------------------- faire une copie dynamique d'un bloc de donnees --------------------------------------------------------------------- I: adresse I: longueur (si 0 -> NULL) O: adresse de la copie ou NULL --------------------------------------------------------------------- */ void *MEM_dup (void const *const p, size_t const n); /* --------------------------------------------------------------------- STR_dup() --------------------------------------------------------------------- Effectue une copie de la chaine en memoire dynamique. Retourne NULL en cas d'erreur (ptr NULL , chaine vide). Le pointeur doit etre libere par free(). Equivallent de strdup() de Borland --------------------------------------------------------------------- E : Chaine originale (non modifiable) S : Copie modifiable (memoire dynamique) --------------------------------------------------------------------- */ char *STR_dup (const char *const s); /* --------------------------------------------------------------------- STR_toupper() --------------------------------------------------------------------- Convertir une chaine en majuscule. La chaine est modifiee. Retourne l'adresse de la chaine originale Equivallent de strupr() de Borland --------------------------------------------------------------------- E : Chaine originale (modifiable) S : Adresse de la chaine originale --------------------------------------------------------------------- */ char *STR_toupper (char *const s); /* --------------------------------------------------------------------- STR_tolower() --------------------------------------------------------------------- Convertir une chaine en minuscules. La chaine est modifiee. Retourne l'adresse de la chaine originale Equivallent de strupr() de Borland --------------------------------------------------------------------- E : Chaine originale (modifiable) S : Adresse de la chaine originale --------------------------------------------------------------------- */ char *STR_tolower (char *const s); /* --------------------------------------------------------------------- STR_no_accent_ibm() --------------------------------------------------------------------- Retire les accents d'une chaine (ASCII) Retourne l'adresse de la chaine --------------------------------------------------------------------- E : Chaine originale (modifiable) S : Adresse de la chaine originale --------------------------------------------------------------------- */ char *STR_no_accent_ibm (char *const s); /* --------------------------------------------------------------------- STR_SkipTrailingSpc() --------------------------------------------------------------------- Retire les espaces en fin de chaine Retourne le nombre d'espaces retires --------------------------------------------------------------------- E : Chaine originale (modifiable) S : Nombre d'espaces retires --------------------------------------------------------------------- */ int STR_SkipTrailingSpc (char *const s); /* --------------------------------------------------------------------- STR_SkipSpaces() --------------------------------------------------------------------- Role : retourne un pointeur sur le premier caractere non espace --------------------------------------------------------------------- E : S : pointeur --------------------------------------------------------------------- */ char const *STR_SkipSpaces (char const *const s); /* --------------------------------------------------------------------- STR_SkipNoSpaces() --------------------------------------------------------------------- Role : retourne un pointeur sur le premier caractere espace --------------------------------------------------------------------- E : chaine S : pointeur --------------------------------------------------------------------- */ char const *STR_SkipNoSpaces (char const *const s); /* --------------------------------------------------------------------- STR_count () --------------------------------------------------------------------- Compte les occurences d'un caracteres dans une chaine --------------------------------------------------------------------- E : S : --------------------------------------------------------------------- */ size_t STR_count (char const *s, int const c); /* --------------------------------------------------------------------- STR_count_sub () --------------------------------------------------------------------- Compte les occurences d'une sous-chaine dans une chaine --------------------------------------------------------------------- E : S : --------------------------------------------------------------------- */ size_t STR_count_sub (char const *const s, char const *const sub); /* --------------------------------------------------------------------- STR_cat_dyn () --------------------------------------------------------------------- Concatene deux chaines en une troisieme plus grande A liberer. --------------------------------------------------------------------- E : chaine initiale E : chaine a ajouter S : chaine resultante --------------------------------------------------------------------- */ char *STR_cat_dyn (char const *const sini, char const *const sadd); /* --------------------------------------------------------------------- STR_sub_dyn () --------------------------------------------------------------------- Fait une copie d'une sous chaine entre deux pointeurs A liberer. --------------------------------------------------------------------- E : debut E : fin --------------------------------------------------------------------- */ char *STR_sub_dyn (char const *const pbeg ,char const *const pend); /* --------------------------------------------------------------------- STR_ext_dyn () --------------------------------------------------------------------- Fait une copie d'une sous chaine definie par (adresse, longueur) A liberer. --------------------------------------------------------------------- E : debut E : longueur --------------------------------------------------------------------- */ char *STR_ext_dyn (char const *const pbeg ,size_t const len); /* --------------------------------------------------------------------- STR_stringize_dyn () --------------------------------------------------------------------- Mettre des "" autour d'une chaine Suppression des blancs en fin de chaine 'abc def ' -> '"abc def"' A liberer. --------------------------------------------------------------------- E : chaine initiale S : chaine resultante --------------------------------------------------------------------- */ char *STR_stringize_dyn (char const *const s_in); /* --------------------------------------------------------------------- STR_subst () --------------------------------------------------------------------- Dans une chaine, remplace un caractere par un autre. La chaine doit etre modifiable. --------------------------------------------------------------------- E : chaine initiale E : ancien caractere E : nouveau caractere S : chaine resultante --------------------------------------------------------------------- */ char *STR_subst (char *const s_in, int const old, int const new_); /* --------------------------------------------------------------------- STR_format () --------------------------------------------------------------------- Cree une chaine a partire d'une autre. La chaine format permet de specifier quels sont les catacteres qui sont forces en majuscule ou en minuscule. Si la chaine format est plus courte que la chaine source, le dernier format est maintenu. "X" "abcd" -> "ABCD" "Xx" "abcd" -> "Abcd" "xxX" "abcd" -> "abCD" --------------------------------------------------------------------- E : chaine de destination E : taille de la chaine de destination E : chaine de formatage E : chaine de source S : --------------------------------------------------------------------- */ void STR_format (char *const s_out ,size_t const size ,char const *const s_fmt ,char const *const s_in); /* --------------------------------------------------------------------- STR_remove_car() --------------------------------------------------------------------- --------------------------------------------------------------------- I: O: --------------------------------------------------------------------- */ void STR_remove_car (char *const s, int const car); /* --------------------------------------------------------------------- STR_is_decimal() --------------------------------------------------------------------- Is a string decimal ? Two cases : sign = 0 : '0'-'9'['0'-'9'[*]]0 -> "123" is valid -> "12a3" is invalid -> "-123" is invalid sign = 1 : ['+'|''-']'0'-'9'['0'-'9'[*]]0 -> "123" is valid -> "12a3" is invalid -> "-123" is valid --------------------------------------------------------------------- I: string I: sign 0 = refuse 1 = accept O: 0=no 1=yes --------------------------------------------------------------------- */ int STR_is_decimal (char const *const s, int sign); /* --------------------------------------------------------------------- STR_safecopy() --------------------------------------------------------------------- copie de chaine securisee En cs de depassement, la chaine est tronquee --------------------------------------------------------------------- I: adr destination I: taille destination I: adr source O: adr destination --------------------------------------------------------------------- */ char *STR_safecopy (char *const des ,size_t const size ,char const *const src); int STR_nicmp (char const *str1 ,char const *str2 ,int cnt); int STR_replace (char *str, int c_old, int c_new); /* public data ========================================================= */ /* File generated by 'NEW.EXE' Ver 1.12 (c) ED 1998 */ #ifdef __cplusplus } #endif #endif /* H_ED_STR_20021226104232 */ /* GUARD (c) ED 2000-2002 Dec 16 2002 Ver. 1.4 */