1708 lines
47 KiB
C
1708 lines
47 KiB
C
/*
|
|
* Copyright 2017, 2020, 2022-2023 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 */
|
|
|
|
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
|
|
#define STR_FORMAT_PRINTF_UVAL_TYPE unsigned long long int
|
|
#define STR_FORMAT_PRINTF_IVAL_TYPE long long int
|
|
#else
|
|
#define STR_FORMAT_PRINTF_UVAL_TYPE unsigned int
|
|
#define STR_FORMAT_PRINTF_IVAL_TYPE int
|
|
#endif
|
|
/*******************************************************************************
|
|
* 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 strCh;
|
|
|
|
do
|
|
{
|
|
strCh = *++p;
|
|
} while ((strCh == 'h') || (strCh == '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 */
|
|
|
|
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
|
|
static void StrFormatExaminedi(uint32_t *flags_used, long long int *ival, va_list *ap)
|
|
#else
|
|
static void StrFormatExaminedi(int *ival, va_list *ap)
|
|
#endif
|
|
{
|
|
#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);
|
|
}
|
|
}
|
|
|
|
#if (defined(PRINTF_ADVANCED_ENABLE) && (PRINTF_ADVANCED_ENABLE > 0U))
|
|
static void StrFormatExaminexX(uint32_t *flags_used, unsigned long long int *uval, va_list *ap)
|
|
#else
|
|
static void StrFormatExaminexX(unsigned int *uval, va_list *ap)
|
|
#endif
|
|
{
|
|
#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))
|
|
static void StrFormatExamineobpu(uint32_t *flags_used, unsigned long long int *uval, va_list *ap)
|
|
#else
|
|
static void StrFormatExamineobpu(unsigned int *uval, va_list *ap)
|
|
#endif
|
|
{
|
|
#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))
|
|
static int32_t ConvertPrecisionWidthToLength(bool valid_precision_width, uint32_t precision_width, char *sval)
|
|
#else
|
|
static int32_t ConvertPrecisionWidthToLength(char *sval)
|
|
#endif
|
|
{
|
|
int32_t vlen = 0;
|
|
#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 */
|
|
|
|
return vlen;
|
|
}
|
|
|
|
/*!
|
|
* 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;
|
|
bool valid_precision_width;
|
|
#else
|
|
int ival;
|
|
unsigned int uval = 0;
|
|
#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))
|
|
StrFormatExaminedi(&flags_used, &ival, &ap);
|
|
#else
|
|
StrFormatExaminedi(&ival, &ap);
|
|
#endif
|
|
|
|
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))
|
|
StrFormatExaminexX(&flags_used, &uval, &ap);
|
|
#else
|
|
StrFormatExaminexX(&uval, &ap);
|
|
#endif
|
|
|
|
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))
|
|
StrFormatExamineobpu(&flags_used, &uval, &ap);
|
|
#else
|
|
StrFormatExamineobpu(&uval, &ap);
|
|
#endif
|
|
}
|
|
|
|
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))
|
|
vlen = ConvertPrecisionWidthToLength(valid_precision_width, precision_width, sval);
|
|
#else
|
|
vlen = ConvertPrecisionWidthToLength(sval);
|
|
#endif
|
|
#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 */
|
|
|
|
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
|
|
static uint8_t strFormatScanfHandleh(uint8_t exitPending, char **c, uint32_t *flag)
|
|
{
|
|
if (0U != ((*flag) & (uint32_t)kSCANF_LengthMask))
|
|
{
|
|
/* Match failure. */
|
|
exitPending = 1U;
|
|
}
|
|
else
|
|
{
|
|
if ((*c)[1] == 'h')
|
|
{
|
|
(*flag) |= (uint32_t)kSCANF_LengthChar;
|
|
*c = *c + 1U;
|
|
}
|
|
else
|
|
{
|
|
(*flag) |= (uint32_t)kSCANF_LengthShortInt;
|
|
}
|
|
}
|
|
|
|
return exitPending;
|
|
}
|
|
|
|
static uint8_t strFormatScanfHandlel(uint8_t exitPending, char **c, uint32_t *flag)
|
|
{
|
|
if (0U != ((*flag) & (uint32_t)kSCANF_LengthMask))
|
|
{
|
|
/* Match failure. */
|
|
exitPending = 1U;
|
|
}
|
|
else
|
|
{
|
|
if ((*c)[1] == 'l')
|
|
{
|
|
(*flag) |= (uint32_t)kSCANF_LengthLongLongInt;
|
|
*c = *c + 1U;
|
|
}
|
|
else
|
|
{
|
|
(*flag) |= (uint32_t)kSCANF_LengthLongInt;
|
|
}
|
|
}
|
|
|
|
return exitPending;
|
|
}
|
|
#endif
|
|
|
|
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))
|
|
{
|
|
exitPending = strFormatScanfHandleh(exitPending, &c, flag);
|
|
}
|
|
else if ('l' == (*c))
|
|
{
|
|
exitPending = strFormatScanfHandlel(exitPending, &c, flag);
|
|
}
|
|
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;
|
|
}
|
|
|
|
static void StrFormatScanfHandleChar(
|
|
const char **Cp, uint32_t *field_width, char **buf, uint32_t flag, uint32_t *n_decode, uint32_t *nassigned)
|
|
{
|
|
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
|
|
uint8_t added = 0;
|
|
#endif
|
|
while ((0U != ((*field_width)--))
|
|
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
|
|
&& ('\0' != (**Cp))
|
|
#endif
|
|
)
|
|
{
|
|
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
|
|
if (0U != (flag & (uint32_t)kSCANF_Suppress))
|
|
{
|
|
(*Cp) = (*Cp) + 1U;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
**buf = **Cp;
|
|
(*Cp) = (*Cp) + 1U;
|
|
(*buf) = (*buf) + 1U;
|
|
|
|
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
|
|
added = 1u;
|
|
#endif
|
|
}
|
|
*n_decode = *n_decode + 1U;
|
|
}
|
|
|
|
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
|
|
if (1u == added)
|
|
#endif
|
|
{
|
|
*nassigned = *nassigned + 1U;
|
|
}
|
|
}
|
|
|
|
static void StrFormatScanfHandleString(
|
|
const char **Sp, uint32_t *field_width, char **buf, uint32_t flag, uint32_t *n_decode, uint32_t *nassigned)
|
|
{
|
|
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
|
|
uint8_t added = 0;
|
|
#endif
|
|
while ((0U != ((*field_width)--)) && (**Sp != '\0') && (0U == ScanIsWhiteSpace(**Sp)))
|
|
{
|
|
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
|
|
if (0U != (flag & (uint32_t)kSCANF_Suppress))
|
|
{
|
|
(*Sp) = (*Sp) + 1U;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
**buf = **Sp;
|
|
(*buf) = (*buf) + 1U;
|
|
(*Sp) = (*Sp) + 1U;
|
|
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
|
|
added = 1u;
|
|
#endif
|
|
}
|
|
*n_decode = *n_decode + 1U;
|
|
}
|
|
|
|
#if (defined(SCANF_ADVANCED_ENABLE) && (SCANF_ADVANCED_ENABLE > 0U))
|
|
if (1u == added)
|
|
#endif
|
|
{
|
|
/* Add NULL to end of string. */
|
|
**buf = '\0';
|
|
*nassigned = *nassigned + 1U;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* 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 = 0U;
|
|
|
|
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;
|
|
|
|
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 *);
|
|
StrFormatScanfHandleChar(&p, &field_width, &buf, flag, &n_decode, &nassigned);
|
|
}
|
|
else if ((flag & (uint32_t)kSCANF_DestMask) == (uint32_t)kSCANF_DestString)
|
|
{
|
|
n_decode += ScanIgnoreWhiteSpace(&p);
|
|
buf = va_arg(args_ptr, char *);
|
|
StrFormatScanfHandleString(&p, &field_width, &buf, flag, &n_decode, &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;
|
|
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);
|
|
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;
|
|
}
|