werunplugged/unplugged-vendor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ebc759d833
unplugged-vendor/external/fastrpc/src/std_strlprintf.c

760 lines
21 KiB
C
Raw Blame History

/*
* Copyright (c) 2019, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of The Linux Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "AEEstd.h"
#include "AEEBufBound.h"
#include "AEEsmath.h"
#include "AEEStdErr.h"
#include "std_dtoa.h"
//#include "math.h"
//==============================================================================
// Macro definitions
//==============================================================================
#define ISDIGIT(c) ( (c) >= '0' && (c) <= '9')
#define TOLOWER(c) ( (c) | 32 ) // works only for letters
#define FAILED(b) ( (b) != AEE_SUCCESS ? TRUE : FALSE )
#define CLEANUP_ON_ERROR(b,l) if( FAILED( b ) ) { goto l; }
#define ROUND(d, p) fp_round( d, p )
#define FP_POW_10(n) fp_pow_10(n)
//==============================================================================
// Type definitions
//==============================================================================
// Formatting flags
#define FF_PLUS 1 // '+'
#define FF_MINUS 2 // '-'
#define FF_POUND 4 // '#'
#define FF_BLANK 8 // ' '
#define FF_ZERO 16 // '0'
typedef struct {
// Parsed values (from "%..." expression)
int flags; // FF_PLUS, FF_MINUS, etc.
char cType; // d, s, c, x, X, etc.
int32 nWidth; // number preceding '.' : controls padding
int32 nPrecision; // number following '.' (-1 if not given)
// Computed values
const char * pszStr; // string holding prefix + value
int nPrefix; // # of numeric prefix bytes in pszStr[]
int nLen; // length of string (after prefix)
int nNumWidth; // minimum numeric value size (pad with '0')
} FieldFormat;
typedef int (*pfnFormatFloat)(FieldFormat* me, double dNumber, char* pcBuffer);
//==============================================================================
// Function definitions
//==============================================================================
// Read an unsigned decimal integer
//
static int ScanDecimal(const char **ppsz)
{
int n = 0;
const char *psz;
for (psz = *ppsz; ISDIGIT(*psz); ++psz) {
n = n*10 + (int) (*psz - '0');
}
*ppsz = psz;
return n;
}
#define FORMATNUMBER_SIZE 24 // octal: 22 + '0' + null ; decimal: 20 + sign + null
// Convert number to string, setting computed fields in FieldFormat.
//
// pcBuf[] must have room for at least FORMATNUMBER_SIZE characters
// return value: length of string.
//
static __inline void
FormatNumber(FieldFormat *me, char pcBuf[FORMATNUMBER_SIZE], uint64 uNum64)
{
char cType = me->cType;
const char *cpszDigits;
char *pc = pcBuf;
int nBase;
char *pcRev;
if (cType == 'p') {
cType = 'X';
me->nPrecision = 8;
}
if (me->nPrecision >= 0) {
me->nNumWidth = me->nPrecision;
// Odd thing: '0' flag is ignored for numbers when precision is
// specified.
me->flags &= ~FF_ZERO;
} else {
me->nNumWidth = 1;
}
// Output prefix
if (( 'd' == cType || 'i' == cType)) {
if ((int64)uNum64 < 0) {
*pc++ = '-';
uNum64 = (uint64)-(int64)uNum64;
} else if (me->flags & FF_PLUS) {
*pc++ = '+';
} else if (me->flags & FF_BLANK) {
*pc++ = ' ';
}
}
if ((me->flags & FF_POUND) && 0 != uNum64) {
if ('x' == TOLOWER(cType)) {
*pc++ = '0';
*pc++ = cType;
} else if ('o' == cType) {
*pc++ = '0';
// Odd thing about libc printf: "0" prefix counts as part of minimum
// width, but "0x" prefix does not.
--me->nNumWidth;
}
}
me->nPrefix = pc - pcBuf;
// Output unsigned numeric value
nBase = ('o' == cType ? 8 :
'x' == TOLOWER(cType) ? 16 :
10);
cpszDigits = ((cType == 'X') ? "0123456789ABCDEF"
: "0123456789abcdef");
pcRev = pc;
while (uNum64) {
*pc++ = cpszDigits[uNum64 % (unsigned)nBase];
uNum64 /= (unsigned)nBase;
}
*pc = '\0';
me->pszStr = pcBuf;
me->nLen = pc - pcRev;
// Reverse string
--pc;
for (; pcRev < pc; ++pcRev, --pc) {
char c = *pc;
*pc = *pcRev;
*pcRev = c;
}
}
//
// This function converts the input floating point number dNumber to an
// ASCII string using either %f or %F formatting. This functions assumes
// that dNumer is a valid floating point number (i.e., dNumber is NOT
// +/-INF or NaN). The size of the output buffer pcBuffer should be at
// least STD_DTOA_FORMAT_FLOAT_SIZE.
//
static int ConvertFloat(FieldFormat* me, double dNumber, char* pcBuffer,
int nBufSize)
{
int nError = AEE_SUCCESS;
int32 nPrecision = 0;
int nIndex = 0;
BufBound OutBuf;
char szIntegerPart[STD_DTOA_FORMAT_INTEGER_SIZE] = {0};
char szFractionPart[STD_DTOA_FORMAT_FRACTION_SIZE] = {0};
int nExponent = 0;
char cType = TOLOWER(me->cType);
// Set the precision for conversion
nPrecision = me->nPrecision;
if (nPrecision < 0) {
// No precision was specified, set it to the default value if the
// format specifier is not %a
if (cType != 'a') {
nPrecision = STD_DTOA_DEFAULT_FLOAT_PRECISION;
}
}
else if ((0 == nPrecision) && ('g' == cType)) {
nPrecision = 1;
}
if (cType != 'a') {
// For %g, check whether to use %e of %f formatting style.
// Also, set the precision value accordingly since in this case the user
// specified value is really the number of significant digits.
// These next few steps should be skipped if the input number is 0.
if (dNumber != 0.0) {
nExponent = fp_log_10(dNumber);
if ('g' == cType) {
if ((nExponent < -4) || (nExponent >= nPrecision)) {
cType = 'e';
nPrecision = nPrecision - 1;
}
else {
cType = 'f';
nPrecision = nPrecision - nExponent - 1;
}
}
// For %e, convert the number to the form d.ddd
if ('e' == cType) {
dNumber = dNumber / FP_POW_10(nExponent);
}
// Now, round the number to the specified precision
dNumber = ROUND(dNumber, nPrecision);
// For %e, the rounding operation may have resulted in a number dd.ddd
// Reconvert it to the form d.ddd
if (('e' == cType) && ((dNumber >= 10.0) || (dNumber <= -10.0))) {
dNumber = dNumber / 10.0;
nExponent++;
}
}
// Convert the decmial number to string
nError = std_dtoa_decimal(dNumber, nPrecision, szIntegerPart, szFractionPart);
CLEANUP_ON_ERROR(nError, bail);
}
else
{
// Conver the hex floating point number to string
nError = std_dtoa_hex(dNumber, nPrecision, me->cType, szIntegerPart,
szFractionPart, &nExponent);
CLEANUP_ON_ERROR(nError, bail);
}
//
// Write the output as per the specified format.
// First: Check for any prefixes that need to be added to the output.
// The only possible prefixes are '-', '+' or ' '. The following rules
// are applicable:
// 1. One and only one prefix will be applicable at any time.
// 2. If the number is negative, then '+' and ' ' are not applicable.
// 3. For positive numbers, the prefix '+' takes precedence over ' '.
//
// In addition, we were dealing with a hex floating point number (%a),
// then we need to write of the 0x prefix.
//
BufBound_Init(&OutBuf, pcBuffer, nBufSize);
if (dNumber < 0.0) {
// The '-' sign would have already been added to the szIntegerPart by
// the conversion function.
me->nPrefix = 1;
}
if (dNumber >= 0.0){
if (me->flags & FF_PLUS) {
BufBound_Putc(&OutBuf, '+');
me->nPrefix = 1;
}
else if(me->flags & FF_BLANK) {
BufBound_Putc(&OutBuf, ' ');
me->nPrefix = 1;
}
}
// For %a, write out the 0x prefix
if ('a' == cType) {
BufBound_Putc(&OutBuf, '0');
BufBound_Putc(&OutBuf, ('a' == me->cType) ? 'x' : 'X');
me->nPrefix += 2;
}
// Second: Write the integer part
BufBound_Puts(&OutBuf, szIntegerPart);
// Third: Write the decimal point followed by the fraction part.
// For %g, we need to truncate the trailing zeros in the fraction.
// Skip this if the '#' flag is specified
if (!(me->flags & FF_POUND) && ('g' == TOLOWER(me->cType))) {
for (nIndex = std_strlen(szFractionPart) - 1;
(nIndex >= 0) && (szFractionPart[nIndex] == '0'); nIndex--) {
szFractionPart[nIndex] = '\0';
}
}
// The decimal point is specified only if there are some decimal digits.
// However, if the '#' format specifier is present then the decimal point
// will be present.
if ((me->flags & FF_POUND) || (*szFractionPart != 0)) {
BufBound_Putc(&OutBuf, '.');
// Write the fraction part
BufBound_Puts(&OutBuf, szFractionPart);
}
// For %e and %a, write out the exponent
if (('e' == cType) || ('a' == cType)) {
char* pcExpStart = NULL;
char* pcExpEnd = NULL;
char cTemp = 0;
if ('a' == me->cType) {
BufBound_Putc(&OutBuf, 'p');
}
else if ('A' == me->cType) {
BufBound_Putc(&OutBuf, 'P');
}
else if (('e' == me->cType) || ('g' == me->cType)) {
BufBound_Putc(&OutBuf, 'e');
}
else {
BufBound_Putc(&OutBuf, 'E');
}
// Write the exponent sign
if (nExponent < 0) {
BufBound_Putc(&OutBuf, '-');
nExponent = -nExponent;
}
else {
BufBound_Putc(&OutBuf, '+');
}
// Write out the exponent.
// For %e, the exponent should at least be two digits.
// The exponent to be written will be at most 4 digits as any
// overflow would have been take care of by now.
if (BufBound_Left(&OutBuf) >= 4) {
if ('e' == cType) {
if (nExponent < 10) {
BufBound_Putc(&OutBuf, '0');
}
}
pcExpStart = OutBuf.pcWrite;
do {
BufBound_Putc(&OutBuf, '0' + (nExponent % 10));
nExponent /= 10;
} while (nExponent);
pcExpEnd = OutBuf.pcWrite - 1;
// Reverse the exponent
for (; pcExpStart < pcExpEnd; pcExpStart++, pcExpEnd--) {
cTemp = *pcExpStart;
*pcExpStart = *pcExpEnd;
*pcExpEnd = cTemp;
}
}
}
// Null-terminate the string
BufBound_ForceNullTerm(&OutBuf);
// Set the output parameters
// We do not care if there was enough space in the output buffer or not.
// The output would be truncated to a maximum length of
// STD_DTOA_FORMAT_FLOAT_SIZE.
me->pszStr = OutBuf.pcBuf;
me->nLen = BufBound_ReallyWrote(&OutBuf) - me->nPrefix - 1;
bail:
return nError;
}
//
// This is a wrapper function that converts an input floating point number
// to a string based on a given format specifier %e, %f or %g. It first checks
// if the specified number is a valid floating point number before calling
// the function that does the conversion.
//
// The size of the output buffer pcBuffer should be at least STD_DTOA_FORMAT_FLOAT_SIZE.
//
static int FormatFloat(FieldFormat* me, double dNumber,
char pcBuffer[STD_DTOA_FORMAT_FLOAT_SIZE])
{
int nError = AEE_SUCCESS;
FloatingPointType NumberType = FP_TYPE_UNKOWN;
// Check for error conditions
if (NULL == pcBuffer) {
nError = AEE_EBADPARM;
goto bail;
}
// Initialize the output params first
me->nLen = 0;
me->nPrefix = 0;
// Check for special cases such as NaN and Infinity
nError = fp_check_special_cases(dNumber, &NumberType);
CLEANUP_ON_ERROR(nError, bail);
switch(NumberType) {
case FP_TYPE_NEGATIVE_INF:
if (('E' == me->cType) || ('F' == me->cType) || ('G' == me->cType)) {
me->nLen = std_strlcpy(pcBuffer, STD_DTOA_NEGATIVE_INF_UPPER_CASE,
STD_DTOA_FORMAT_FLOAT_SIZE);
}
else {
me->nLen = std_strlcpy(pcBuffer, STD_DTOA_NEGATIVE_INF_LOWER_CASE,
STD_DTOA_FORMAT_FLOAT_SIZE);
}
// Don't pad with 0's
me->flags &= ~FF_ZERO;
break;
case FP_TYPE_POSITIVE_INF:
if (('E' == me->cType) || ('F' == me->cType) || ('G' == me->cType)) {
me->nLen = std_strlcpy(pcBuffer, STD_DTOA_POSITIVE_INF_UPPER_CASE,
STD_DTOA_FORMAT_FLOAT_SIZE);
}
else {
me->nLen = std_strlcpy(pcBuffer, STD_DTOA_POSITIVE_INF_LOWER_CASE,
STD_DTOA_FORMAT_FLOAT_SIZE);
}
// Don't pad with 0's
me->flags &= ~FF_ZERO;
break;
case FP_TYPE_NAN:
if (('E' == me->cType) || ('F' == me->cType) || ('G' == me->cType)) {
me->nLen = std_strlcpy(pcBuffer, STD_DTOA_NAN_UPPER_CASE,
STD_DTOA_FORMAT_FLOAT_SIZE);
}
else
{
me->nLen = std_strlcpy(pcBuffer, STD_DTOA_NAN_LOWER_CASE,
STD_DTOA_FORMAT_FLOAT_SIZE);
}
// Don't pad with 0's
me->flags &= ~FF_ZERO;
break;
case FP_TYPE_GENERAL:
nError = ConvertFloat(me, dNumber, pcBuffer,
STD_DTOA_FORMAT_FLOAT_SIZE);
CLEANUP_ON_ERROR(nError, bail);
break;
default:
// This should only happen if this function has been modified
// to support other special cases and this block has not been
// updated.
nError = AEE_EFAILED;
goto bail;
}
// Set the output parameters
me->pszStr = pcBuffer;
bail:
return nError;
}
static int std_strlprintf_inner(char *pszDest, int nDestSize,
const char *cpszFmt, AEEVaList args,
pfnFormatFloat pfnFormatFloatFunc)
{
BufBound bb;
const char *pcIn = cpszFmt;
BufBound_Init(&bb, pszDest, nDestSize);
for (;;) {
FieldFormat ff;
const char *pcEsc;
char achBuf[FORMATNUMBER_SIZE];
char achBuf2[STD_DTOA_FORMAT_FLOAT_SIZE];
char cType;
boolean bLong = 0;
pcEsc = std_strchrend(pcIn, '%');
BufBound_Write(&bb, pcIn, pcEsc-pcIn);
if (0 == *pcEsc) {
break;
}
pcIn = pcEsc+1;
//----------------------------------------------------
// Consume "%..." specifiers:
//
// %[FLAGS] [WIDTH] [.PRECISION] [{h | l | I64 | L}]
//----------------------------------------------------
std_memset(&ff, 0, sizeof(FieldFormat));
ff.nPrecision = -1;
// Consume all flags
for (;;) {
int f;
f = (('+' == *pcIn) ? FF_PLUS :
('-' == *pcIn) ? FF_MINUS :
('#' == *pcIn) ? FF_POUND :
(' ' == *pcIn) ? FF_BLANK :
('0' == *pcIn) ? FF_ZERO : 0);
if (0 == f) {
break;
}
ff.flags |= f;
++pcIn;
}
// Consume width
if ('*' == *pcIn) {
AEEVA_ARG(args, ff.nWidth, int32);
pcIn++;
} else {
ff.nWidth = ScanDecimal(&pcIn);
}
if ((ff.flags & FF_MINUS) && ff.nWidth > 0) {
ff.nWidth = -ff.nWidth;
}
// Consume precision
if ('.' == *pcIn) {
pcIn++;
if ('*' == *pcIn) { // Can be *... (given in int * param)
AEEVA_ARG(args, ff.nPrecision, int32);
pcIn++;
} else {
ff.nPrecision = ScanDecimal(&pcIn);
}
}
// Consume size designator
{
static const struct {
char szPre[3];
boolean b64;
} a[] = {
{ "l", 0, },
{ "ll", 1, },
{ "L", 1, },
{ "j", 1, },
{ "h", 0, },
{ "hh", 0, },
{ "z", 0 }
};
int n = STD_ARRAY_SIZE(a);
while (--n >= 0) {
const char *psz = std_strbegins(pcIn, a[n].szPre);
if ((const char*)0 != psz) {
pcIn = psz;
bLong = a[n].b64;
break;
}
}
}
//----------------------------------------------------
//
// Format output values
//
//----------------------------------------------------
ff.cType = cType = *pcIn++;
if ('s' == cType) {
// String
char *psz;
AEEVA_ARG(args, psz, char*);
ff.pszStr = psz;
ff.nLen = std_strlen(psz);
if (ff.nPrecision >= 0 && ff.nPrecision < ff.nLen) {
ff.nLen = ff.nPrecision;
}
} else if ('c' == cType) {
// char
AEEVA_ARG(args, achBuf[0], int);
achBuf[1] = '\0';
ff.pszStr = achBuf;
ff.nLen = 1;
} else if ('u' == cType ||
'o' == cType ||
'd' == cType ||
'i' == cType ||
'p' == cType ||
'x' == TOLOWER(cType) ) {
// int
uint64 uArg64;
if (bLong) {
AEEVA_ARG(args, uArg64, int64); // See how much room needed
} else {
uint32 uArg32;
AEEVA_ARG(args, uArg32, int32); // See how much room needed
uArg64 = uArg32;
if ('d' == cType || 'i' == cType) {
uArg64 = (uint64)(int64)(int32)uArg32;
}
}
FormatNumber(&ff, achBuf, uArg64);
} else if (pfnFormatFloatFunc &&
('e' == TOLOWER(cType) ||
'f' == TOLOWER(cType) ||
'g' == TOLOWER(cType) ||
'a' == TOLOWER(cType))) {
// float
int nError = AEE_SUCCESS;
double dNumber;
AEEVA_ARG(args, dNumber, double);
nError = pfnFormatFloatFunc(&ff, dNumber, achBuf2);
if (FAILED(nError)) {
continue;
}
} else if ('\0' == cType) {
// premature end
break;
} else {
// Unknown type
BufBound_Putc(&bb, cType);
continue;
}
// FieldFormat computed variables + nWidth controls output
if (ff.flags & FF_ZERO) {
ff.nNumWidth = ff.nWidth - ff.nPrefix;
}
{
int nLen1 = ff.nLen;
int nLen2 = STD_MAX(ff.nNumWidth, nLen1) + ff.nPrefix;
// Putnc() safely ignores negative sizes
BufBound_Putnc(&bb, ' ', smath_Sub(ff.nWidth,nLen2));
BufBound_Write(&bb, ff.pszStr, ff.nPrefix);
BufBound_Putnc(&bb, '0', smath_Sub(ff.nNumWidth, nLen1));
BufBound_Write(&bb, ff.pszStr+ff.nPrefix, nLen1);
BufBound_Putnc(&bb, ' ', smath_Sub(-nLen2, ff.nWidth));
}
}
AEEVA_END(args);
BufBound_ForceNullTerm(&bb);
/* Return number of bytes required regardless if buffer bound was reached */
/* Note that we subtract 1 because the NUL byte which was added in
BufBound_ForceNullTerm() is counted as a written byte; the semantics
of both the ...printf() functions and the strl...() functions call for
the NUL byte to be excluded from the count. */
return BufBound_Wrote(&bb)-1;
}
int std_vstrlprintf(char *pszDest, int nDestSize,
const char *cpszFmt,
AEEVaList args)
{
return std_strlprintf_inner(pszDest, nDestSize, cpszFmt, args, NULL);
}
int std_vsnprintf(char *pszDest, int nDestSize,
const char *cpszFmt,
AEEVaList args)
/*
Same as std_vstrlprintf with the additional support of floating point
conversion specifiers - %e, %f, %g and %a
*/
{
return std_strlprintf_inner(pszDest, nDestSize, cpszFmt, args, FormatFloat);
}
int std_strlprintf(char *pszDest, int nDestSize, const char *pszFmt, ...)
{
int nRet;
AEEVaList args;
AEEVA_START(args, pszFmt);
nRet = std_vstrlprintf(pszDest, nDestSize, pszFmt, args);
AEEVA_END(args);
return nRet;
}
int std_snprintf(char *pszDest, int nDestSize, const char *pszFmt, ...)
/*
Same as std_strlprintf with the additional support of floating point
conversion specifiers - %e, %f, %g and %a
*/
{
int nRet;
AEEVaList args;
AEEVA_START(args, pszFmt);
nRet = std_vsnprintf(pszDest, nDestSize, pszFmt, args);
AEEVA_END(args);
return nRet;
}
Reference in New Issue View Git Blame Copy Permalink