mirror/mongoose
1
0
Fork 0
mirror of https://github.com/cesanta/mongoose.git synced 2024-12-21 13:42:15 +08:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity
f883504d2d
mongoose/examples/nxp/rt1060-evk-xpresso-baremetal-builtin/utilities/fsl_str.c

1618 lines
46 KiB
C
Raw Normal View History

add RT1060 Xpresso example
2024-01-06 05:24:47 +08:00
/*
* Copyright 2017, 2020, 2022 NXP
* All rights reserved.
*
*
* SPDX-License-Identifier: BSD-3-Clause
*
*/
#include <math.h>
#include <stdarg.h>
#include <stdlib.h>
#include <errno.h> /* MISRA C-2012 Rule 22.9 */
#include "fsl_str.h"
/*******************************************************************************
* Definitions
******************************************************************************/
/*! @brief The overflow value.*/
#ifndef HUGE_VAL
#define HUGE_VAL (99.e99)
#endif /* HUGE_VAL */
#ifndef MAX_FIELD_WIDTH
#define MAX_FIELD_WIDTH 99U
#endif
/*! @brief Keil: suppress ellipsis warning in va_arg usage below. */
#if defined(__CC_ARM)
#pragma diag_suppress 1256
#endif /* __CC_ARM */
/*******************************************************************************
* Prototypes
******************************************************************************/
/*!
* @brief Scanline function which ignores white spaces.
*
* @param[in] s The address of the string pointer to update.
* @return String without white spaces.
*/
static uint32_t ScanIgnoreWhiteSpace(const char **s);
/*!
* @brief Converts a radix number to a string and return its length.
*
* @param[in] numstr Converted string of the number.
* @param[in] nump Pointer to the number.
* @param[in] neg Polarity of the number.
* @param[in] radix The radix to be converted to.
* @param[in] use_caps Used to identify %x/X output format.
* @return Length of the converted string.
*/
static int32_t ConvertRadixNumToString(char *numstr, void *nump, unsigned int neg, unsigned int radix, bool use_caps);
#if (defined(PRINTF_FLOAT_ENABLE) && (PRINTF_FLOAT_ENABLE > 0U))
/*!
* @brief Converts a floating radix number to a string and return its length.
*
* @param[in] numstr Converted string of the number.
* @param[in] nump Pointer to the number.
* @param[in] radix The radix to be converted to.
* @param[in] precision_width Specify the precision width.
* @return Length of the converted string.
*/
static int32_t ConvertFloatRadixNumToString(char *numstr, void *nump, int32_t radix, uint32_t precision_width);
#endif /* PRINTF_FLOAT_ENABLE */
/*************Code for process formatted data*******************************/
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
static uint8_t PrintGetSignChar(long long int ival, uint32_t flags_used, char *schar)
{
uint8_t len = 1U;
if (ival < 0)
{
*schar = '-';
}
else
{
if (0U != (flags_used & (uint32_t)kPRINTF_Plus))
{
*schar = '+';
}
else if (0U != (flags_used & (uint32_t)kPRINTF_Space))
{
*schar = ' ';
}
else
{
*schar = '\0';
len = 0U;
}
}
return len;
}
#endif /* PRINTF_ADVANCED_ENABLE */
static uint32_t PrintGetWidth(const char **p, va_list *ap)
{
uint32_t field_width = 0;
uint8_t done = 0U;
char c;
while (0U == done)
{
c = *(++(*p));
if ((c >= '0') && (c <= '9'))
{
(field_width) = ((field_width)*10U) + ((uint32_t)c - (uint32_t)'0');
}
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
else if (c == '*')
{
(field_width) = (uint32_t)va_arg(*ap, uint32_t);
}
#endif /* PRINTF_ADVANCED_ENABLE */
else
{
/* We've gone one char too far. */
--(*p);
done = 1U;
}
}
return field_width;
}
static uint32_t PrintGetPrecision(const char **s, va_list *ap, bool *valid_precision_width)
{
const char *p = *s;
uint32_t precision_width = 6U;
uint8_t done = 0U;
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
if (NULL != valid_precision_width)
{
*valid_precision_width = false;
}
#endif /* PRINTF_ADVANCED_ENABLE */
if (*++p == '.')
{
/* Must get precision field width, if present. */
precision_width = 0U;
done = 0U;
while (0U == done)
{
char c = *++p;
if ((c >= '0') && (c <= '9'))
{
precision_width = (precision_width * 10U) + ((uint32_t)c - (uint32_t)'0');
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
if (NULL != valid_precision_width)
{
*valid_precision_width = true;
}
#endif /* PRINTF_ADVANCED_ENABLE */
}
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
else if (c == '*')
{
precision_width = (uint32_t)va_arg(*ap, uint32_t);
if (NULL != valid_precision_width)
{
*valid_precision_width = true;
}
}
#endif /* PRINTF_ADVANCED_ENABLE */
else
{
/* We've gone one char too far. */
--p;
done = 1U;
}
}
}
else
{
/* We've gone one char too far. */
--p;
}
*s = p;
return precision_width;
}
static uint32_t PrintIsobpu(const char c)
{
uint32_t ret = 0U;
if ((c == 'o') || (c == 'b') || (c == 'p') || (c == 'u'))
{
ret = 1U;
}
return ret;
}
static uint32_t PrintIsdi(const char c)
{
uint32_t ret = 0U;
if ((c == 'd') || (c == 'i'))
{
ret = 1U;
}
return ret;
}
static void PrintOutputdifFobpu(uint32_t flags_used,
uint32_t field_width,
uint32_t vlen,
char schar,
char *vstrp,
printfCb cb,
char *buf,
int32_t *count)
{
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
/* Do the ZERO pad. */
if (0U != (flags_used & (uint32_t)kPRINTF_Zero))
{
if ('\0' != schar)
{
cb(buf, count, schar, 1);
schar = '\0';
}
cb(buf, count, '0', (int)field_width - (int)vlen);
vlen = field_width;
}
else
{
if (0U == (flags_used & (uint32_t)kPRINTF_Minus))
{
cb(buf, count, ' ', (int)field_width - (int)vlen);
if ('\0' != schar)
{
cb(buf, count, schar, 1);
schar = '\0';
}
}
}
/* The string was built in reverse order, now display in correct order. */
if ('\0' != schar)
{
cb(buf, count, schar, 1);
}
#else
cb(buf, count, ' ', (int)field_width - (int)vlen);
#endif /* PRINTF_ADVANCED_ENABLE */
while ('\0' != (*vstrp))
{
cb(buf, count, *vstrp--, 1);
}
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
if (0U != (flags_used & (uint32_t)kPRINTF_Minus))
{
cb(buf, count, ' ', (int)field_width - (int)vlen);
}
#endif /* PRINTF_ADVANCED_ENABLE */
}
static void PrintOutputxX(uint32_t flags_used,
uint32_t field_width,
uint32_t vlen,
bool use_caps,
char *vstrp,
printfCb cb,
char *buf,
int32_t *count)
{
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
uint8_t dschar = 0;
if (0U != (flags_used & (uint32_t)kPRINTF_Zero))
{
if (0U != (flags_used & (uint32_t)kPRINTF_Pound))
{
cb(buf, count, '0', 1);
cb(buf, count, (use_caps ? 'X' : 'x'), 1);
dschar = 1U;
}
cb(buf, count, '0', (int)field_width - (int)vlen);
vlen = field_width;
}
else
{
if (0U == (flags_used & (uint32_t)kPRINTF_Minus))
{
if (0U != (flags_used & (uint32_t)kPRINTF_Pound))
{
vlen += 2U;
}
cb(buf, count, ' ', (int)field_width - (int)vlen);
if (0U != (flags_used & (uint32_t)kPRINTF_Pound))
{
cb(buf, count, '0', 1);
cb(buf, count, (use_caps ? 'X' : 'x'), 1);
dschar = 1U;
}
}
}
if ((0U != (flags_used & (uint32_t)kPRINTF_Pound)) && (0U == dschar))
{
cb(buf, count, '0', 1);
cb(buf, count, (use_caps ? 'X' : 'x'), 1);
vlen += 2U;
}
#else
cb(buf, count, ' ', (int)field_width - (int)vlen);
#endif /* PRINTF_ADVANCED_ENABLE */
while ('\0' != (*vstrp))
{
cb(buf, count, *vstrp--, 1);
}
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
if (0U != (flags_used & (uint32_t)kPRINTF_Minus))
{
cb(buf, count, ' ', (int)field_width - (int)vlen);
}
#endif /* PRINTF_ADVANCED_ENABLE */
}
static uint32_t PrintIsfF(const char c)
{
uint32_t ret = 0U;
if ((c == 'f') || (c == 'F'))
{
ret = 1U;
}
return ret;
}
static uint32_t PrintIsxX(const char c)
{
uint32_t ret = 0U;
if ((c == 'x') || (c == 'X'))
{
ret = 1U;
}
return ret;
}
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
static uint32_t PrintCheckFlags(const char **s)
{
const char *p = *s;
/* First check for specification modifier flags. */
uint32_t flags_used = 0U;
bool done = false;
while (false == done)
{
switch (*++p)
{
case '-':
flags_used |= (uint32_t)kPRINTF_Minus;
break;
case '+':
flags_used |= (uint32_t)kPRINTF_Plus;
break;
case ' ':
flags_used |= (uint32_t)kPRINTF_Space;
break;
case '0':
flags_used |= (uint32_t)kPRINTF_Zero;
break;
case '#':
flags_used |= (uint32_t)kPRINTF_Pound;
break;
default:
/* We've gone one char too far. */
--p;
done = true;
break;
}
}
*s = p;
return flags_used;
}
#endif /* PRINTF_ADVANCED_ENABLE */
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
/*
* Check for the length modifier.
*/
static uint32_t PrintGetLengthFlag(const char **s)
{
const char *p = *s;
/* First check for specification modifier flags. */
uint32_t flags_used = 0U;
switch (/* c = */ *++p)
{
case 'h':
if (*++p != 'h')
{
flags_used |= (uint32_t)kPRINTF_LengthShortInt;
--p;
}
else
{
flags_used |= (uint32_t)kPRINTF_LengthChar;
}
break;
case 'l':
if (*++p != 'l')
{
flags_used |= (uint32_t)kPRINTF_LengthLongInt;
--p;
}
else
{
flags_used |= (uint32_t)kPRINTF_LengthLongLongInt;
}
break;
case 'z':
if (sizeof(size_t) == sizeof(uint32_t))
{
flags_used |= (uint32_t)kPRINTF_LengthLongInt;
}
else if (sizeof(size_t) == (2U * sizeof(uint32_t)))
{
flags_used |= (uint32_t)kPRINTF_LengthLongLongInt;
}
else if (sizeof(size_t) == sizeof(uint16_t))
{
flags_used |= (uint32_t)kPRINTF_LengthShortInt;
}
else
{
/* MISRA C-2012 Rule 15.7 */
}
break;
default:
/* we've gone one char too far */
--p;
break;
}
*s = p;
return flags_used;
}
#else
static void PrintFilterLengthFlag(const char **s)
{
const char *p = *s;
char ch;
do
{
ch = *++p;
} while ((ch == 'h') || (ch == 'l'));
*s = --p;
}
#endif /* PRINTF_ADVANCED_ENABLE */
static uint8_t PrintGetRadixFromobpu(const char c)
{
uint8_t radix;
if (c == 'o')
{
radix = 8U;
}
else if (c == 'b')
{
radix = 2U;
}
else if (c == 'p')
{
radix = 16U;
}
else
{
radix = 10U;
}
return radix;
}
static uint32_t ScanIsWhiteSpace(const char c)
{
uint32_t ret = 0U;
if ((c == ' ') || (c == '\t') || (c == '\n') || (c == '\r') || (c == '\v') || (c == '\f'))
{
ret = 1U;
}
return ret;
}
static uint32_t ScanIgnoreWhiteSpace(const char **s)
{
uint32_t count = 0U;
char c;
c = **s;
while (1U == ScanIsWhiteSpace(c))
{
count++;
(*s)++;
c = **s;
}
return count;
}
static int32_t ConvertRadixNumToString(char *numstr, void *nump, unsigned int neg, unsigned int radix, bool use_caps)
{
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
long long int a;
long long int b;
long long int c;
unsigned long long int ua;
unsigned long long int ub;
unsigned long long int uc;
unsigned long long int uc_param;
#else
int a;
int b;
int c;
unsigned int ua;
unsigned int ub;
unsigned int uc;
unsigned int uc_param;
#endif /* PRINTF_ADVANCED_ENABLE */
int32_t nlen;
char *nstrp;
nlen = 0;
nstrp = numstr;
*nstrp++ = '\0';
#if !(defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0u))
neg = 0U;
#endif
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
a = 0;
b = 0;
c = 0;
ua = 0ULL;
ub = 0ULL;
uc = 0ULL;
uc_param = 0ULL;
#else
a = 0;
b = 0;
c = 0;
ua = 0U;
ub = 0U;
uc = 0U;
uc_param = 0U;
#endif /* PRINTF_ADVANCED_ENABLE */
(void)a;
(void)b;
(void)c;
(void)ua;
(void)ub;
(void)uc;
(void)uc_param;
(void)neg;
/*
* Fix MISRA issue: CID 15972928 (#15 of 15): MISRA C-2012 Control Flow Expressions (MISRA C-2012 Rule 14.3)
* misra_c_2012_rule_14_3_violation: Execution cannot reach this statement: a = *((int *)nump);
*/
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
if (0U != neg)
{
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
a = *(long long int *)nump;
#else
a = *(int *)nump;
#endif /* PRINTF_ADVANCED_ENABLE */
if (a == 0)
{
*nstrp = '0';
++nlen;
return nlen;
}
while (a != 0)
{
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
b = (long long int)a / (long long int)radix;
c = (long long int)a - ((long long int)b * (long long int)radix);
if (c < 0)
{
uc = (unsigned long long int)c;
uc_param = ~uc;
c = (long long int)uc_param + 1 + (long long int)'0';
}
#else
b = (int)a / (int)radix;
c = (int)a - ((int)b * (int)radix);
if (c < 0)
{
uc = (unsigned int)c;
uc_param = ~uc;
c = (int)uc_param + 1 + (int)'0';
}
#endif /* PRINTF_ADVANCED_ENABLE */
else
{
c = c + (int)'0';
}
a = b;
*nstrp++ = (char)c;
++nlen;
}
}
else
#endif /* PRINTF_ADVANCED_ENABLE */
{
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
ua = *(unsigned long long int *)nump;
#else
ua = *(unsigned int *)nump;
#endif /* PRINTF_ADVANCED_ENABLE */
if (ua == 0U)
{
*nstrp = '0';
++nlen;
return nlen;
}
while (ua != 0U)
{
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
ub = (unsigned long long int)ua / (unsigned long long int)radix;
uc = (unsigned long long int)ua - ((unsigned long long int)ub * (unsigned long long int)radix);
#else
ub = ua / (unsigned int)radix;
uc = ua - (ub * (unsigned int)radix);
#endif /* PRINTF_ADVANCED_ENABLE */
if (uc < 10U)
{
uc = uc + (unsigned int)'0';
}
else
{
uc = uc - 10U + (unsigned int)(use_caps ? 'A' : 'a');
}
ua = ub;
*nstrp++ = (char)uc;
++nlen;
}
}
return nlen;
}
#if (defined(PRINTF_FLOAT_ENABLE) && (PRINTF_FLOAT_ENABLE > 0U))
static int32_t ConvertFloatRadixNumToString(char *numstr, void *nump, int32_t radix, uint32_t precision_width)
{
int32_t a;
int32_t b;
int32_t c;
int32_t i;
uint32_t uc;
double fa;
double dc;
double fb;
double r;
double fractpart;
double intpart;
int32_t nlen;
char *nstrp;
nlen = 0;
nstrp = numstr;
*nstrp++ = '\0';
r = *(double *)nump;
if (0.0 == r)
{
*nstrp = '0';
++nlen;
return nlen;
}
fractpart = modf((double)r, (double *)&intpart);
/* Process fractional part. */
for (i = 0; i < (int32_t)precision_width; i++)
{
fractpart *= (double)radix;
}
if (r >= (double)0.0)
{
fa = fractpart + (double)0.5;
if (fa >= pow((double)10, (double)precision_width))
{
intpart++;
}
}
else
{
fa = fractpart - (double)0.5;
if (fa <= -pow((double)10, (double)precision_width))
{
intpart--;
}
}
for (i = 0; i < (int32_t)precision_width; i++)
{
fb = fa / (double)radix;
dc = (fa - (double)(long long int)fb * (double)radix);
c = (int32_t)dc;
if (c < 0)
{
uc = (uint32_t)c;
uc = ~uc;
c = (int32_t)uc;
c += (int32_t)1;
c += (int32_t)'0';
}
else
{
c = c + '0';
}
fa = fb;
*nstrp++ = (char)c;
++nlen;
}
*nstrp++ = (char)'.';
++nlen;
a = (int32_t)intpart;
if (a == 0)
{
*nstrp++ = '0';
++nlen;
}
else
{
while (a != 0)
{
b = (int32_t)a / (int32_t)radix;
c = (int32_t)a - ((int32_t)b * (int32_t)radix);
if (c < 0)
{
uc = (uint32_t)c;
uc = ~uc;
c = (int32_t)uc;
c += (int32_t)1;
c += (int32_t)'0';
}
else
{
c = c + '0';
}
a = b;
*nstrp++ = (char)c;
++nlen;
}
}
return nlen;
}
#endif /* PRINTF_FLOAT_ENABLE */
/*!
* brief This function outputs its parameters according to a formatted string.
*
* note I/O is performed by calling given function pointer using following
* (*func_ptr)(c);
*
* param[in] fmt Format string for printf.
* param[in] ap Arguments to printf.
* param[in] buf pointer to the buffer
* param cb print callback function pointer
*
* return Number of characters to be print
*/
int StrFormatPrintf(const char *fmt, va_list ap, char *buf, printfCb cb)
{
/* va_list ap; */
const char *p;
char c;
char vstr[33];
char *vstrp = NULL;
int32_t vlen = 0;
int32_t count = 0;
uint32_t field_width;
uint32_t precision_width;
char *sval;
int32_t cval;
bool use_caps;
unsigned int radix = 0;
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
uint32_t flags_used;
char schar;
long long int ival;
unsigned long long int uval = 0;
#define STR_FORMAT_PRINTF_UVAL_TYPE unsigned long long int
#define STR_FORMAT_PRINTF_IVAL_TYPE long long int
bool valid_precision_width;
#else
int ival;
unsigned int uval = 0;
#define STR_FORMAT_PRINTF_UVAL_TYPE unsigned int
#define STR_FORMAT_PRINTF_IVAL_TYPE int
#endif /* PRINTF_ADVANCED_ENABLE */
#if (defined(PRINTF_FLOAT_ENABLE) && (PRINTF_FLOAT_ENABLE > 0U))
double fval;
#endif /* PRINTF_FLOAT_ENABLE */
/* Start parsing apart the format string and display appropriate formats and data. */
p = fmt;
while (true)
{
if ('\0' == *p)
{
break;
}
c = *p;
/*
* All formats begin with a '%' marker. Special chars like
* '\n' or '\t' are normally converted to the appropriate
* character by the __compiler__. Thus, no need for this
* routine to account for the '\' character.
*/
if (c != '%')
{
cb(buf, &count, c, 1);
p++;
/* By using 'continue', the next iteration of the loop is used, skipping the code that follows. */
continue;
}
use_caps = true;
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
/* First check for specification modifier flags. */
flags_used = PrintCheckFlags(&p);
#endif /* PRINTF_ADVANCED_ENABLE */
/* Next check for minimum field width. */
field_width = PrintGetWidth(&p, &ap);
/* Next check for the width and precision field separator. */
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
precision_width = PrintGetPrecision(&p, &ap, &valid_precision_width);
#else
precision_width = PrintGetPrecision(&p, &ap, NULL);
(void)precision_width;
#endif
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
/* Check for the length modifier. */
flags_used |= PrintGetLengthFlag(&p);
#else
/* Filter length modifier. */
PrintFilterLengthFlag(&p);
#endif
/* Now we're ready to examine the format. */
c = *++p;
{
if (1U == PrintIsdi(c))
{
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
if (0U != (flags_used & (uint32_t)kPRINTF_LengthLongLongInt))
{
ival = (long long int)va_arg(ap, long long int);
}
else if (0U != (flags_used & (uint32_t)kPRINTF_LengthLongInt))
{
ival = (long long int)va_arg(ap, long int);
}
else
#endif /* PRINTF_ADVANCED_ENABLE */
{
ival = (STR_FORMAT_PRINTF_IVAL_TYPE)va_arg(ap, int);
}
vlen = ConvertRadixNumToString((char *)vstr, (void *)&ival, 1, 10, use_caps);
vstrp = &vstr[vlen];
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
vlen += (int)PrintGetSignChar(ival, flags_used, &schar);
PrintOutputdifFobpu(flags_used, field_width, (unsigned int)vlen, schar, vstrp, cb, buf, &count);
#else
PrintOutputdifFobpu(0U, field_width, (unsigned int)vlen, '\0', vstrp, cb, buf, &count);
#endif
}
else if (1U == PrintIsfF(c))
{
#if (defined(PRINTF_FLOAT_ENABLE) && (PRINTF_FLOAT_ENABLE > 0U))
fval = (double)va_arg(ap, double);
vlen = ConvertFloatRadixNumToString(vstr, &fval, 10, precision_width);
vstrp = &vstr[vlen];
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
vlen += (int32_t)PrintGetSignChar(((fval < 0.0) ? ((long long int)-1) : ((long long int)fval)),
flags_used, &schar);
PrintOutputdifFobpu(flags_used, field_width, (unsigned int)vlen, schar, vstrp, cb, buf, &count);
#else
PrintOutputdifFobpu(0, field_width, (unsigned int)vlen, '\0', vstrp, cb, buf, &count);
#endif
#else
(void)va_arg(ap, double);
#endif /* PRINTF_FLOAT_ENABLE */
}
else if (1U == PrintIsxX(c))
{
if (c == 'x')
{
use_caps = false;
}
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
if (0U != (flags_used & (unsigned int)kPRINTF_LengthLongLongInt))
{
uval = (unsigned long long int)va_arg(ap, unsigned long long int);
}
else if (0U != (flags_used & (unsigned int)kPRINTF_LengthLongInt))
{
uval = (unsigned long long int)va_arg(ap, unsigned long int);
}
else
#endif /* PRINTF_ADVANCED_ENABLE */
{
uval = (STR_FORMAT_PRINTF_UVAL_TYPE)va_arg(ap, unsigned int);
}
vlen = ConvertRadixNumToString((char *)vstr, (void *)&uval, 0, 16, use_caps);
vstrp = &vstr[vlen];
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
PrintOutputxX(flags_used, field_width, (unsigned int)vlen, use_caps, vstrp, cb, buf, &count);
#else
PrintOutputxX(0U, field_width, (uint32_t)vlen, use_caps, vstrp, cb, buf, &count);
#endif
}
else if (1U == PrintIsobpu(c))
{
if ('p' == c)
{
/*
* Fix MISRA issue: CID 17205581 (#15 of 15): MISRA C-2012 Pointer Type Conversions (MISRA C-2012
* Rule 11.6) 1.misra_c_2012_rule_11_6_violation: The expression va_arg (ap, void *) of type void *
* is cast to type uint32_t.
*
* Orignal code: uval = (STR_FORMAT_PRINTF_UVAL_TYPE)(uint32_t)va_arg(ap, void *);
*/
void *pval;
pval = (void *)va_arg(ap, void *);
(void)memcpy((void *)&uval, (void *)&pval, sizeof(void *));
}
else
{
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
if (0U != (flags_used & (unsigned int)kPRINTF_LengthLongLongInt))
{
uval = (unsigned long long int)va_arg(ap, unsigned long long int);
}
else if (0U != (flags_used & (unsigned int)kPRINTF_LengthLongInt))
{
uval = (unsigned long long int)va_arg(ap, unsigned long int);
}
else
{
#endif /* PRINTF_ADVANCED_ENABLE */
uval = (STR_FORMAT_PRINTF_UVAL_TYPE)va_arg(ap, unsigned int);
}
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
}
#endif /* PRINTF_ADVANCED_ENABLE */
radix = PrintGetRadixFromobpu(c);
vlen = ConvertRadixNumToString((char *)vstr, (void *)&uval, 0, radix, use_caps);
vstrp = &vstr[vlen];
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
PrintOutputdifFobpu(flags_used, field_width, (unsigned int)vlen, '\0', vstrp, cb, buf, &count);
#else
PrintOutputdifFobpu(0U, field_width, (uint32_t)vlen, '\0', vstrp, cb, buf, &count);
#endif
}
else if (c == 'c')
{
cval = (int32_t)va_arg(ap, int);
cb(buf, &count, cval, 1);
}
else if (c == 's')
{
sval = (char *)va_arg(ap, char *);
if (NULL != sval)
{
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
if (valid_precision_width)
{
vlen = (int)precision_width;
}
else
{
vlen = (int)strlen(sval);
}
#else
vlen = (int32_t)strlen(sval);
#endif /* PRINTF_ADVANCED_ENABLE */
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
if (0U == (flags_used & (unsigned int)kPRINTF_Minus))
#endif /* PRINTF_ADVANCED_ENABLE */
{
cb(buf, &count, ' ', (int)field_width - (int)vlen);
}
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
if (valid_precision_width)
{
while (('\0' != *sval) && (vlen > 0))
{
cb(buf, &count, *sval++, 1);
vlen--;
}
/* In case that vlen sval is shorter than vlen */
vlen = (int)precision_width - vlen;
}
else
{
#endif /* PRINTF_ADVANCED_ENABLE */
while ('\0' != (*sval))
{
cb(buf, &count, *sval++, 1);
}
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
}
#endif /* PRINTF_ADVANCED_ENABLE */
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
if (0U != (flags_used & (unsigned int)kPRINTF_Minus))
{
cb(buf, &count, ' ', (int)field_width - vlen);
}
#endif /* PRINTF_ADVANCED_ENABLE */
}
}
else
{
cb(buf, &count, c, 1);
}
}
p++;
}
return (int)count;
}
#if (defined(SCANF_FLOAT_ENABLE) && (SCANF_FLOAT_ENABLE > 0U))
static uint8_t StrFormatScanIsFloat(char *c)
{
uint8_t ret = 0U;
if (('a' == (*c)) || ('A' == (*c)) || ('e' == (*c)) || ('E' == (*c)) || ('f' == (*c)) || ('F' == (*c)) ||
('g' == (*c)) || ('G' == (*c)))
{
ret = 1U;
}
return ret;
}
#endif
static uint8_t StrFormatScanIsFormatStarting(char *c)
{
uint8_t ret = 1U;
if ((*c != '%'))
{
ret = 0U;
}
else if (*(c + 1) == '%')
{
ret = 0U;
}
else
{
/*MISRA rule 15.7*/
}
return ret;
}
static uint8_t StrFormatScanGetBase(uint8_t base, const char *s)
{
if (base == 0U)
{
if (s[0] == '0')
{
if ((s[1] == 'x') || (s[1] == 'X'))
{
base = 16;
}
else
{
base = 8;
}
}
else
{
base = 10;
}
}
return base;
}
static uint8_t StrFormatScanCheckSymbol(const char *p, int8_t *neg)
{
uint8_t len;
switch (*p)
{
case '-':
*neg = -1;
len = 1;
break;
case '+':
*neg = 1;
len = 1;
break;
default:
*neg = 1;
len = 0;
break;
}
return len;
}
static uint8_t StrFormatScanFillInteger(uint32_t flag, va_list *args_ptr, int32_t val)
{
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
if (0U != (flag & (uint32_t)kSCANF_Suppress))
{
return 0u;
}
switch (flag & (uint32_t)kSCANF_LengthMask)
{
case (uint32_t)kSCANF_LengthChar:
if (0U != (flag & (uint32_t)kSCANF_TypeSinged))
{
*va_arg(*args_ptr, signed char *) = (signed char)val;
}
else
{
*va_arg(*args_ptr, unsigned char *) = (unsigned char)val;
}
break;
case (uint32_t)kSCANF_LengthShortInt:
if (0U != (flag & (uint32_t)kSCANF_TypeSinged))
{
*va_arg(*args_ptr, signed short *) = (signed short)val;
}
else
{
*va_arg(*args_ptr, unsigned short *) = (unsigned short)val;
}
break;
case (uint32_t)kSCANF_LengthLongInt:
if (0U != (flag & (uint32_t)kSCANF_TypeSinged))
{
*va_arg(*args_ptr, signed long int *) = (signed long int)val;
}
else
{
*va_arg(*args_ptr, unsigned long int *) = (unsigned long int)val;
}
break;
case (uint32_t)kSCANF_LengthLongLongInt:
if (0U != (flag & (uint32_t)kSCANF_TypeSinged))
{
*va_arg(*args_ptr, signed long long int *) = (signed long long int)val;
}
else
{
*va_arg(*args_ptr, unsigned long long int *) = (unsigned long long int)val;
}
break;
default:
/* The default type is the type int. */
if (0U != (flag & (uint32_t)kSCANF_TypeSinged))
{
*va_arg(*args_ptr, signed int *) = (signed int)val;
}
else
{
*va_arg(*args_ptr, unsigned int *) = (unsigned int)val;
}
break;
}
#else
/* The default type is the type int. */
if (0U != (flag & (uint32_t)kSCANF_TypeSinged))
{
*va_arg(*args_ptr, signed int *) = (signed int)val;
}
else
{
*va_arg(*args_ptr, unsigned int *) = (unsigned int)val;
}
#endif /* SCANF_ADVANCED_ENABLE */
return 1u;
}
#if (defined(SCANF_FLOAT_ENABLE) && (SCANF_FLOAT_ENABLE > 0U))
static uint8_t StrFormatScanFillFloat(uint32_t flag, va_list *args_ptr, double fnum)
{
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
if (0U != (flag & (uint32_t)kSCANF_Suppress))
{
return 0u;
}
else
#endif /* SCANF_ADVANCED_ENABLE */
{
if (0U != (flag & (uint32_t)kSCANF_LengthLongLongDouble))
{
*va_arg(*args_ptr, double *) = fnum;
}
else
{
*va_arg(*args_ptr, float *) = (float)fnum;
}
return 1u;
}
}
#endif /* SCANF_FLOAT_ENABLE */
static uint8_t StrFormatScanfStringHandling(char **str, uint32_t *flag, uint32_t *field_width, uint8_t *base)
{
uint8_t exitPending = 0U;
char *c = *str;
/* Loop to get full conversion specification. */
while (('\0' != (*c)) && (0U == (*flag & (uint32_t)kSCANF_DestMask)))
{
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
if ('*' == (*c))
{
if (0U != ((*flag) & (uint32_t)kSCANF_Suppress))
{
/* Match failure. */
exitPending = 1U;
}
else
{
(*flag) |= (uint32_t)kSCANF_Suppress;
}
}
else if ('h' == (*c))
{
if (0U != ((*flag) & (uint32_t)kSCANF_LengthMask))
{
/* Match failure. */
exitPending = 1U;
}
else
{
if (c[1] == 'h')
{
(*flag) |= (uint32_t)kSCANF_LengthChar;
c++;
}
else
{
(*flag) |= (uint32_t)kSCANF_LengthShortInt;
}
}
}
else if ('l' == (*c))
{
if (0U != ((*flag) & (uint32_t)kSCANF_LengthMask))
{
/* Match failure. */
exitPending = 1U;
}
else
{
if (c[1] == 'l')
{
(*flag) |= (uint32_t)kSCANF_LengthLongLongInt;
c++;
}
else
{
(*flag) |= (uint32_t)kSCANF_LengthLongInt;
}
}
}
else
#endif /* SCANF_ADVANCED_ENABLE */
#if (defined(SCANF_FLOAT_ENABLE) && (SCANF_FLOAT_ENABLE > 0U))
if ('L' == (*c))
{
if (0U != ((*flag) & (uint32_t)kSCANF_LengthMask))
{
/* Match failure. */
exitPending = 1U;
}
else
{
(*flag) |= (uint32_t)kSCANF_LengthLongLongDouble;
}
}
else
#endif /* SCANF_FLOAT_ENABLE */
if (((*c) >= '0') && ((*c) <= '9'))
{
{
char *p;
errno = 0;
(*field_width) = strtoul(c, &p, 10);
if (0 != errno)
{
*field_width = 0U;
}
c = p - 1;
}
}
else if ('d' == (*c))
{
(*base) = 10U;
(*flag) |= (uint32_t)kSCANF_TypeSinged;
(*flag) |= (uint32_t)kSCANF_DestInt;
}
else if ('u' == (*c))
{
(*base) = 10U;
(*flag) |= (uint32_t)kSCANF_DestInt;
}
else if ('o' == (*c))
{
(*base) = 8U;
(*flag) |= (uint32_t)kSCANF_DestInt;
}
else if (('x' == (*c)))
{
(*base) = 16U;
(*flag) |= (uint32_t)kSCANF_DestInt;
}
else if ('X' == (*c))
{
(*base) = 16U;
(*flag) |= (uint32_t)kSCANF_DestInt;
}
else if ('i' == (*c))
{
(*base) = 0U;
(*flag) |= (uint32_t)kSCANF_DestInt;
}
#if (defined(SCANF_FLOAT_ENABLE) && (SCANF_FLOAT_ENABLE > 0U))
else if (1U == StrFormatScanIsFloat(c))
{
(*flag) |= (uint32_t)kSCANF_DestFloat;
}
#endif /* SCANF_FLOAT_ENABLE */
else if ('c' == (*c))
{
(*flag) |= (uint32_t)kSCANF_DestChar;
if (MAX_FIELD_WIDTH == (*field_width))
{
(*field_width) = 1;
}
}
else if ('s' == (*c))
{
(*flag) |= (uint32_t)kSCANF_DestString;
}
else
{
exitPending = 1U;
}
if (1U == exitPending)
{
break;
}
else
{
c++;
}
}
*str = c;
return exitPending;
}
/*!
* brief Converts an input line of ASCII characters based upon a provided
* string format.
*
* param[in] line_ptr The input line of ASCII data.
* param[in] format Format first points to the format string.
* param[in] args_ptr The list of parameters.
*
* return Number of input items converted and assigned.
* retval IO_EOF When line_ptr is empty string "".
*/
int StrFormatScanf(const char *line_ptr, char *format, va_list args_ptr)
{
uint8_t base;
int8_t neg;
/* Identifier for the format string. */
char *c = format;
char *buf;
/* Flag telling the conversion specification. */
uint32_t flag = 0;
/* Filed width for the matching input streams. */
uint32_t field_width;
/* How many arguments are assigned except the suppress. */
uint32_t nassigned = 0;
/* How many characters are read from the input streams. */
uint32_t n_decode = 0;
int32_t val;
uint8_t added;
uint8_t exitPending = 0;
const char *s;
#if (defined(SCANF_FLOAT_ENABLE) && (SCANF_FLOAT_ENABLE > 0U))
char *s_temp; /* MISRA C-2012 Rule 11.3 */
#endif
/* Identifier for the input string. */
const char *p = line_ptr;
#if (defined(SCANF_FLOAT_ENABLE) && (SCANF_FLOAT_ENABLE > 0U))
double fnum = 0.0;
#endif /* SCANF_FLOAT_ENABLE */
/* Return EOF error before any conversion. */
if (*p == '\0')
{
return -1;
}
/* Decode directives. */
while (('\0' != (*c)) && ('\0' != (*p)))
{
/* Ignore all white-spaces in the format strings. */
if (0U != ScanIgnoreWhiteSpace((const char **)((void *)&c)))
{
n_decode += ScanIgnoreWhiteSpace(&p);
}
else if (0U == StrFormatScanIsFormatStarting(c))
{
/* Ordinary characters. */
c++;
if (*p == *c)
{
n_decode++;
p++;
c++;
}
else
{
/* Match failure. Misalignment with C99, the unmatched characters need to be pushed back to stream.
* However, it is deserted now. */
break;
}
}
else
{
/* convernsion specification */
c++;
/* Reset. */
flag = 0;
field_width = MAX_FIELD_WIDTH;
base = 0;
added = 0U;
exitPending = StrFormatScanfStringHandling(&c, &flag, &field_width, &base);
if (1U == exitPending)
{
/* Format strings are exhausted. */
break;
}
/* Matching strings in input streams and assign to argument. */
if ((flag & (uint32_t)kSCANF_DestMask) == (uint32_t)kSCANF_DestChar)
{
s = (const char *)p;
buf = va_arg(args_ptr, char *);
while ((0U != (field_width--))
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
&& ('\0' != (*p))
#endif
)
{
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
if (0U != (flag & (uint32_t)kSCANF_Suppress))
{
p++;
}
else
#endif
{
*buf++ = *p++;
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
added = 1u;
#endif
}
n_decode++;
}
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
if (1u == added)
#endif
{
nassigned++;
}
}
else if ((flag & (uint32_t)kSCANF_DestMask) == (uint32_t)kSCANF_DestString)
{
n_decode += ScanIgnoreWhiteSpace(&p);
s = p;
buf = va_arg(args_ptr, char *);
while ((0U != (field_width--)) && (*p != '\0') && (0U == ScanIsWhiteSpace(*p)))
{
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
if (0U != (flag & (uint32_t)kSCANF_Suppress))
{
p++;
}
else
#endif
{
*buf++ = *p++;
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
added = 1u;
#endif
}
n_decode++;
}
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
if (1u == added)
#endif
{
/* Add NULL to end of string. */
*buf = '\0';
nassigned++;
}
}
else if ((flag & (uint32_t)kSCANF_DestMask) == (uint32_t)kSCANF_DestInt)
{
n_decode += ScanIgnoreWhiteSpace(&p);
s = p;
val = 0;
base = StrFormatScanGetBase(base, s);
added = StrFormatScanCheckSymbol(p, &neg);
n_decode += added;
p += added;
field_width -= added;
s = p;
if (strlen(p) > field_width)
{
char temp[12];
char *tempEnd;
(void)memcpy(temp, p, sizeof(temp) - 1U);
temp[sizeof(temp) - 1U] = '\0';
errno = 0;
val = (int32_t)strtoul(temp, &tempEnd, (int)base);
if (0 != errno)
{
break;
}
p = p + (tempEnd - temp);
}
else
{
char *tempEnd;
val = 0;
errno = 0;
val = (int32_t)strtoul(p, &tempEnd, (int)base);
if (0 != errno)
{
break;
}
p = tempEnd;
}
n_decode += (uintptr_t)p - (uintptr_t)s;
val *= neg;
nassigned += StrFormatScanFillInteger(flag, &args_ptr, val);
}
#if (defined(SCANF_FLOAT_ENABLE) && (SCANF_FLOAT_ENABLE > 0U))
else if ((flag & (uint32_t)kSCANF_DestMask) == (uint32_t)kSCANF_DestFloat)
{
n_decode += ScanIgnoreWhiteSpace(&p);
fnum = 0.0;
errno = 0;
fnum = strtod(p, (char **)&s_temp);
s = s_temp; /* MISRA C-2012 Rule 11.3 */
/* MISRA C-2012 Rule 22.9 */
if (0 != errno)
{
break;
}
if ((fnum < HUGE_VAL) && (fnum > -HUGE_VAL))
{
n_decode = (uint32_t)n_decode + (uint32_t)s - (uint32_t)p;
p = s;
nassigned += StrFormatScanFillFloat(flag, &args_ptr, fnum);
}
}
#endif /* SCANF_FLOAT_ENABLE */
else
{
break;
}
}
}
return (int)nassigned;
}
Reference in New Issue Copy Permalink