ssp_string.c

abstract rtos

#include "syscfg.h"

#ifdef __cplusplus
#if __cplusplus
extern "C"{
#endif 
#endif 



#include "sys/sys_pub.h"
#include "aos.h"











VOID *aos_memcpy( VOID *dest, VOID *src, SIZE_T count )
{
    U32 room;
    if( AOS_ADDR_VALID(dest) && AOS_ADDR_VALID(src) )
    {
        room = mem_obj_room(dest);
        if( count > room )
        {
            AOS_ASSERT_FUNC( 0, aos_printf(0,"memcpy:dest=0x%x,src=0x%x,cnt=%u,room=%u", dest, src, count, room) );
            
            aos_task_show_call_stack(0);
            return NULL;
        }
        return (VOID*)memcpy(dest,src,count);
    }
    
    aos_task_show_call_stack(0);
    return NULL;
}

VOID *aos_memmove( VOID * dest, const VOID * src, SIZE_T count )
{
    if( AOS_ADDR_WRITABLE(dest) && AOS_ADDR_VALID(src) )
    {
        return (VOID*)memmove( dest, src, count );
    }

    aos_task_show_call_stack(0);
    return NULL;
}

VOID *aos_memset( VOID *dest, U8 ch, SIZE_T count )
{
    U32 room;
    if( AOS_ADDR_WRITABLE(dest) )
    {
        room = mem_obj_room(dest);
        if( count > room )
        {
            AOS_ASSERT_FUNC( 0, aos_printf(0,"memset:dest=0x%x,cnt=%u,room=%u", dest, count, room) );
            aos_task_show_call_stack(0);
            return NULL;
        }
        
        return (VOID*)memset( dest, ch, count );
    }

    aos_task_show_call_stack(0);
    return NULL;
}

VOID * aos_memchr( VOID * buf, S8 ch, SIZE_T count )
{
    if( AOS_ADDR_VALID(buf) )
    {
        return memchr( buf, ch, count );
    }

    aos_task_show_call_stack(0);
    return (VOID *)NULL;
}

S32 aos_memcmp( VOID * buf1, const VOID * buf2, SIZE_T count )
{
    if( AOS_ADDR_VALID(buf1) && AOS_ADDR_VALID(buf2) )
    {
        return memcmp( buf1, buf2, count );
    }

    aos_task_show_call_stack(0);    
    return -1;
}

S8 *aos_strcat (S8 *dest, const S8 *src)
{
	if( AOS_ADDR_VALID(dest) && AOS_ADDR_VALID(src) )
	{
	    return strcat( dest, src );
	}

    return NULL;
}

S8 *aos_strchr (const S8 *str, S32 i)
{
    if( AOS_ADDR_VALID( str ) )
    {
        return strchr( str, i );
    }

    return NULL;
}



S8* aos_strstr(S8 * source,  S8 *key)
{
       char *pCh=key;
       char *pSch, *pSource;

       pSource= source;
       do
       { 
           pSch=aos_strchr(pSource, *pCh); 
           if( pSch )
           {
                if(aos_strncmp(key,pSch,aos_strlen(key)) == 0 )
                    break;  
                else
                    pSource=pSch+1;   
           }
       }while( pSch );  
        
       return pSch; 
}

S32 aos_strcmp (const S8 *s1, const S8 *s2)
{
    AOS_ASSERT( NULL != s1 && NULL != s2 );

    if( AOS_ADDR_VALID( s1 ) && AOS_ADDR_VALID( s2 ) )
    {
        return strcmp( s1, s2 );
    }

    return -1;
}

S32 aos_stricmp (const S8 *s1, const S8 *s2)
{
    S8 cCh1, cCh2;

    if( AOS_ADDR_VALID(s1) && AOS_ADDR_VALID(s2) )
    {
        if (s1 == s2)
        {
            return 0;
        }
        
        for (;;)
        {
            cCh1 = *s1;
            cCh2 = *s2;

            if (cCh1 >= 'A' && cCh1 <= 'Z')
            {
                 cCh1 += 'a' - 'A';
            }
            if (cCh2 >= 'A' && cCh2 <= 'Z')
            {
                 cCh2 += 'a' - 'A';
            }
            
            if (cCh1 != cCh2)
            {
                 return (S32)(cCh1 - cCh2);
            }
            if (!cCh1)
            {
                 return 0;
            }

            s1++;
            s2++;
        }

    }
    
    return -1;
}

S32 aos_strncmp (const S8 *s1, const S8 *s2, U32 n)
{
    if( AOS_ADDR_VALID(s1) && AOS_ADDR_VALID(s2) )
    {
        return strncmp(s1, s2, n );
    }
    
    return -1;
}

S32 aos_strnicmp (const S8 *s1, const S8 *s2, U32 n)
{
    S8	cCh1, cCh2;

    if( AOS_ADDR_VALID(s1) && AOS_ADDR_VALID(s2) )
    {
        if ((s1 == s2) || (n == 0))
        {
            return 0;
        }

        while (n)
        {
            cCh1 = *s1;
            cCh2 = *s2;

            if (cCh1 >= 'A' && cCh1 <= 'Z')
            {
                cCh1 += 'a' - 'A';
            }

            if (cCh2 >= 'A' && cCh2 <= 'Z')
            {
                cCh2 += 'a' - 'A';
            }
            if (cCh1 != cCh2)
            {
                return (S32)(cCh1 - cCh2);
            }
            if (!cCh1)
            {
                return 0;
            }

            s1++;
            s2++;
            n--;
        }

        return 0;
    }

    return -1;
}

S8 *aos_strcpy (S8 *dest, const S8 *src)
{
    U32 room;
    if( AOS_ADDR_WRITABLE( dest ) && AOS_ADDR_VALID(src))
    {
        room = mem_obj_room(dest);
        if( (aos_strlen(src)+1) > room )
        {
            dest[0] = 0;
            AOS_ASSERT_FUNC( 0, aos_printf(0,"memcpy:dest=0x%x,src=0x%x,cnt=%u,room=%u", dest, src, aos_strlen(src)+1, room) );
            aos_task_show_call_stack(0);
            return NULL;
        }
        
        return strcpy( dest, src );
    }

    aos_task_show_call_stack(0);
    return NULL;
}

S8 *aos_strncpy (S8 *dest, const S8 *src, U32 n)
{
    U32 room;
    if( AOS_ADDR_WRITABLE( dest ) && AOS_ADDR_VALID( src ))
    {
        room = mem_obj_room(dest);
        if( n > room )
        {
            dest[0] = 0;
            AOS_ASSERT_FUNC( 0, aos_printf(0,"memcpy:dest=0x%x,src=0x%x,cnt=%u,room=%u", dest, src, n, room) );
            aos_task_show_call_stack(0);
            return NULL;
        }        
        return strncpy( dest, src, n );
    }
    
    aos_task_show_call_stack(0);
    return NULL;
}

U32 aos_strlen (const S8 *str)
{
    U32 ulCnt;

    if( AOS_ADDR_VALID( str ) )
    {
        ulCnt = 0;
        while (*str)
        {
            ulCnt++;
            str++;
        }

        return ulCnt;

    }
    
    return 0;
}

SIZE_T aos_strnlen(const S8 * str, SIZE_T count)
{
	const S8 *sc;

    if( AOS_ADDR_VALID( str ) )
    {
    	for (sc = str; count-- && *sc != '\0'; ++sc)
    		;
    	return (SIZE_T)(sc - str);
    }

    return 0;
}

S8 aos_toupper(S8 ch)
{
	if (ch >= 'a' && ch <= 'z')
		return (S8)(ch + 'A' - 'a');

	return ch;
}

S8 aos_tolower(S8 ch)
{
	if (ch >= 'A' && ch <= 'Z')
		return (S8)(ch + 'a' - 'A');

	return ch;
}

VOID aos_uppercase (S8 *str)
{
    if (!str)
	return;
    while(*str) {
	if (*str >= 'a' && *str <= 'z')
	    *str = (S8)((*str) + 'A' - 'a');
	str++;
    }
}

VOID aos_lowercase (S8 *str)
{
    if (!str)
	return;
    while(*str) {
	if (*str >= 'A' && *str <= 'Z')
	    *str = (S8)((*str) + 'a' - 'A');
	str++;
    }
}

#define Isspace(c)      ((c == ' ') || (c == '\t') || (c=='\n') || (c=='\v') \
                         || (c == '\r') || (c == '\f'))
#define Isdigit(c)      ((c <= '9') && (c >= '0'))

S32 aos_atol (const S8 *szStr, S32 *pnVal)
{
    if( AOS_ADDR_VALID( szStr ) && AOS_ADDR_WRITABLE(pnVal) )
    {
        if (aos_sscanf(szStr, "%d", pnVal) < 1)
        {
            *pnVal = 0;
            return -1;
        }
        return 0;
    }

    return -1;
}
S32 aos_atol_range (const S8 *szStr, S32 *pnVal, S32 nMin, S32 nMax)
{
	if( AOS_ADDR_VALID(szStr) && AOS_ADDR_WRITABLE(pnVal) )
	{
    	if (aos_sscanf(szStr, "%d", pnVal) < 1)
    	{
    		*pnVal = 0;
    		return -1;
    	}

    	if ((*pnVal) > nMax || (*pnVal) < nMin)
    	{
    		return -1;
    	}

        return 0;
	}
	
	return -1;
}

S32 aos_atoul (const S8 *szStr, U32 *pulVal)
{
	U32 nVal;

	if( AOS_ADDR_VALID(szStr) && AOS_ADDR_WRITABLE(pulVal) )
	{
    	if (aos_sscanf(szStr, "%u", &nVal) < 1)
    	{
    		*pulVal = 0;
    		return -1;
    	}

    	*pulVal = nVal;
        return 0;
	}

	return -1;
}

S32 aos_atolx (const S8 *szStr, S32 *pnVal)
{
	if( AOS_ADDR_VALID(szStr) && AOS_ADDR_WRITABLE(pnVal) )
	{
    	if (aos_sscanf(szStr, "%x", pnVal) < 1 &&
    		aos_sscanf(szStr, "%X", pnVal) < 1)
    	{
    		*pnVal = 0;
    		return -1;
    	}

        return 0;
	}

	return -1;
}

S32 aos_atolx_range (const S8 *szStr, S32 *pnVal, S32 nMin, S32 nMax)
{
	if( AOS_ADDR_VALID(szStr) && AOS_ADDR_WRITABLE(pnVal) )
	{
    	if (aos_sscanf(szStr, "%x", pnVal) < 1 &&
    		aos_sscanf(szStr, "%X", pnVal) < 1)
    	{
    		*pnVal = 0;
    		return -1;
    	}

    	if ((*pnVal) > nMax || (*pnVal) < nMin)
    	{
    		return -1;
    	}

        return 0;
	}
	
	return -1;
}

S32 aos_atoulx (const S8 *szStr, U32 *pulVal)
{
	U32 nVal;

	if( AOS_ADDR_VALID(szStr) && AOS_ADDR_WRITABLE(pulVal) )
	{
    	if (aos_sscanf(szStr, "%x", &nVal) < 1 &&
    		aos_sscanf(szStr, "%X", &nVal) < 1)
    	{
    		*pulVal = 0;
    		return -1;
    	}

    	*pulVal = nVal;
        return 0;
	}
	
	return -1;
}

S32 aos_ltoa (S32 nVal, S8 *szStr)
{
	if( AOS_ADDR_WRITABLE(szStr) )
	{
    	if (aos_sprintf(szStr, "%d", nVal) < 1)
    	{
    		return -1;
    	}
        return 0;
	}
	return -1;
}
S32 aos_ltoax (S32 nVal, S8 *szStr)
{
	if( AOS_ADDR_WRITABLE(szStr) )
	{
    	if (aos_sprintf(szStr, "%x", nVal) < 1)
    	{
    		return -1;
    	}
        return 0;
	}

    return -1;
}

S32 aos_ultoax (U32 ulVal, S8 *szStr)
{
	if( AOS_ADDR_WRITABLE(szStr) )
	{
    	if (aos_sprintf(szStr, "%x", ulVal) < 1)
    	{
    		return -1;
    	}

        return 0;
	}

	return -1;
}

S8  *aos_ipaddrtostr(U32 ulAddr, S8 *str)
{
	if( AOS_ADDR_WRITABLE(str) )
	{
    	aos_sprintf(str, "%d.%d.%d.%d", 
    		ulAddr >> 24, (ulAddr >> 16) & 0xff,
    		(ulAddr >> 8) & 0xff, ulAddr & 0xff);
    		
    	return str;
	}

	return NULL;
}

S32 aos_strtoipaddr(S8 *szStr, U32 *pulIpAddr)
{
	U32 a, b, c, d;
	
	if( AOS_ADDR_WRITABLE(pulIpAddr) )
	{
    	if (aos_sscanf(szStr, "%d.%d.%d.%d", &a, &b, &c, &d) == 4)
    	{
    		if (a<256 && b<256 && c<256 && d<256)
    		{
    			*pulIpAddr = (a<<24) | (b<<16) | (c<<8) | d;
    			return 0;
    		}
    	}
	}

	return -1;
}

S8* aos_ultoa(U32 Value,S8 *str,S32 Radix)
{
	S8 szTemp[100];
	S32 i=0,j;

	if( AOS_ADDR_WRITABLE( str ) )
	{
    	if (Radix)
    	{
    		do
    		{
    			szTemp[i]=(S8)(Value%Radix);
    			Value/=Radix;
    			szTemp[i]+=((szTemp[i]>9)?55:48);
    			i++;
    		} while (Value);
    		for (j=i-1;j>=0;j--)
    			str[i-j-1]=szTemp[j];
    	}
    	str[i]='\0';
    	
    	return str;
	}
	
	return NULL;
}

U16 aos_ntohs( U16 str )
{
    return AOS_NTOHS(str);
}

U16 aos_htons( U16 str )
{
    return AOS_HTONS(str);
}

U32 aos_ntohl( U32 n ) 
{
    return AOS_NTOHL(n);
}

U32 aos_htonl( U32 n ) 
{
    return AOS_HTONL(n);
}


#ifdef __cplusplus
#if __cplusplus
}
#endif 
#endif