str.c

vt6528芯片交换机API函数和文档运行程序

/*
 * File:    str.c
 *
 * Purpose: String operations (used to replace "string.h")
 */


#if !defined(__MACRO_H__)
#include "macro.h"
#endif
#if !defined(__STR_H__)
#include "str.h"
#endif




/*---------------------  Static Definitions  ------------------------*/

/*---------------------  Static Types  ------------------------------*/

/*---------------------  Static Macros  -----------------------------*/

/*---------------------  Static Classes  ----------------------------*/

/*---------------------  Static Variables  --------------------------*/

/*---------------------  Static Functions  --------------------------*/

/*---------------------  Export Variables  --------------------------*/




int STR_iStrcmp (char* dst, char* src)
{
    int ret = 0;


    ret = *(unsigned char*)src - *(unsigned char*)dst;
    while (!ret && *dst) {
        src++, dst++;
        ret = *(unsigned char*)src - *(unsigned char*)dst;
    }

    if (ret < 0)
        ret = -1 ;
    else if (ret > 0)
        ret = 1 ;

    return ret;
}


int STR_iStrcat (char* dst, char* src)
{
    char*   cp = dst;
    int     length = 0;


    /* find end of dst */
    while (*cp)
        cp++;
    for (*cp = *src; *src != '\0'; ) {
        cp++, src++;
        *cp = *src;
        length++;
    }
    return length;
}


char* STR_pszStrcat (char* dst, char* src)
{
    char*   cp = dst;


    /* find end of dst */
    while (*cp)
        cp++;
    for (*cp = *src; *src != '\0'; ) {
        cp++, src++;
        *cp = *src;
    }
    return dst;
}


char* STR_pszStrcatchr (char* dst, char c)
{
    char*   cp = dst;


    /* find end of dst */
    while (*cp)
        cp++;
    *cp++ = c;
    *cp = '\0';
    return dst;
}


int STR_iStrcpy (char* dst, char* src)
{
    char*   cp = dst;
    int     length = 0;


    /* Copy src over dst */
    for (*cp = *src; *src != '\0'; ) {
        cp++, src++;
        *cp = *src;
        length++;
    }
    return length;
}


char* STR_pszStrcpy (char* dst, char* src)
{
    char*   cp = dst;


    /* Copy src over dst */
    for (*cp = *src; *src != '\0'; ) {
        cp++, src++;
        *cp = *src;
    }
    return dst;
}


int STR_iStrlen (char* str)
{
    int length = 0;


    while (*str++)
        length++;
    return length;
}


void* STR_pvMemcpy (void* dst, void* src, UINT32 count)
{
    void*   ret = dst;


    while (count--) {
        *(char* )dst = *(char*)src;
        dst = (char*)dst + 1;
        src = (char*)src + 1;
    }

    return ret;
}


void* STR_pvMemset (void* dst, char val, UINT32 count)
{
    void*   start = dst;

    while (count--) {
        *(char*)dst = (char)val;
        dst = (char*)dst + 1;
    }

    return start;
}


int STR_iMemcmp(void* dst, void* src, UINT32 count)
{
    if (!count)
        return (0);

    while (--count && (*(char*)dst == *(char*)src)) {
        dst = (char*)dst + 1;
        src = (char*)src + 1;
    }

    return (*((unsigned char*)dst) - *((unsigned char*)src));
}


BOOL STR_bIsPrint (CHAR c)
{
    return ((0x20 <= c) && (c <= 0x7E));
}


BOOL STR_bIsDigit (CHAR c)
{
    return (('0' <= c) && (c <= '9'));
}


BOOL STR_bIsXDigit (CHAR c)
{
    return ((('0' <= c) && (c <= '9'))
            || (('A' <= c) && (c <= 'F'))
            || (('a' <= c) && (c <= 'f'))
            );
}


CHAR STR_cToInt (CHAR c)
{
    if (c <= '9')
        return (c - '0');
    else if (c <= 'Z')
        return (c - 'A' + 10);
    else
        return (c - 'a' + 10);
}


CHAR STR_cToUpper (CHAR c)
{
    if (('a' <= c) && (c <= 'z'))
        return (c - ('a' - 'A'));
    else
        return (c);
}


CHAR STR_cToLower (CHAR c)
{
    if (('A' <= c) && (c <= 'Z'))
        return (c + ('a' - 'A'));
    else
        return (c);
}


//
// No leading zero or space will be added
//
int STR_iU32ToStr (PSTR pszResult, UINT32 u32Value, INT iRadix)
{
    UINT8   u8Nibble;
    PCHAR   pchResult = pszResult;
    PCHAR   pchFirstDig = pszResult;
    char    temp;
    int     length = 0;


    // step 1. we convert digits in reverse order
    do {
        u8Nibble = (UINT8)(u32Value % iRadix);
        u32Value /= iRadix;

        if (u8Nibble < 10)
            *pchResult = (char)(u8Nibble + '0');
        else
            *pchResult = (char)(u8Nibble - 10 + 'A');
        pchResult++;
        length++;
    } while (u32Value > 0);

    // end of string is 0
    *pchResult-- = '\0';                /* terminate string; p points to last digit */

    // step 2. reverse digits now
    do {
        temp = *pchResult;
        *pchResult = *pchFirstDig;
        *pchFirstDig = temp;

        --pchResult;
        ++pchFirstDig;
    } while (pchFirstDig < pchResult);  /* repeat until halfway */

    return length;
}


//
// Leading will pad with zero digit
//
int STR_iU32ToStrDecPad (PSTR pszResult, UINT32 u32Value, UINT8 byDigCnt)
{
    UINT8   u8Nibble;
    PCHAR   pchResult = pszResult + byDigCnt;
    int     tmp = byDigCnt;


    // end of string is 0
    *pchResult = '\0';

    // each time we convert one nibble to one digit
    while (byDigCnt--) {
        u8Nibble = (UINT8)(u32Value % 10);
        u32Value /= 10;

        pchResult--;
        if (u8Nibble < 10)
            *pchResult = (char)(u8Nibble + '0');
        else
            *pchResult = (char)(u8Nibble - 10 + 'A');
    }

    return tmp;
}


//
// Leading will pad with zero digit
//
int STR_iU32ToStrHexPad (PSTR pszResult, UINT32 u32Value, UINT8 byDigCnt)
{
    UINT8   u8Nibble;
    PCHAR   pchResult = pszResult + byDigCnt;
    int     tmp = byDigCnt;


    // end of string is 0
    *pchResult = '\0';

    // each time we convert one nibble to one digit
    while (byDigCnt--) {
        u8Nibble = LONIBBLE(u32Value);
        u32Value >>= 4;

        pchResult--;
        if (u8Nibble < 10)
            *pchResult = (char)(u8Nibble + '0');
        else
            *pchResult = (char)(u8Nibble - 10 + 'A');
    }

    return tmp;
}


UINT32 STR_u32StrDecToU32 (char* str)
{
    UINT32  dwValue = 0;
    UINT8    byLen;


    // convert string to num value
    for (byLen = 0; STR_bIsDigit(str[byLen]); byLen++)
        dwValue = dwValue * 10 + STR_cToInt(str[byLen]);

    return dwValue;
}


// input string will be in the format of 0x######## ,
// # is a hex digit of '0'~'9', 'A'~'F', 'a'~'f'
UINT32 STR_u32StrHexToU32 (char* str)
{
    UINT32  dwValue = 0;
    UINT8    byLen;


    // convert string to num value
    for (byLen = 0; STR_bIsXDigit(str[byLen]); byLen++)
        dwValue = dwValue * 16 + STR_cToInt(str[byLen]);

    return dwValue;
}


//transfer abyMacAddr to Mac string
void STR_vCvtMacValtoStr(char* pszMacStr, char* pzMacVal)
{
    UINT8 si;

    for (si = 0; si < 6; si++) {
        STR_iU32ToStrHexPad(pszMacStr + si * 3, pzMacVal[5 - si], 2);
        STR_iStrcat(pszMacStr + si * 3, ":");
    }
    pszMacStr[MAC_STRING_LEN] = '\0';   // remove the last ":"

}


//transfer Mac string to abyMacBuff
void STR_vCvtMacStrtoVal(char* pszMacStr, char* pszMacVal)
{
    UINT8 byCnt = 5;

    STR_pvMemset(pszMacVal, 0 , 6);

    while (*pszMacStr) {
        if (*pszMacStr == ':')
            byCnt--;
        else
            pszMacVal[byCnt] = pszMacVal[byCnt] * 16 + STR_cToInt(*pszMacStr);

        pszMacStr++;
    }
}


//transfer dwIpAddr to Ip string
void STR_vCvtIpValtoStr(char* pszIp, UINT32 dwIpAddr)
{
    UINT8 uu;



    for (uu = 0; uu < (IP_STRING_LEN + 1); uu++)
        pszIp[uu] = 0;

    // convert ip address to dec string
    for (uu = 0; uu < 4; uu++) {
        STR_iU32ToStrDecPad(pszIp + uu * 4, (UINT8)(dwIpAddr >> ((3 - uu) * 8)), 3);
        pszIp[(uu + 1) * 4 - 1] = '.';
    }
    
    pszIp[IP_STRING_LEN] = 0;    // remove the last "."
}


//transfer Ip string to dwIpAddr
UINT32 STR_dwCvtIpStrtoVal(char* pszIp)
{
    UINT32  dwIp = 0;
    UINT16  u16Value = 0;
    UINT8    byCnt = 0;



    while (*pszIp) {
        if (*pszIp == '.') {
            // Check if the value bigger than 255
            if (u16Value > 255)
                return 0;

            dwIp = (dwIp << 8) | u16Value;
            u16Value = 0;
            byCnt++;
        }
        else if (! STR_bIsDigit(*pszIp)) {
            return 0;
        }
        else {
            u16Value *= 10;
            if (u16Value + STR_cToInt(*pszIp) < u16Value)
                return 0;
            u16Value += STR_cToInt(*pszIp);
        }
        pszIp++;
    }
    if (byCnt != 3)
        return 0;

    //check 4th number if the value bigger than 255
    if (u16Value > 255)
        return 0;
        
    return ((dwIp << 8) | u16Value);
}