3 * All rights reserved.
\r
6 * SPDX-License-Identifier: BSD-3-Clause
\r
12 #include "fsl_str.h"
\r
13 #include "fsl_debug_console_conf.h"
\r
15 /*******************************************************************************
\r
17 ******************************************************************************/
\r
19 /*! @brief The overflow value.*/
\r
21 #define HUGE_VAL (99.e99)
\r
22 #endif /* HUGE_VAL */
\r
24 #if PRINTF_ADVANCED_ENABLE
\r
25 /*! @brief Specification modifier flags for printf. */
\r
26 enum _debugconsole_printf_flag
\r
28 kPRINTF_Minus = 0x01U, /*!< Minus FLag. */
\r
29 kPRINTF_Plus = 0x02U, /*!< Plus Flag. */
\r
30 kPRINTF_Space = 0x04U, /*!< Space Flag. */
\r
31 kPRINTF_Zero = 0x08U, /*!< Zero Flag. */
\r
32 kPRINTF_Pound = 0x10U, /*!< Pound Flag. */
\r
33 kPRINTF_LengthChar = 0x20U, /*!< Length: Char Flag. */
\r
34 kPRINTF_LengthShortInt = 0x40U, /*!< Length: Short Int Flag. */
\r
35 kPRINTF_LengthLongInt = 0x80U, /*!< Length: Long Int Flag. */
\r
36 kPRINTF_LengthLongLongInt = 0x100U, /*!< Length: Long Long Int Flag. */
\r
38 #endif /* PRINTF_ADVANCED_ENABLE */
\r
40 /*! @brief Specification modifier flags for scanf. */
\r
41 enum _debugconsole_scanf_flag
\r
43 kSCANF_Suppress = 0x2U, /*!< Suppress Flag. */
\r
44 kSCANF_DestMask = 0x7cU, /*!< Destination Mask. */
\r
45 kSCANF_DestChar = 0x4U, /*!< Destination Char Flag. */
\r
46 kSCANF_DestString = 0x8U, /*!< Destination String FLag. */
\r
47 kSCANF_DestSet = 0x10U, /*!< Destination Set Flag. */
\r
48 kSCANF_DestInt = 0x20U, /*!< Destination Int Flag. */
\r
49 kSCANF_DestFloat = 0x30U, /*!< Destination Float Flag. */
\r
50 kSCANF_LengthMask = 0x1f00U, /*!< Length Mask Flag. */
\r
51 #if SCANF_ADVANCED_ENABLE
\r
52 kSCANF_LengthChar = 0x100U, /*!< Length Char Flag. */
\r
53 kSCANF_LengthShortInt = 0x200U, /*!< Length ShortInt Flag. */
\r
54 kSCANF_LengthLongInt = 0x400U, /*!< Length LongInt Flag. */
\r
55 kSCANF_LengthLongLongInt = 0x800U, /*!< Length LongLongInt Flag. */
\r
56 #endif /* SCANF_ADVANCED_ENABLE */
\r
57 #if SCANF_FLOAT_ENABLE
\r
58 kSCANF_LengthLongLongDouble = 0x1000U, /*!< Length LongLongDuoble Flag. */
\r
59 #endif /*PRINTF_FLOAT_ENABLE */
\r
60 kSCANF_TypeSinged = 0x2000U, /*!< TypeSinged Flag. */
\r
63 /*! @brief Keil: suppress ellipsis warning in va_arg usage below. */
\r
64 #if defined(__CC_ARM)
\r
65 #pragma diag_suppress 1256
\r
66 #endif /* __CC_ARM */
\r
68 /*******************************************************************************
\r
70 ******************************************************************************/
\r
72 * @brief Scanline function which ignores white spaces.
\r
74 * @param[in] s The address of the string pointer to update.
\r
75 * @return String without white spaces.
\r
77 static uint32_t ScanIgnoreWhiteSpace(const char **s);
\r
80 * @brief Converts a radix number to a string and return its length.
\r
82 * @param[in] numstr Converted string of the number.
\r
83 * @param[in] nump Pointer to the number.
\r
84 * @param[in] neg Polarity of the number.
\r
85 * @param[in] radix The radix to be converted to.
\r
86 * @param[in] use_caps Used to identify %x/X output format.
\r
88 * @return Length of the converted string.
\r
90 static int32_t ConvertRadixNumToString(char *numstr, void *nump, int32_t neg, int32_t radix, bool use_caps);
\r
92 #if PRINTF_FLOAT_ENABLE
\r
94 * @brief Converts a floating radix number to a string and return its length.
\r
96 * @param[in] numstr Converted string of the number.
\r
97 * @param[in] nump Pointer to the number.
\r
98 * @param[in] radix The radix to be converted to.
\r
99 * @param[in] precision_width Specify the precision width.
\r
101 * @return Length of the converted string.
\r
103 static int32_t ConvertFloatRadixNumToString(char *numstr, void *nump, int32_t radix, uint32_t precision_width);
\r
104 #endif /* PRINTF_FLOAT_ENABLE */
\r
109 double modf(double input_dbl, double *intpart_ptr);
\r
111 /*************Code for process formatted data*******************************/
\r
113 static uint32_t ScanIgnoreWhiteSpace(const char **s)
\r
119 while ((c == ' ') || (c == '\t') || (c == '\n') || (c == '\r') || (c == '\v') || (c == '\f'))
\r
128 static int32_t ConvertRadixNumToString(char *numstr, void *nump, int32_t neg, int32_t radix, bool use_caps)
\r
130 #if PRINTF_ADVANCED_ENABLE
\r
146 #endif /* PRINTF_ADVANCED_ENABLE */
\r
157 #if PRINTF_ADVANCED_ENABLE
\r
158 a = *(int64_t *)nump;
\r
160 a = *(int32_t *)nump;
\r
161 #endif /* PRINTF_ADVANCED_ENABLE */
\r
170 #if PRINTF_ADVANCED_ENABLE
\r
171 b = (int64_t)a / (int64_t)radix;
\r
172 c = (int64_t)a - ((int64_t)b * (int64_t)radix);
\r
176 c = (int64_t)(~uc) + 1 + '0';
\r
180 c = a - (b * radix);
\r
184 c = (uint32_t)(~uc) + 1 + '0';
\r
186 #endif /* PRINTF_ADVANCED_ENABLE */
\r
192 *nstrp++ = (char)c;
\r
198 #if PRINTF_ADVANCED_ENABLE
\r
199 ua = *(uint64_t *)nump;
\r
201 ua = *(uint32_t *)nump;
\r
202 #endif /* PRINTF_ADVANCED_ENABLE */
\r
211 #if PRINTF_ADVANCED_ENABLE
\r
212 ub = (uint64_t)ua / (uint64_t)radix;
\r
213 uc = (uint64_t)ua - ((uint64_t)ub * (uint64_t)radix);
\r
215 ub = ua / (uint32_t)radix;
\r
216 uc = ua - (ub * (uint32_t)radix);
\r
217 #endif /* PRINTF_ADVANCED_ENABLE */
\r
225 uc = uc - 10 + (use_caps ? 'A' : 'a');
\r
228 *nstrp++ = (char)uc;
\r
235 #if PRINTF_FLOAT_ENABLE
\r
236 static int32_t ConvertFloatRadixNumToString(char *numstr, void *nump, int32_t radix, uint32_t precision_width)
\r
255 r = *(double *)nump;
\r
262 fractpart = modf((double)r, (double *)&intpart);
\r
263 /* Process fractional part. */
\r
264 for (i = 0; i < precision_width; i++)
\r
266 fractpart *= radix;
\r
270 fa = fractpart + (double)0.5;
\r
271 if (fa >= pow(10, precision_width))
\r
278 fa = fractpart - (double)0.5;
\r
279 if (fa <= -pow(10, precision_width))
\r
284 for (i = 0; i < precision_width; i++)
\r
286 fb = fa / (int32_t)radix;
\r
287 dc = (fa - (int64_t)fb * (int32_t)radix);
\r
292 c = (int32_t)(~uc) + 1 + '0';
\r
299 *nstrp++ = (char)c;
\r
302 *nstrp++ = (char)'.';
\r
304 a = (int32_t)intpart;
\r
314 b = (int32_t)a / (int32_t)radix;
\r
315 c = (int32_t)a - ((int32_t)b * (int32_t)radix);
\r
319 c = (int32_t)(~uc) + 1 + '0';
\r
326 *nstrp++ = (char)c;
\r
332 #endif /* PRINTF_FLOAT_ENABLE */
\r
335 * brief This function outputs its parameters according to a formatted string.
\r
337 * note I/O is performed by calling given function pointer using following
\r
340 * param[in] fmt_ptr Format string for printf.
\r
341 * param[in] args_ptr Arguments to printf.
\r
342 * param[in] buf pointer to the buffer
\r
343 * param cb print callback function pointer
\r
345 * return Number of characters to be print
\r
347 int StrFormatPrintf(const char *fmt, va_list ap, char *buf, printfCb cb)
\r
354 char *vstrp = NULL;
\r
360 uint32_t field_width;
\r
361 uint32_t precision_width;
\r
367 #if PRINTF_ADVANCED_ENABLE
\r
368 uint32_t flags_used;
\r
369 int32_t schar, dschar;
\r
372 bool valid_precision_width;
\r
376 #endif /* PRINTF_ADVANCED_ENABLE */
\r
378 #if PRINTF_FLOAT_ENABLE
\r
380 #endif /* PRINTF_FLOAT_ENABLE */
\r
382 /* Start parsing apart the format string and display appropriate formats and data. */
\r
383 for (p = (char *)fmt; (c = *p) != 0; p++)
\r
386 * All formats begin with a '%' marker. Special chars like
\r
387 * '\n' or '\t' are normally converted to the appropriate
\r
388 * character by the __compiler__. Thus, no need for this
\r
389 * routine to account for the '\' character.
\r
393 cb(buf, &count, c, 1);
\r
394 /* By using 'continue', the next iteration of the loop is used, skipping the code that follows. */
\r
400 #if PRINTF_ADVANCED_ENABLE
\r
401 /* First check for specification modifier flags. */
\r
409 flags_used |= kPRINTF_Minus;
\r
412 flags_used |= kPRINTF_Plus;
\r
415 flags_used |= kPRINTF_Space;
\r
418 flags_used |= kPRINTF_Zero;
\r
421 flags_used |= kPRINTF_Pound;
\r
424 /* We've gone one char too far. */
\r
430 #endif /* PRINTF_ADVANCED_ENABLE */
\r
432 /* Next check for minimum field width. */
\r
438 if ((c >= '0') && (c <= '9'))
\r
440 field_width = (field_width * 10) + (c - '0');
\r
442 #if PRINTF_ADVANCED_ENABLE
\r
445 field_width = (uint32_t)va_arg(ap, uint32_t);
\r
447 #endif /* PRINTF_ADVANCED_ENABLE */
\r
450 /* We've gone one char too far. */
\r
455 /* Next check for the width and precision field separator. */
\r
456 precision_width = 6;
\r
457 #if PRINTF_ADVANCED_ENABLE
\r
458 valid_precision_width = false;
\r
459 #endif /* PRINTF_ADVANCED_ENABLE */
\r
462 /* Must get precision field width, if present. */
\r
463 precision_width = 0;
\r
468 if ((c >= '0') && (c <= '9'))
\r
470 precision_width = (precision_width * 10) + (c - '0');
\r
471 #if PRINTF_ADVANCED_ENABLE
\r
472 valid_precision_width = true;
\r
473 #endif /* PRINTF_ADVANCED_ENABLE */
\r
475 #if PRINTF_ADVANCED_ENABLE
\r
478 precision_width = (uint32_t)va_arg(ap, uint32_t);
\r
479 valid_precision_width = true;
\r
481 #endif /* PRINTF_ADVANCED_ENABLE */
\r
484 /* We've gone one char too far. */
\r
492 /* We've gone one char too far. */
\r
495 #if PRINTF_ADVANCED_ENABLE
\r
497 * Check for the length modifier.
\r
499 switch (/* c = */ *++p)
\r
504 flags_used |= kPRINTF_LengthShortInt;
\r
509 flags_used |= kPRINTF_LengthChar;
\r
515 flags_used |= kPRINTF_LengthLongInt;
\r
520 flags_used |= kPRINTF_LengthLongLongInt;
\r
524 /* we've gone one char too far */
\r
528 #endif /* PRINTF_ADVANCED_ENABLE */
\r
529 /* Now we're ready to examine the format. */
\r
532 if ((c == 'd') || (c == 'i') || (c == 'f') || (c == 'F') || (c == 'x') || (c == 'X') || (c == 'o') ||
\r
533 (c == 'b') || (c == 'p') || (c == 'u'))
\r
535 if ((c == 'd') || (c == 'i'))
\r
537 #if PRINTF_ADVANCED_ENABLE
\r
538 if (flags_used & kPRINTF_LengthLongLongInt)
\r
540 ival = (int64_t)va_arg(ap, int64_t);
\r
543 #endif /* PRINTF_ADVANCED_ENABLE */
\r
545 ival = (int32_t)va_arg(ap, int32_t);
\r
547 vlen = ConvertRadixNumToString(vstr, &ival, true, 10, use_caps);
\r
548 vstrp = &vstr[vlen];
\r
549 #if PRINTF_ADVANCED_ENABLE
\r
557 if (flags_used & kPRINTF_Plus)
\r
564 if (flags_used & kPRINTF_Space)
\r
576 /* Do the ZERO pad. */
\r
577 if (flags_used & kPRINTF_Zero)
\r
581 cb(buf, &count, schar, 1);
\r
585 cb(buf, &count, '0', field_width - vlen);
\r
586 vlen = field_width;
\r
590 if (!(flags_used & kPRINTF_Minus))
\r
592 cb(buf, &count, ' ', field_width - vlen);
\r
595 cb(buf, &count, schar, 1);
\r
600 /* The string was built in reverse order, now display in correct order. */
\r
601 if ((!dschar) && schar)
\r
603 cb(buf, &count, schar, 1);
\r
605 #endif /* PRINTF_ADVANCED_ENABLE */
\r
608 #if PRINTF_FLOAT_ENABLE
\r
609 if ((c == 'f') || (c == 'F'))
\r
611 fval = (double)va_arg(ap, double);
\r
612 vlen = ConvertFloatRadixNumToString(vstr, &fval, 10, precision_width);
\r
613 vstrp = &vstr[vlen];
\r
615 #if PRINTF_ADVANCED_ENABLE
\r
623 if (flags_used & kPRINTF_Plus)
\r
630 if (flags_used & kPRINTF_Space)
\r
642 if (flags_used & kPRINTF_Zero)
\r
646 cb(buf, &count, schar, 1);
\r
649 cb(buf, &count, '0', field_width - vlen);
\r
650 vlen = field_width;
\r
654 if (!(flags_used & kPRINTF_Minus))
\r
656 cb(buf, &count, ' ', field_width - vlen);
\r
659 cb(buf, &count, schar, 1);
\r
664 if ((!dschar) && schar)
\r
666 cb(buf, &count, schar, 1);
\r
668 #endif /* PRINTF_ADVANCED_ENABLE */
\r
670 #endif /* PRINTF_FLOAT_ENABLE */
\r
671 if ((c == 'X') || (c == 'x'))
\r
677 #if PRINTF_ADVANCED_ENABLE
\r
678 if (flags_used & kPRINTF_LengthLongLongInt)
\r
680 uval = (uint64_t)va_arg(ap, uint64_t);
\r
683 #endif /* PRINTF_ADVANCED_ENABLE */
\r
685 uval = (uint32_t)va_arg(ap, uint32_t);
\r
687 vlen = ConvertRadixNumToString(vstr, &uval, false, 16, use_caps);
\r
688 vstrp = &vstr[vlen];
\r
690 #if PRINTF_ADVANCED_ENABLE
\r
692 if (flags_used & kPRINTF_Zero)
\r
694 if (flags_used & kPRINTF_Pound)
\r
696 cb(buf, &count, '0', 1);
\r
697 cb(buf, &count, (use_caps ? 'X' : 'x'), 1);
\r
700 cb(buf, &count, '0', field_width - vlen);
\r
701 vlen = field_width;
\r
705 if (!(flags_used & kPRINTF_Minus))
\r
707 if (flags_used & kPRINTF_Pound)
\r
711 cb(buf, &count, ' ', field_width - vlen);
\r
712 if (flags_used & kPRINTF_Pound)
\r
714 cb(buf, &count, '0', 1);
\r
715 cb(buf, &count, (use_caps ? 'X' : 'x'), 1);
\r
721 if ((flags_used & kPRINTF_Pound) && (!dschar))
\r
723 cb(buf, &count, '0', 1);
\r
724 cb(buf, &count, (use_caps ? 'X' : 'x'), 1);
\r
727 #endif /* PRINTF_ADVANCED_ENABLE */
\r
729 if ((c == 'o') || (c == 'b') || (c == 'p') || (c == 'u'))
\r
731 #if PRINTF_ADVANCED_ENABLE
\r
732 if (flags_used & kPRINTF_LengthLongLongInt)
\r
734 uval = (uint64_t)va_arg(ap, uint64_t);
\r
737 #endif /* PRINTF_ADVANCED_ENABLE */
\r
739 uval = (uint32_t)va_arg(ap, uint32_t);
\r
759 vlen = ConvertRadixNumToString(vstr, &uval, false, radix, use_caps);
\r
760 vstrp = &vstr[vlen];
\r
761 #if PRINTF_ADVANCED_ENABLE
\r
762 if (flags_used & kPRINTF_Zero)
\r
764 cb(buf, &count, '0', field_width - vlen);
\r
765 vlen = field_width;
\r
769 if (!(flags_used & kPRINTF_Minus))
\r
771 cb(buf, &count, ' ', field_width - vlen);
\r
774 #endif /* PRINTF_ADVANCED_ENABLE */
\r
776 #if !PRINTF_ADVANCED_ENABLE
\r
777 cb(buf, &count, ' ', field_width - vlen);
\r
778 #endif /* !PRINTF_ADVANCED_ENABLE */
\r
783 cb(buf, &count, *vstrp--, 1);
\r
786 #if PRINTF_ADVANCED_ENABLE
\r
787 if (flags_used & kPRINTF_Minus)
\r
789 cb(buf, &count, ' ', field_width - vlen);
\r
791 #endif /* PRINTF_ADVANCED_ENABLE */
\r
795 cval = (char)va_arg(ap, uint32_t);
\r
796 cb(buf, &count, cval, 1);
\r
800 sval = (char *)va_arg(ap, char *);
\r
803 #if PRINTF_ADVANCED_ENABLE
\r
804 if (valid_precision_width)
\r
806 vlen = precision_width;
\r
810 vlen = strlen(sval);
\r
813 vlen = strlen(sval);
\r
814 #endif /* PRINTF_ADVANCED_ENABLE */
\r
815 #if PRINTF_ADVANCED_ENABLE
\r
816 if (!(flags_used & kPRINTF_Minus))
\r
817 #endif /* PRINTF_ADVANCED_ENABLE */
\r
819 cb(buf, &count, ' ', field_width - vlen);
\r
822 #if PRINTF_ADVANCED_ENABLE
\r
823 if (valid_precision_width)
\r
825 while ((*sval) && (vlen > 0))
\r
827 cb(buf, &count, *sval++, 1);
\r
830 /* In case that vlen sval is shorter than vlen */
\r
831 vlen = precision_width - vlen;
\r
835 #endif /* PRINTF_ADVANCED_ENABLE */
\r
838 cb(buf, &count, *sval++, 1);
\r
840 #if PRINTF_ADVANCED_ENABLE
\r
842 #endif /* PRINTF_ADVANCED_ENABLE */
\r
844 #if PRINTF_ADVANCED_ENABLE
\r
845 if (flags_used & kPRINTF_Minus)
\r
847 cb(buf, &count, ' ', field_width - vlen);
\r
849 #endif /* PRINTF_ADVANCED_ENABLE */
\r
854 cb(buf, &count, c, 1);
\r
863 * brief Converts an input line of ASCII characters based upon a provided
\r
866 * param[in] line_ptr The input line of ASCII data.
\r
867 * param[in] format Format first points to the format string.
\r
868 * param[in] args_ptr The list of parameters.
\r
870 * return Number of input items converted and assigned.
\r
871 * retval IO_EOF When line_ptr is empty string "".
\r
873 int StrFormatScanf(const char *line_ptr, char *format, va_list args_ptr)
\r
877 /* Identifier for the format string. */
\r
881 /* Flag telling the conversion specification. */
\r
883 /* Filed width for the matching input streams. */
\r
884 uint32_t field_width;
\r
885 /* How many arguments are assigned except the suppress. */
\r
886 uint32_t nassigned = 0;
\r
887 /* How many characters are read from the input streams. */
\r
888 uint32_t n_decode = 0;
\r
893 /* Identifier for the input string. */
\r
894 const char *p = line_ptr;
\r
896 #if SCANF_FLOAT_ENABLE
\r
898 #endif /* SCANF_FLOAT_ENABLE */
\r
899 /* Return EOF error before any conversion. */
\r
905 /* Decode directives. */
\r
906 while ((*c) && (*p))
\r
908 /* Ignore all white-spaces in the format strings. */
\r
909 if (ScanIgnoreWhiteSpace((const char **)&c))
\r
911 n_decode += ScanIgnoreWhiteSpace(&p);
\r
913 else if ((*c != '%') || ((*c == '%') && (*(c + 1) == '%')))
\r
915 /* Ordinary characters. */
\r
925 /* Match failure. Misalignment with C99, the unmatched characters need to be pushed back to stream.
\r
926 * However, it is deserted now. */
\r
932 /* convernsion specification */
\r
939 /* Loop to get full conversion specification. */
\r
940 while ((*c) && (!(flag & kSCANF_DestMask)))
\r
944 #if SCANF_ADVANCED_ENABLE
\r
946 if (flag & kSCANF_Suppress)
\r
948 /* Match failure. */
\r
951 flag |= kSCANF_Suppress;
\r
955 if (flag & kSCANF_LengthMask)
\r
957 /* Match failure. */
\r
963 flag |= kSCANF_LengthChar;
\r
968 flag |= kSCANF_LengthShortInt;
\r
973 if (flag & kSCANF_LengthMask)
\r
975 /* Match failure. */
\r
981 flag |= kSCANF_LengthLongLongInt;
\r
986 flag |= kSCANF_LengthLongInt;
\r
990 #endif /* SCANF_ADVANCED_ENABLE */
\r
991 #if SCANF_FLOAT_ENABLE
\r
993 if (flag & kSCANF_LengthMask)
\r
995 /* Match failure. */
\r
998 flag |= kSCANF_LengthLongLongDouble;
\r
1001 #endif /* SCANF_FLOAT_ENABLE */
\r
1014 /* Match failure. */
\r
1019 field_width = field_width * 10 + *c - '0';
\r
1021 } while ((*c >= '0') && (*c <= '9'));
\r
1025 flag |= kSCANF_TypeSinged;
\r
1026 flag |= kSCANF_DestInt;
\r
1031 flag |= kSCANF_DestInt;
\r
1036 flag |= kSCANF_DestInt;
\r
1042 flag |= kSCANF_DestInt;
\r
1047 flag |= kSCANF_DestInt;
\r
1050 #if SCANF_FLOAT_ENABLE
\r
1059 flag |= kSCANF_DestFloat;
\r
1062 #endif /* SCANF_FLOAT_ENABLE */
\r
1064 flag |= kSCANF_DestChar;
\r
1072 flag |= kSCANF_DestString;
\r
1080 if (!(flag & kSCANF_DestMask))
\r
1082 /* Format strings are exhausted. */
\r
1088 /* Large than length of a line. */
\r
1092 /* Matching strings in input streams and assign to argument. */
\r
1093 switch (flag & kSCANF_DestMask)
\r
1095 case kSCANF_DestChar:
\r
1096 s = (const char *)p;
\r
1097 buf = va_arg(args_ptr, char *);
\r
1098 while ((field_width--) && (*p))
\r
1100 if (!(flag & kSCANF_Suppress))
\r
1111 if ((!(flag & kSCANF_Suppress)) && (s != p))
\r
1116 case kSCANF_DestString:
\r
1117 n_decode += ScanIgnoreWhiteSpace(&p);
\r
1119 buf = va_arg(args_ptr, char *);
\r
1120 while ((field_width--) && (*p != '\0') && (*p != ' ') && (*p != '\t') && (*p != '\n') &&
\r
1121 (*p != '\r') && (*p != '\v') && (*p != '\f'))
\r
1123 if (flag & kSCANF_Suppress)
\r
1134 if ((!(flag & kSCANF_Suppress)) && (s != p))
\r
1136 /* Add NULL to end of string. */
\r
1141 case kSCANF_DestInt:
\r
1142 n_decode += ScanIgnoreWhiteSpace(&p);
\r
1145 if ((base == 0) || (base == 16))
\r
1147 if ((s[0] == '0') && ((s[1] == 'x') || (s[1] == 'X')))
\r
1150 if (field_width >= 1)
\r
1190 while ((*p) && (field_width--))
\r
1192 if ((*p <= '9') && (*p >= '0'))
\r
1196 else if ((*p <= 'f') && (*p >= 'a'))
\r
1198 temp = *p - 'a' + 10;
\r
1200 else if ((*p <= 'F') && (*p >= 'A'))
\r
1202 temp = *p - 'A' + 10;
\r
1215 val = base * val + temp;
\r
1221 if (!(flag & kSCANF_Suppress))
\r
1223 #if SCANF_ADVANCED_ENABLE
\r
1224 switch (flag & kSCANF_LengthMask)
\r
1226 case kSCANF_LengthChar:
\r
1227 if (flag & kSCANF_TypeSinged)
\r
1229 *va_arg(args_ptr, signed char *) = (signed char)val;
\r
1233 *va_arg(args_ptr, unsigned char *) = (unsigned char)val;
\r
1236 case kSCANF_LengthShortInt:
\r
1237 if (flag & kSCANF_TypeSinged)
\r
1239 *va_arg(args_ptr, signed short *) = (signed short)val;
\r
1243 *va_arg(args_ptr, unsigned short *) = (unsigned short)val;
\r
1246 case kSCANF_LengthLongInt:
\r
1247 if (flag & kSCANF_TypeSinged)
\r
1249 *va_arg(args_ptr, signed long int *) = (signed long int)val;
\r
1253 *va_arg(args_ptr, unsigned long int *) = (unsigned long int)val;
\r
1256 case kSCANF_LengthLongLongInt:
\r
1257 if (flag & kSCANF_TypeSinged)
\r
1259 *va_arg(args_ptr, signed long long int *) = (signed long long int)val;
\r
1263 *va_arg(args_ptr, unsigned long long int *) = (unsigned long long int)val;
\r
1267 /* The default type is the type int. */
\r
1268 if (flag & kSCANF_TypeSinged)
\r
1270 *va_arg(args_ptr, signed int *) = (signed int)val;
\r
1274 *va_arg(args_ptr, unsigned int *) = (unsigned int)val;
\r
1279 /* The default type is the type int. */
\r
1280 if (flag & kSCANF_TypeSinged)
\r
1282 *va_arg(args_ptr, signed int *) = (signed int)val;
\r
1286 *va_arg(args_ptr, unsigned int *) = (unsigned int)val;
\r
1288 #endif /* SCANF_ADVANCED_ENABLE */
\r
1292 #if SCANF_FLOAT_ENABLE
\r
1293 case kSCANF_DestFloat:
\r
1294 n_decode += ScanIgnoreWhiteSpace(&p);
\r
1295 fnum = strtod(p, (char **)&s);
\r
1297 if ((fnum >= HUGE_VAL) || (fnum <= -HUGE_VAL))
\r
1302 n_decode += (int)(s) - (int)(p);
\r
1304 if (!(flag & kSCANF_Suppress))
\r
1306 if (flag & kSCANF_LengthLongLongDouble)
\r
1308 *va_arg(args_ptr, double *) = fnum;
\r
1312 *va_arg(args_ptr, float *) = (float)fnum;
\r
1317 #endif /* SCANF_FLOAT_ENABLE */
\r