cos2000v2/lib/string.c

402 lines
9.2 KiB
C
Raw Normal View History

#include <string.h>
/******************************************************************************/
/* Compare 2 chaines de caract<63>re et renvoie la premiere distance (diff) */
s8 strcmp(const u8 * src, const u8 * dest)
{
register s8 result;
do {
if ((result = *src - *dest++) != 0)
break;
}
while (*src++ != 0);
return result;
}
/******************************************************************************/
/* Trouve la premiere occurence d'un caract<63>re dans une chaine et renvoie un pointeur */
u8 *strchr(const u8 * src, u8 achar)
{
for (; *src != achar; ++src)
if (*src == 0)
return 0;
return (u8 *) src;
}
/******************************************************************************/
/* Trouve la premiere occurence d'un caract<63>re dans une chaine */
u32 strchrpos(const u8 * src, u8 achar)
{
u32 i;
for (i=0; *(src+i) != achar; ++i)
if (*(src+i) == 0)
return 0;
return i;
}
/******************************************************************************/
/* Renvoie la taille de la chaine */
u32 strlen(const u8 * src)
{
u32 size;
for (size = 0; *(src + size) != 0; size++) ;
return size;
}
/******************************************************************************/
/* copie une chaine dans une autre */
u8 *strcpy(const u8 * src, u8 * dest)
{
u8 *temp = dest;
while ((*dest++ = *src++) != 0) ;
return temp;
}
/******************************************************************************/
/* copie une portion limit<69> d'une chaine asciiZ*/
u8 *strncpy(const u8 * src, u8 * dest, u32 count)
{
u8 *temp = dest;
while (count) {
if ((*temp = *src) != 0)
src++;
temp++;
count--;
}
return dest;
}
/******************************************************************************/
/* concatene 2 chaines de caract<63>re */
u8 *strcat(const u8 * src, u8 * dest)
{
u8 *temp = dest;
while (*dest != 0)
dest++;
while ((*dest++ = *src++) != 0) ;
return temp;
}
/******************************************************************************/
/* Met en minuscule */
void strtolower(u8 * src)
{
while (*src != 0) {
if ((*src >= 'A') && (*src <= 'Z'))
*src=*src+'a'-'A';
src++;
}
}
/******************************************************************************/
/* Met en majuscule */
void strtoupper(u8 * src)
{
while (*src != 0) {
if ((*src >= 'a') && (*src <= 'z'))
*src=*src-('a'-'A');
src++;
}
}
/******************************************************************************/
/* inverse la casse */
void strinvertcase(u8 * src)
{
while (*src != 0) {
if ((*src >= 'A') && (*src <= 'Z'))
*src=*src+'a'-'A';
else if ((*src >= 'a') && (*src <= 'z'))
*src=*src-('a'-'A');
src++;
}
}
/******************************************************************************/
/* Met une majuscule et met le reste en minuscule */
void stronecase(u8 * src)
{
if ((*src >= 'a') && (*src <= 'z'))
*src=*src-('a'-'A');
while (*src != 0) {
src++;
if ((*src >= 'A') && (*src <= 'Z'))
*src=*src+'a'-'A';
}
}
/******************************************************************************/
/* Fixe la taille de la chaine */
void strsetlen(u8 * src, u32 size)
{
*(src+size)='\000';
}
/******************************************************************************/
/* Inverse la chaine */
void strinvert(u8 *src)
{
u8 *dst=src+strlen(src)-1;
while (src < dst) {
u8 char1=*dst;
u8 char2=*src;
*dst=char2;
*src=char1;
src++;
dst--;
}
}
/******************************************************************************/
/* Remplace tout les caract<63>res rechercher par un autre */
void strreplace(u8 *src, u8 search, u8 replaced)
{
u8 *pos=strchr(src, search);
while (pos!=0)
{
*pos=replaced;
pos=strchr(src, search);
}
}
/******************************************************************************/
/* Rempli de caract<63>re */
u8 *strfill(u8 *dst, u8 pattern, u32 size)
{
u32 i;
for (i=0; i <= size; i++)
*(dst+i)=pattern;
*(dst+i+1)='\000';
return dst;
}
/******************************************************************************/
/* Renvoie la partie gauche d'une chaine */
void strleft(u8 *src, u8 *dest, u32 size) {
u32 i;
for (i = 0; (*(src + i) != 0) && (i<size); i++)
*dest++=*(src + i);
*dest++='\000';
}
/******************************************************************************/
/* Renvoie la partie droite d'une chaine */
void strright(u8 *src, u8 *dest, u32 size) {
u32 i;
u32 begin=strlen(src)-size;
for (i = 0; (*(src + i + begin) != 0) && (i<size); i++)
*dest++=*(src + i + begin);
*dest++='\000';
}
/******************************************************************************/
/* Supprime une portion de chaine */
void strdelete(u8 *src, u32 index, u32 size) {
u32 i;
u32 realsize=strlen(src)-index-size;
for (i = 0; (*(src+index+size+i) != 0) && (i<realsize); i++)
*(src+index+i)=*(src+index+size+i);
*(src+index+i)='\000';
}
/******************************************************************************/
/* Insert une portion dans la chaine */
void strinsert(u8 *src, u8 *dest, u32 index) {
u32 i;
u32 realsize=strlen(src);
u32 copysize=strlen(dest)-index;
for (i = 0; i<=copysize; i++)
*(dest+index+realsize+copysize-i)=*(dest+index+copysize-i);
for (i = 0; (*(src+i) != 0) ; i++)
*(dest+index+i)=*(src+i);
}
/******************************************************************************/
/* Supprime les d<>limiteurs cons<6E>cutifs */
void strcompressdelimiter(u8 *src, u8 delim) {
u8 *pos=strchr(src, delim);
while (pos!=0)
{
u8 i;
for (i = 0; (*(pos+i) != 0) && (*(pos+i) == delim); i++);
if (i>1)
strdelete(pos,1,i-1);
pos=strchr(pos+1, delim);
}
}
/******************************************************************************/
/* R<>cup<75>r<EFBFBD>re l'<27>l<EFBFBD>ment N d'une liste utilisant un d<>limiteur */
u8* strgetitem(u8 *src, u8 *dest, u8 delim, u32 index) {
u32 i;
u8* pos=strgetpointeritem(src,delim,index);
for (i = 0; (*(pos+i) != 0) && (*(pos+i) != delim); i++)
*(dest+i)=*(pos+i);
*(dest+i)='\000';
return dest;
}
/******************************************************************************/
/* R<>cup<75>r<EFBFBD>re un pointeur sur l'<27>l<EFBFBD>ment N d'une liste utilisant un d<>limiteur */
u8* strgetpointeritem(u8 *src, u8 delim, u32 index) {
u32 i;
u8* pos=src;
for (i = 0; i<index; i++)
pos=strchr(pos+1, delim);
if (*pos == delim) pos++;
return pos;
}
/******************************************************************************/
/* R<>cup<75>r<EFBFBD>re le nombre d'<27>l<EFBFBD>ments d'une liste utilisant un d<>limiteur */
u32 strgetnbitems(u8 *src, u8 delim) {
u32 number=0;
if (*src==0) return 0;
number++;
u8 *pos=strchr(src, delim);
while (pos!=0)
{
pos=strchr(pos+1, delim);
number++;
}
return number;
}
/******************************************************************************/
/* Renvoie la base minimum du nombre */
u8 base[]=" 0123456789ABCDEF\000";
u8 strgetminbase(u8 *src) {
u8 temp[]=" \000";
u8 *dst=&temp;
strtoupper(strcpy(src, &temp));
u8 max=0;
while (*dst!=0) {
u32 result=strchrpos(&base,*dst++);
if (result==0)
return 0;
if (result>max)
max=result;
}
if (max>10)
return 16;
else if (max>8)
return 10;
else if (max>2)
return 8;
else
return 2;
}
/******************************************************************************/
/* Renvoie la base du nombre */
u8 hexa[]="0x\000";
u8 bases[]=" bodh\000";
u8 basesnum[]={0,2,8,10,16};
u8 declaredbase=10;
u8 minbase=0;
u8 strgetbase(u8 *src) {
u8 temp[]=" \000";
strleft(src,&temp,2);
if (strcmp(&temp,&hexa)==0) {
declaredbase=16;
u8 size=strlen(src);
strright(src,&temp,size-2);
minbase=strgetminbase(&temp);
}
else {
strright(src,&temp,1);
declaredbase=basesnum[strchrpos(&bases,temp[0])];
if (declaredbase>0) {
u8 size=strlen(src);
strleft(src,&temp,size-1);
minbase=strgetminbase(&temp);
}
else
{
minbase=strgetminbase(src);
declaredbase=minbase;
}
}
if (declaredbase>=minbase && minbase!=0)
return declaredbase;
else
return 0;
}
/******************************************************************************/
/* Renvoie la base du nombre */
u32 strtoint(u8 *src) {
u8* temp=src;
u32 result=0;
u8 thebase=strgetbase(src);
u32 multi=1;
u8 shorter=0;
if (thebase==0) return 0;
if (*(src+1)=='x') shorter=2;
while (*++temp!=0);
while (*temp==0 || *temp=='b' || *temp=='o' || *temp=='d' || *temp=='h')
temp--;
while (src+shorter<=temp) {
u8 achar=*temp--;
if ((achar >= 'a') && (achar <= 'z'))
achar=achar-('a'-'A');
result=result+multi*(strchrpos(&base,achar)-1);
multi=multi*thebase;
}
return result;
}