479 lines
13 KiB
C
479 lines
13 KiB
C
|
/* ----> DO NOT REMOVE THE FOLLOWING NOTICE <----
|
||
|
|
|
||
|
|
Copyright (c) 2014-2015 Datalight, Inc.
|
||
|
|
All Rights Reserved Worldwide.
|
||
|
|
|
||
|
|
This program is free software; you can redistribute it and/or modify
|
||
|
|
it under the terms of the GNU General Public License as published by
|
||
|
|
the Free Software Foundation; use version 2 of the License.
|
||
|
|
|
||
|
|
This program is distributed in the hope that it will be useful,
|
||
|
|
but "AS-IS," WITHOUT ANY WARRANTY; without even the implied warranty
|
||
|
|
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
GNU General Public License for more details.
|
||
|
|
|
||
|
|
You should have received a copy of the GNU General Public License along
|
||
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
||
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||
|
|
*/
|
||
|
|
/* Businesses and individuals that for commercial or other reasons cannot
|
||
|
|
comply with the terms of the GPLv2 license may obtain a commercial license
|
||
|
|
before incorporating Reliance Edge into proprietary software for
|
||
|
|
distribution in any form. Visit http://www.datalight.com/reliance-edge for
|
||
|
|
more information.
|
||
|
|
*/
|
||
|
|
/** @file
|
||
|
|
@brief Implements utilities that convert strings to numbers.
|
||
|
|
*/
|
||
|
|
#include <redfs.h>
|
||
|
|
#include <redtestutils.h>
|
||
|
|
|
||
|
|
|
||
|
|
#define ISHEXDIGITU(c) (((c) >= 'A') && ((c) <= 'F'))
|
||
|
|
#define ISHEXDIGITL(c) (((c) >= 'a') && ((c) <= 'f'))
|
||
|
|
#define ISHEXDIGIT(c) (ISHEXDIGITL(c) || ISHEXDIGITU(c))
|
||
|
|
|
||
|
|
|
||
|
|
/** @brief Converts an ASCII number into an int32_t.
|
||
|
|
|
||
|
|
Converts all decimal digit numbers up to the end of the string or to the
|
||
|
|
first non-numerical character.
|
||
|
|
|
||
|
|
@note This function does *not* ignore leading white space.
|
||
|
|
|
||
|
|
@param pszNum Pointer to a constant array of characters.
|
||
|
|
|
||
|
|
@return The integer represented in the string.
|
||
|
|
*/
|
||
|
|
int32_t RedAtoI(
|
||
|
|
const char *pszNum)
|
||
|
|
{
|
||
|
|
int32_t lValue = 0;
|
||
|
|
int32_t lNegative = 1;
|
||
|
|
uint32_t ulIdx = 0U;
|
||
|
|
|
||
|
|
if(pszNum[ulIdx] == '+')
|
||
|
|
{
|
||
|
|
ulIdx++;
|
||
|
|
}
|
||
|
|
else if(pszNum[ulIdx] == '-')
|
||
|
|
{
|
||
|
|
ulIdx++;
|
||
|
|
lNegative = -1;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* No sign, implicitly positive.
|
||
|
|
*/
|
||
|
|
}
|
||
|
|
|
||
|
|
while(ISDIGIT(pszNum[ulIdx]))
|
||
|
|
{
|
||
|
|
lValue *= 10;
|
||
|
|
lValue += pszNum[ulIdx] - '0';
|
||
|
|
ulIdx++;
|
||
|
|
}
|
||
|
|
|
||
|
|
lValue *= lNegative;
|
||
|
|
|
||
|
|
return lValue;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/** @brief Convert a hexadecimal ASCII number into a uint32_t value.
|
||
|
|
|
||
|
|
The function processes all hex digits up to a NUL-terminator, or to the
|
||
|
|
first non-hex character. Only hexadecimal digits are processed, so leading
|
||
|
|
white space, or a leading "0x" prefix are not allowed.
|
||
|
|
|
||
|
|
If pachNum points to an empty string (points to a NUL), this function will
|
||
|
|
return NULL, and the value at *pulNum will not be modified.
|
||
|
|
|
||
|
|
@note This function does not check for overflow. If there are more
|
||
|
|
significant digits than can be represented in a uint32_t variable, the
|
||
|
|
output is unspecified.
|
||
|
|
|
||
|
|
@param pszNum A pointer to a constant array of hex characters.
|
||
|
|
@param pulNum A pointer to the location in which to store the uint32_t
|
||
|
|
result. Upon return, this value will be modified ONLY if
|
||
|
|
the function succeeds and the returned pointer is valid (not
|
||
|
|
NULL).
|
||
|
|
|
||
|
|
@return A pointer to the byte following the converted number or NULL to
|
||
|
|
indicate failure.
|
||
|
|
*/
|
||
|
|
const char *RedHtoUL(
|
||
|
|
const char *pszNum,
|
||
|
|
uint32_t *pulNum)
|
||
|
|
{
|
||
|
|
uint64_t ullValue;
|
||
|
|
const char *pszReturn;
|
||
|
|
|
||
|
|
pszReturn = RedHtoULL(pszNum, &ullValue);
|
||
|
|
if(pszReturn != NULL)
|
||
|
|
{
|
||
|
|
if(ullValue < UINT32_MAX)
|
||
|
|
{
|
||
|
|
*pulNum = (uint32_t)ullValue;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pszReturn = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return pszReturn;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/** @brief Convert a hexadecimal ASCII number into a D_UINT64 value.
|
||
|
|
|
||
|
|
The function processes all hex digits up to a NUL-terminator, or to the
|
||
|
|
first non-hex character. Only hexadecimal digits are processed, so leading
|
||
|
|
white space, or a leading "0x" prefix are not allowed.
|
||
|
|
|
||
|
|
If pachNum points to an empty string (points to a NUL), this function will
|
||
|
|
return NULL, and the value at *pulNum will not be modified.
|
||
|
|
|
||
|
|
@note This function does not check for overflow. If there are more
|
||
|
|
significant digits than can be represented in a uint64_t variable, the
|
||
|
|
output is unspecified.
|
||
|
|
|
||
|
|
@param pszNum A pointer to a constant array of hex characters.
|
||
|
|
@param pullNum A pointer to the location in which to store the uint64_t
|
||
|
|
result. Upon return, this value will be modified ONLY if
|
||
|
|
the function succeeds and the returned pointer is valid (not
|
||
|
|
NULL).
|
||
|
|
|
||
|
|
@return A pointer to the byte following the converted number, or NULL to
|
||
|
|
indicate failure.
|
||
|
|
*/
|
||
|
|
const char *RedHtoULL(
|
||
|
|
const char *pszNum,
|
||
|
|
uint64_t *pullNum)
|
||
|
|
{
|
||
|
|
uint64_t ullValue = 0U;
|
||
|
|
const char *pszReturn = NULL;
|
||
|
|
uint32_t ulIdx = 0U;
|
||
|
|
|
||
|
|
REDASSERT(pszNum != NULL);
|
||
|
|
REDASSERT(pullNum != NULL);
|
||
|
|
|
||
|
|
while(pszNum[ulIdx] != '\0')
|
||
|
|
{
|
||
|
|
char cDigit = pszNum[ulIdx];
|
||
|
|
|
||
|
|
if(ISDIGIT(cDigit))
|
||
|
|
{
|
||
|
|
cDigit -= '0';
|
||
|
|
}
|
||
|
|
else if(ISHEXDIGITU(cDigit))
|
||
|
|
{
|
||
|
|
cDigit -= ('A' - 10);
|
||
|
|
}
|
||
|
|
else if(ISHEXDIGITL(cDigit))
|
||
|
|
{
|
||
|
|
cDigit -= ('a' - 10);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
REDASSERT((ullValue & UINT64_SUFFIX(0xF000000000000000)) == 0U);
|
||
|
|
|
||
|
|
ullValue <<= 4U;
|
||
|
|
ullValue += cDigit;
|
||
|
|
|
||
|
|
ulIdx++;
|
||
|
|
pszReturn = &pszNum[ulIdx];
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Modify the number returned only if we found one or more valid hex
|
||
|
|
digits.
|
||
|
|
*/
|
||
|
|
if(pszReturn != NULL)
|
||
|
|
{
|
||
|
|
*pullNum = ullValue;
|
||
|
|
}
|
||
|
|
|
||
|
|
return pszReturn;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/** @brief Convert the ASCII number to a uint32_t value.
|
||
|
|
|
||
|
|
The number may be hex or decimal. Hex numbers must be prefixed by '0x', and
|
||
|
|
they may be upper or lower case. The conversion process will stop with the
|
||
|
|
first non hex or decimal digit.
|
||
|
|
|
||
|
|
If the number is negative (the first character is a '-' sign), the value
|
||
|
|
will be range checked and returned as the equivalent unsigned value.
|
||
|
|
|
||
|
|
@note This function will NOT fail for numbers which exceed the size of a
|
||
|
|
uint32_t value.
|
||
|
|
|
||
|
|
@param pszNum A pointer to the ASCII number to convert
|
||
|
|
@param pulNum A pointer to the uint32_t location to store the result.
|
||
|
|
This value will be modified on return only if the function
|
||
|
|
succeeds and the returned pointer is valid (not NULL).
|
||
|
|
|
||
|
|
@return A pointer to the byte following the converted number, or NULL to
|
||
|
|
indicate failure.
|
||
|
|
*/
|
||
|
|
const char *RedNtoUL(
|
||
|
|
const char *pszNum,
|
||
|
|
uint32_t *pulNum)
|
||
|
|
{
|
||
|
|
bool fNegative = false;
|
||
|
|
uint32_t ulIdx = 0U;
|
||
|
|
const char *pszReturn;
|
||
|
|
|
||
|
|
REDASSERT(pszNum != NULL);
|
||
|
|
REDASSERT(pulNum != NULL);
|
||
|
|
|
||
|
|
if(pszNum[ulIdx] == '-')
|
||
|
|
{
|
||
|
|
fNegative = true;
|
||
|
|
ulIdx++;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Hex numbers must be prefixed with '0x'.
|
||
|
|
*/
|
||
|
|
if((pszNum[ulIdx] == '0') && ((pszNum[ulIdx + 1U] == 'x') || (pszNum[ulIdx + 1U] == 'X')))
|
||
|
|
{
|
||
|
|
ulIdx += 2U;
|
||
|
|
|
||
|
|
if(ISDIGIT(pszNum[ulIdx]) || ISHEXDIGIT(pszNum[ulIdx]))
|
||
|
|
{
|
||
|
|
pszReturn = RedHtoUL(&pszNum[ulIdx], pulNum);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pszReturn = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if(ISDIGIT(pszNum[ulIdx]))
|
||
|
|
{
|
||
|
|
uint32_t ulTemp;
|
||
|
|
|
||
|
|
ulTemp = RedAtoI(&pszNum[ulIdx]);
|
||
|
|
|
||
|
|
while(ISDIGIT(pszNum[ulIdx]))
|
||
|
|
{
|
||
|
|
ulIdx++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(fNegative)
|
||
|
|
{
|
||
|
|
/* Fail if the number is out of range.
|
||
|
|
*/
|
||
|
|
if(ulTemp > INT32_MAX)
|
||
|
|
{
|
||
|
|
pszReturn = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*pulNum = -((int32_t)ulTemp);
|
||
|
|
pszReturn = &pszNum[ulIdx];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*pulNum = ulTemp;
|
||
|
|
pszReturn = &pszNum[ulIdx];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* Return an error if there is not at least one hex or decimal digit.
|
||
|
|
*/
|
||
|
|
pszReturn = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
return pszReturn;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/** @brief Convert the ASCII number pointed to by pachNum to a uint64_t value.
|
||
|
|
|
||
|
|
The number may be hex or decimal. Hex numbers must be prefixed by '0x', and
|
||
|
|
they may be upper or lower case. The conversion process will stop with the
|
||
|
|
first non hex or decimal digit.
|
||
|
|
|
||
|
|
If the number is negative (the first character is a '-' sign), the value
|
||
|
|
will be range checked and returned as the equivalent unsigned value.
|
||
|
|
|
||
|
|
@param pszNum A pointer to the ASCII number to convert.
|
||
|
|
@param pullNum A pointer to the uint64_t location to store the result.
|
||
|
|
This value will be modified on return only if the function
|
||
|
|
succeeds and the returned pointer is valid (not NULL).
|
||
|
|
|
||
|
|
@return A pointer to the byte following the converted number, or NULL to
|
||
|
|
indicate failure.
|
||
|
|
*/
|
||
|
|
const char *RedNtoULL(
|
||
|
|
const char *pszNum,
|
||
|
|
uint64_t *pullNum)
|
||
|
|
{
|
||
|
|
bool fNegative = false;
|
||
|
|
uint32_t ulIdx = 0U;
|
||
|
|
const char *pszReturn;
|
||
|
|
|
||
|
|
REDASSERT(pszNum != NULL);
|
||
|
|
REDASSERT(pullNum != NULL);
|
||
|
|
|
||
|
|
if(pszNum[ulIdx] == '-')
|
||
|
|
{
|
||
|
|
fNegative = true;
|
||
|
|
ulIdx++;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Hex numbers must be prefixed with '0x'.
|
||
|
|
*/
|
||
|
|
if((pszNum[ulIdx] == '0') && ((pszNum[ulIdx + 1U] == 'x') || (pszNum[ulIdx + 1U] == 'X')))
|
||
|
|
{
|
||
|
|
ulIdx += 2U;
|
||
|
|
|
||
|
|
if(ISDIGIT(pszNum[ulIdx]) || ISHEXDIGIT(pszNum[ulIdx]))
|
||
|
|
{
|
||
|
|
pszReturn = RedHtoULL(&pszNum[ulIdx], pullNum);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pszReturn = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if(ISDIGIT(pszNum[ulIdx]))
|
||
|
|
{
|
||
|
|
uint64_t ullTemp = 0U;
|
||
|
|
|
||
|
|
while(ISDIGIT(pszNum[ulIdx]))
|
||
|
|
{
|
||
|
|
ullTemp *= 10U;
|
||
|
|
ullTemp += pszNum[ulIdx] - '0';
|
||
|
|
ulIdx++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(fNegative)
|
||
|
|
{
|
||
|
|
/* Fail if the number is out of range.
|
||
|
|
*/
|
||
|
|
if(ullTemp > INT64_MAX)
|
||
|
|
{
|
||
|
|
pszReturn = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*pullNum = (uint64_t)(-((int64_t)ullTemp));
|
||
|
|
pszReturn = &pszNum[ulIdx];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*pullNum = ullTemp;
|
||
|
|
pszReturn = &pszNum[ulIdx];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* Return an error if there is not at least one hex or decimal digit.
|
||
|
|
*/
|
||
|
|
pszReturn = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
return pszReturn;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/** @brief Convert an ASCII hex or decimal number, which may may have a "B",
|
||
|
|
"KB", or "MB" suffix (case insensitive), to a binary value.
|
||
|
|
|
||
|
|
Hex numbers must be prefixed with "0x".
|
||
|
|
|
||
|
|
@note If there is no postfix, KB is assumed!
|
||
|
|
|
||
|
|
May fail due to bad formatting or overflow.
|
||
|
|
|
||
|
|
@param pszNum A pointer to the ASCII number to convert.
|
||
|
|
@param pulResult A pointer to a uint32_t in which to place the result.
|
||
|
|
|
||
|
|
@return A pointer to the byte following the string, or NULL to indicate an
|
||
|
|
error. In the event of an error, *pulResult will not be modified.
|
||
|
|
*/
|
||
|
|
const char *RedSizeToUL(
|
||
|
|
const char *pszNum,
|
||
|
|
uint32_t *pulResult)
|
||
|
|
{
|
||
|
|
uint32_t ulResult;
|
||
|
|
const char *pszSuffix;
|
||
|
|
const char *pszReturn;
|
||
|
|
uint32_t ulIdx = 0U;
|
||
|
|
|
||
|
|
REDASSERT(pszNum != NULL);
|
||
|
|
REDASSERT(pulResult != NULL);
|
||
|
|
|
||
|
|
/* Do the basic hex/decimal conversion
|
||
|
|
*/
|
||
|
|
pszSuffix = RedNtoUL(pszNum, &ulResult);
|
||
|
|
if(pszSuffix != NULL)
|
||
|
|
{
|
||
|
|
if((pszSuffix[ulIdx] == 'B') || (pszSuffix[ulIdx] == 'b'))
|
||
|
|
{
|
||
|
|
ulIdx++;
|
||
|
|
pszReturn = &pszSuffix[ulIdx];
|
||
|
|
}
|
||
|
|
else if( ((pszSuffix[ulIdx] == 'M') || (pszSuffix[ulIdx] == 'm'))
|
||
|
|
&& ((pszSuffix[ulIdx + 1U] == 'B') || (pszSuffix[ulIdx + 1U] == 'b')))
|
||
|
|
{
|
||
|
|
ulIdx += 2U;
|
||
|
|
|
||
|
|
if(ulResult > (UINT32_MAX / (1024U * 1024U)))
|
||
|
|
{
|
||
|
|
pszReturn = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ulResult *= 1024U * 1024U;
|
||
|
|
pszReturn = &pszSuffix[ulIdx];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* The number is either postfixed with "KB" or something
|
||
|
|
else (we don't care), but we must increment the pointer
|
||
|
|
if it is something recognize.
|
||
|
|
*/
|
||
|
|
if( ((pszSuffix[ulIdx] == 'K') || (pszSuffix[ulIdx] == 'k'))
|
||
|
|
&& ((pszSuffix[ulIdx + 1U] == 'B') || (pszSuffix[ulIdx + 1U] == 'b')))
|
||
|
|
{
|
||
|
|
ulIdx += 2U;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* "B" or "MB" were not specified, so it must be "KB"
|
||
|
|
*/
|
||
|
|
if(ulResult > (UINT32_MAX / 1024U))
|
||
|
|
{
|
||
|
|
pszReturn = NULL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ulResult *= 1024UL;
|
||
|
|
pszReturn = &pszSuffix[ulIdx];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pszReturn != NULL)
|
||
|
|
{
|
||
|
|
*pulResult = ulResult;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pszReturn = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
return pszReturn;
|
||
|
|
}
|
||
|
|
|