/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/**
 ************************************************************************
 * @file         M4DPAK_CharStar.c
 * @ingroup
  * @brief        definition of the Char Star set of functions.
 * @note         This file defines the Char Star set of functions.
 *
 ************************************************************************
*/


#include "M4OSA_CharStar.h"
#include "M4OSA_Memory.h"
#include "M4OSA_Debug.h"

/* WARNING: Specific Android */
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>


/**
 ************************************************************************
 * @brief      This function mimics the functionality of the libc's strncpy().
 * @note       It copies exactly len2Copy characters from pStrIn to pStrOut,
 *             truncating  pStrIn or adding null characters to pStrOut if
 *             necessary.
 *             - If len2Copy is less than or equal to the length of pStrIn,
 *               a null character is appended automatically to the copied
 *               string.
 *             - If len2Copy is greater than the length of pStrIn, pStrOut is
 *               padded with null characters up to length len2Copy.
 *             - pStrOut and pStrIn MUST NOT OVERLAP (this is NOT CHECKED).
 * @param      pStrOut: (OUT) Destination character string.
 * @param      pStrIn: (IN) Source character string.
 * @param      len2Copy: (IN) Maximum number of characters from pStrIn to copy.
 * @return     M4NO_ERROR: there is no error.
 * @return     M4ERR_PARAMETER: pStrIn or pStrOut is M4OSA_NULL.
  ************************************************************************
*/
M4OSA_ERR M4OSA_chrNCopy(M4OSA_Char* pStrOut, M4OSA_Char   *pStrIn, M4OSA_UInt32 len2Copy)
{
    M4OSA_TRACE1_3("M4OSA_chrNCopy\t(M4OSA_Char* %x,M4OSA_Char* %x,M4OSA_UInt32 %ld)",
        pStrOut,pStrIn,len2Copy);
    M4OSA_DEBUG_IF2((M4OSA_NULL == pStrOut),M4ERR_PARAMETER,
                            "M4OSA_chrNCopy:\tpStrOut is M4OSA_NULL");
    M4OSA_DEBUG_IF2((M4OSA_NULL == pStrIn),M4ERR_PARAMETER,
                            "M4OSA_chrNCopy:\tpStrIn is M4OSA_NULL");

    strncpy((char *)pStrOut, (const char *)pStrIn, (size_t)len2Copy);
    if(len2Copy <= (M4OSA_UInt32)strlen((const char *)pStrIn))
    {
        pStrOut[len2Copy] = '\0';
    }

    return M4NO_ERROR;
}

/**
 ************************************************************************
  * @brief      This function returns the boolean comparison of pStrIn1 and pStrIn2.
 * @note       The value returned in result is M4OSA_TRUE if the string
 *             pointed to by pStrIn1 is strictly identical to the string pointed
 *             to by pStrIn2, and M4OSA_FALSE otherwise.
 * @param      pStrIn1: (IN) First character string.
 * @param      pStrIn2: (IN) Second character string.
 * @param      cmpResult: (OUT) Comparison result.
 * @return     M4NO_ERROR: there is no error.
 * @return     M4ERR_PARAMETER: pStrIn1 pStrIn2 or cmpResult is M4OSA_NULL.
  ************************************************************************
*/
M4OSA_ERR M4OSA_chrAreIdentical(M4OSA_Char* pStrIn1, M4OSA_Char* pStrIn2,
                                                            M4OSA_Bool* pResult)
{
    M4OSA_UInt32 i32,len32;
    M4OSA_TRACE1_3("M4OSA_chrAreIdentical\t(M4OSA_Char* %x,M4OSA_Char* %x,"
        "M4OSA_Int32* %x)",pStrIn1,pStrIn2,pResult);
    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn1, M4ERR_PARAMETER,
                               "M4OSA_chrAreIdentical:\tpStrIn1 is M4OSA_NULL");
    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn2, M4ERR_PARAMETER,
                               "M4OSA_chrAreIdentical:\tpStrIn2 is M4OSA_NULL");
    M4OSA_DEBUG_IF2(M4OSA_NULL == pResult, M4ERR_PARAMETER,
                               "M4OSA_chrAreIdentical:\tpResult is M4OSA_NULL");

    len32 = (M4OSA_UInt32)strlen((const char *)pStrIn1);
    if(len32 != (M4OSA_UInt32)strlen((const char *)pStrIn2))
    {
        *pResult = M4OSA_FALSE;
        return M4NO_ERROR;
    }

    for(i32=0;i32<len32;i32++)
    {
        if(pStrIn1[i32] != pStrIn2[i32])
        {
            *pResult = M4OSA_FALSE;
            return M4NO_ERROR;
        }
    }

    *pResult = M4OSA_TRUE;

    return M4NO_ERROR;
}


/**
 ************************************************************************
 * @brief      This function gets a M4OSA_UInt32 from string.
 * @note       This function converts the first set of non-whitespace
 *             characters of pStrIn to a M4OSA_UInt32 value pVal, assuming a
 *             representation in base provided by the parameter base. pStrOut is
 *             set to the first character of the string following the last
 *             character of the number that has been converted.
 *             - in case of a failure during the conversion, pStrOut is not
 *               updated, and pVal is set to null.
 *             - in case of negative number, pStrOut is not updated, and pVal is
 *               set to null.
 *             - in case of numerical overflow, pVal is set to M4OSA_UINT32_MAX.
 *             - if pStrOut is not to be used, it can be set to M4OSA_NULL.
 * @param      pStrIn: (IN) Character string.
 * @param      pVal: (OUT) read value.
 * @param      pStrOut: (OUT) Output character string.
 * @param      base: (IN) Base of the character string representation.
 * @return     M4NO_ERROR: there is no error.
 * @return     M4ERR_PARAMETER: pStrIn or pVal is M4OSA_NULL.
 * @return     M4ERR_CHR_CONV_FAILED: conversion failure.
 * @return     M4WAR_CHR_NUM_RANGE: the character string represents a number
 *             greater than M4OSA_UINT32_MAX.
 * @return     M4WAR_CHR_NEGATIVE: the character string represents a negative
 *             number.
 ************************************************************************
*/
M4OSA_ERR M4OSA_chrGetUInt32(M4OSA_Char*    pStrIn,
                             M4OSA_UInt32*    pVal,
                             M4OSA_Char**    pStrOut,
                             M4OSA_chrNumBase base)
{
    M4OSA_UInt32 ul;
    char*        pTemp;

    M4OSA_TRACE1_4("M4OSA_chrGetUInt32\t(M4OSA_Char* %x, M4OSA_UInt32* %x"
        "M4OSA_Char** %x,M4OSA_chrNumBase %d)",pStrIn,pVal,pStrOut,base);
    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn, M4ERR_PARAMETER,
                                   "M4OSA_chrGetUInt32:\tpStrIn is M4OSA_NULL");
    M4OSA_DEBUG_IF2(M4OSA_NULL == pVal, M4ERR_PARAMETER,
                                     "M4OSA_chrGetUInt32:\tpVal is M4OSA_NULL");

    errno = 0;
    switch(base)
    {
    case M4OSA_kchrDec:
        ul = strtoul((const char *)pStrIn, &pTemp, 10);
        break;
    case M4OSA_kchrHexa:
        ul = strtoul((const char *)pStrIn, &pTemp,16);
        break;
    case M4OSA_kchrOct:
        ul = strtoul((const char *)pStrIn, &pTemp,8);
        break;
    default:
        return M4ERR_PARAMETER;
    }

    /* has conversion failed ? */
    if((M4OSA_Char*)pTemp == pStrIn)
    {
        *pVal = 0;
        return M4ERR_CHR_CONV_FAILED;
    }

    /* was the number negative ? */
    if(*(pStrIn+strspn((const char *)pStrIn," \t")) == '-')
    {
        *pVal = 0;
        return M4WAR_CHR_NEGATIVE;
    }

    /* has an overflow occured ? */
    if(errno == ERANGE)
    {
        *pVal = M4OSA_UINT32_MAX;
        if(M4OSA_NULL != pStrOut)
        {
            *pStrOut = (M4OSA_Char*)pTemp;
        }
        return M4WAR_CHR_NUM_RANGE;
    }

    /* nominal case */
    *pVal = (M4OSA_UInt32)ul;
    if(M4OSA_NULL != pStrOut)
    {
        *pStrOut = (M4OSA_Char*)pTemp;
    }

    return M4NO_ERROR;
}

/**
 ************************************************************************
 * @brief      This function gets a M4OSA_UInt16 from string.
 * @note       This function converts the first set of non-whitespace
 *             characters of pStrIn to a M4OSA_UInt16 value pVal, assuming a
 *             representation in base provided by the parameter base. pStrOut is
 *             set to the first character of the string following the last
 *             character of the number that has been converted.
 *             - in case of a failure during the conversion, pStrOut is not
 *               updated, and pVal is set to null.
 *             - in case of negative number, pStrOut is not updated, and pVal is
 *               set to null.
 *             - in case of numerical overflow, pVal is set to M4OSA_UINT16_MAX.
 *             - if pStrOut is not to be used, it can be set to M4OSA_NULL.
 * @param      pStrIn: (IN) Character string.
 * @param      pVal: (OUT) read value.
 * @param      pStrOut: (OUT) Output character string.
 * @param      base: (IN) Base of the character string representation.
 * @return     M4NO_ERROR: there is no error.
 * @return     M4ERR_PARAMETER: pStrIn or pVal is M4OSA_NULL.
 * @return     M4ERR_CHR_CONV_FAILED: conversion failure.
 * @return     M4WAR_CHR_NUM_RANGE: the character string represents a number
 *             greater than M4OSA_UINT16_MAX.
 * @return     M4WAR_CHR_NEGATIVE: the character string represents a negative
 *             number.
 ************************************************************************
*/
M4OSA_ERR M4OSA_chrGetUInt16 (M4OSA_Char* pStrIn, M4OSA_UInt16 *pVal,
                              M4OSA_Char** pStrOut, M4OSA_chrNumBase base)
{
    M4OSA_UInt32 ul;
    char*        pTemp;

    M4OSA_TRACE1_4("M4OSA_chrGetUInt16\t(M4OSA_Char* %x, M4OSA_UInt16* %x"
        "M4OSA_Char** %x,M4OSA_chrNumBase %d)",pStrIn,pVal,pStrOut,base);
    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn,M4ERR_PARAMETER,
                                   "M4OSA_chrGetUInt16:\tpStrIn is M4OSA_NULL");
    M4OSA_DEBUG_IF2(M4OSA_NULL == pVal, M4ERR_PARAMETER,
                                     "M4OSA_chrGetUInt16:\tpVal is M4OSA_NULL");

    switch(base)
    {
    case M4OSA_kchrDec:
        ul = strtoul((const char *)pStrIn, &pTemp,10);
        break;
    case M4OSA_kchrHexa:
        ul = strtoul((const char *)pStrIn, &pTemp,16);
        break;
    case M4OSA_kchrOct:
        ul = strtoul((const char *)pStrIn, &pTemp,8);
        break;
    default:
        return M4ERR_PARAMETER;
    }

    /* has conversion failed ? */
    if((M4OSA_Char*)pTemp == pStrIn)
    {
        *pVal = 0;
        return M4ERR_CHR_CONV_FAILED;
    }

    /* was the number negative ? */
    if(*(pStrIn+strspn((const char *)pStrIn," \t")) == '-')
    {
        *pVal = 0;
        return M4WAR_CHR_NEGATIVE;
    }

    /* has an overflow occured ? */
    if(ul>M4OSA_UINT16_MAX)
    {
        *pVal = M4OSA_UINT16_MAX;
        if(M4OSA_NULL != pStrOut)
        {
            *pStrOut = (M4OSA_Char*)pTemp;
        }
        return M4WAR_CHR_NUM_RANGE;
    }

    /* nominal case */
    *pVal = (M4OSA_UInt16)ul;
    if(M4OSA_NULL != pStrOut)
    {
        *pStrOut = (M4OSA_Char*)pTemp;
    }
    return M4NO_ERROR;
}

M4OSA_ERR M4OSA_chrSPrintf(M4OSA_Char  *pStrOut, M4OSA_UInt32 strOutMaxLen,
                           M4OSA_Char   *format, ...)
{
    va_list       marker;
    M4OSA_Char   *pTemp;
    M4OSA_Char   *percentPointer;
    M4OSA_Char   *newFormat;
    M4OSA_Int32  newFormatLength=0;
    M4OSA_UInt32  count_ll = 0;
    M4OSA_UInt32  count_tm = 0;
    M4OSA_UInt32  count_aa = 0;
    M4OSA_UInt32  count;
    M4OSA_UInt32  nbChar;
    M4OSA_Int32     err;
    M4OSA_Char flagChar[]             = "'-+ #0";
    M4OSA_Char widthOrPrecisionChar[] = "*0123456789";
    M4OSA_Char otherPrefixChar[]      = "hlL";
    M4OSA_Char conversionChar[]       = "diouxXnfeEgGcCsSp%";

    M4OSA_TRACE1_3("M4OSA_chrSPrintf\t(M4OSA_Char* %x, M4OSA_UInt32 %ld"
        "M4OSA_Char* %x)",pStrOut,strOutMaxLen,format);
    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrOut, M4ERR_PARAMETER,
                                    "M4OSA_chrSPrintf:\tpStrOut is M4OSA_NULL");
    M4OSA_DEBUG_IF2(M4OSA_NULL == format, M4ERR_PARAMETER,
                                     "M4OSA_chrSPrintf:\tformat is M4OSA_NULL");

    va_start(marker,format);

    /* count the number of %[flags][width][.precision]ll[conversion] */
    pTemp = format;
    while(*pTemp)
    {
        percentPointer = (M4OSA_Char *)strchr((const char *)pTemp,'%'); /* get the next percent character */
        if(!percentPointer)
            break;                            /* "This is the End", (c) J. Morrisson */
        pTemp = percentPointer+1;           /* span it */
        if(!*pTemp)
            break;                            /* "This is the End", (c) J. Morrisson */
        pTemp += strspn((const char *)pTemp,(const char *)flagChar);    /* span the optional flags */
        if(!*pTemp)
            break;                            /* "This is the End", (c) J. Morrisson */
        pTemp += strspn((const char *)pTemp,(const char *)widthOrPrecisionChar); /* span the optional width */
        if(!*pTemp)
            break;                            /* "This is the End", (c) J. Morrisson */
        if(*pTemp=='.')
        {
            pTemp++;
            pTemp += strspn((const char *)pTemp, (const char *)widthOrPrecisionChar); /* span the optional precision */
        }
        if(!*pTemp)
            break;                            /* "This is the End", (c) J. Morrisson */
        if(strlen((const char *)pTemp)>=2)
        {
            if(!strncmp((const char *)pTemp,"ll",2))
            {
                count_ll++;                 /* I got ONE */
                pTemp +=2;                  /* span the "ll" prefix */
            }
            else if(!strncmp((const char *)pTemp,"tm",2))
            {
                count_tm++;
                pTemp +=2;
            }
            else if(!strncmp((const char *)pTemp,"aa",2))
            {
                count_aa++;
                pTemp +=2;
            }
        }
        pTemp += strspn((const char *)pTemp, (const char *)otherPrefixChar); /* span the other optional prefix */
        if(!*pTemp)
            break;                        /* "This is the End", (c) J. Morrisson */
        pTemp += strspn((const char *)pTemp, (const char *)conversionChar);
        if(!*pTemp)
            break;                        /* "This is the End", (c) J. Morrisson */
    }

    count = count_ll + count_tm + count_aa;

    if(!count)
    {
        err= vsnprintf((char *)pStrOut, (size_t)strOutMaxLen + 1, (const char *)format, marker);
        va_end(marker);
        if ((err<0) || ((M4OSA_UInt32)err>strOutMaxLen))
        {
            pStrOut[strOutMaxLen] = '\0';
            return M4ERR_CHR_STR_OVERFLOW;
        }
        else
        {
            return M4NO_ERROR;
        }
    }


    newFormatLength = strlen((const char *)format) + 1;

    newFormatLength -= (count_ll+count_tm+count_aa);

    newFormat =(M4OSA_Char*)M4OSA_32bitAlignedMalloc(newFormatLength,
        M4OSA_CHARSTAR,(M4OSA_Char*)"M4OSA_chrPrintf: newFormat");
    if(M4OSA_NULL == newFormat)
        return M4ERR_ALLOC;
    newFormat[newFormatLength-1] = '\0';
    pTemp = newFormat;

    /* copy format to newFormat, replacing %[flags][width][.precision]ll[conversion]
     * by %[flags][width][.precision]I64[conversion] */
    while(*format)
    {
        nbChar = strcspn((const char *)format, "%");
        if(nbChar)
        {
            strncpy((char *)pTemp, (const char *)format, nbChar);      /* copy characters before the % character */
            format +=nbChar;
            pTemp   +=nbChar;
        }
        if(!*format) break;
        *pTemp++ = *format++;                 /* copy the % character */
        nbChar = strspn((const char *)format, (const char *)flagChar);
        if(nbChar)
        {
            strncpy((char *)pTemp, (const char *)format, nbChar);      /* copy the flag characters */
            format +=nbChar;
            pTemp   +=nbChar;
        }
        if(!*format) break;
        nbChar = strspn((const char *)format, (const char *)widthOrPrecisionChar);
        if(nbChar)
        {
            strncpy((char *)pTemp, (const char *)format, nbChar);      /* copy the width characters */
            format +=nbChar;
            pTemp   +=nbChar;
        }
        if(!*format) break;
        if(*format=='.')
        {
            *pTemp++ = *format++;              /* copy the dot character */
            if(!format) break;
            nbChar = strspn((const char *)format, (const char *)widthOrPrecisionChar);
            if(nbChar)
            {
                strncpy((char *)pTemp, (const char *)format, nbChar);      /* copy the width characters */
                format +=nbChar;
                pTemp   +=nbChar;
            }
            if(!format) break;
        }
        if(strlen((const char *)format)>=2)
        {
            if(!strncmp((const char *)format, "ll", 2))
            {
                *pTemp++ = 'l'; /* %l */
                format +=2;                         /* span the "ll" prefix */
            }
            else if(!strncmp((const char *)format, "tm", 2))
            {
                *pTemp++ = 'l'; /* %l */
                format +=2;                         /* span the "tm" prefix */
            }
            else if(!strncmp((const char *)format, "aa", 2))
            {
                *pTemp++ = 'l';
                format +=2;                         /* span the "aa" prefix */
            }
        }
        nbChar = strspn((const char *)format, (const char *)otherPrefixChar);
        if(nbChar)
        {
            strncpy((char *)pTemp, (const char *)format, nbChar);      /* copy the other Prefix */
            format +=nbChar;
            pTemp   +=nbChar;
        }
        if(!*format) break;
        nbChar = strspn((const char *)format, (const char *)conversionChar);
        if(nbChar)
        {
            strncpy((char *)pTemp, (const char *)format, nbChar);
            format += nbChar;
            pTemp   += nbChar;
        }
        if(!*format) break;
    }

    /* Zero terminate the format string. */
    (*pTemp) = '\0';

    err = vsnprintf((char *)pStrOut, (size_t)strOutMaxLen + 1, (const char *)newFormat, marker);
    va_end(marker);
    free(newFormat);
    if ((err<0) || ((M4OSA_UInt32)err>strOutMaxLen))
    {
        pStrOut[strOutMaxLen] = '\0';
        return M4ERR_CHR_STR_OVERFLOW;
    }
    else
    {
        return M4NO_ERROR;
    }
}