From bdcdebef745db7285edcd6e255dd487ea925b1b6 Mon Sep 17 00:00:00 2001 From: Yonggang Luo Date: Fri, 24 Nov 2023 21:13:57 +0800 Subject: [PATCH 1/5] Convert to block comment for multiple line comments (( *)//.*\n)( *//.*\n)+ -> $2/**\n$0$2 */\n --- src/printf/printf.c | 100 ++++++++++++++++++++++++++++++++++++++++++++ src/printf/printf.h | 2 + 2 files changed, 102 insertions(+) diff --git a/src/printf/printf.c b/src/printf/printf.c index e47bac6..bcf1792 100644 --- a/src/printf/printf.c +++ b/src/printf/printf.c @@ -37,8 +37,10 @@ * THE SOFTWARE. */ +/** // Define this globally (e.g. gcc -DPRINTF_INCLUDE_CONFIG_H=1 ...) to include the // printf_config.h header file + */ #if PRINTF_INCLUDE_CONFIG_H #include "printf_config.h" #endif @@ -64,15 +66,19 @@ #endif +/** // 'ntoa' conversion buffer size, this must be big enough to hold one converted // numeric number including padded zeros (dynamically created on stack) + */ #ifndef PRINTF_INTEGER_BUFFER_SIZE #define PRINTF_INTEGER_BUFFER_SIZE 32 #endif +/** // size of the fixed (on-stack) buffer for printing individual decimal numbers. // this must be big enough to hold one converted floating-point value including // padded zeros. + */ #ifndef PRINTF_DECIMAL_BUFFER_SIZE #define PRINTF_DECIMAL_BUFFER_SIZE 32 #endif @@ -102,23 +108,29 @@ #define PRINTF_USE_DOUBLE_INTERNALLY 1 #endif +/** // According to the C languages standard, printf() and related functions must be able to print any // integral number in floating-point notation, regardless of length, when using the %f specifier - // possibly hundreds of characters, potentially overflowing your buffers. In this implementation, // all values beyond this threshold are switched to exponential notation. + */ #ifndef PRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL #define PRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL 9 #endif +/** // Support for the long long integral types (with the ll, z and t length modifiers for specifiers // %d,%i,%o,%x,%X,%u, and with the %p specifier). + */ #ifndef PRINTF_SUPPORT_LONG_LONG #define PRINTF_SUPPORT_LONG_LONG 1 #endif +/** // The number of terms in a Taylor series expansion of log_10(x) to // use for approximation - including the power-zero term (i.e. the // value at the point of expansion). + */ #ifndef PRINTF_LOG10_TAYLOR_TERMS #define PRINTF_LOG10_TAYLOR_TERMS 4 #endif @@ -127,8 +139,10 @@ #error "At least one non-constant Taylor expansion is necessary for the log10() calculation" #endif +/** // Be extra-safe, and don't assume format specifiers are completed correctly // before the format string end. + */ #ifndef PRINTF_CHECK_FOR_NUL_IN_FORMAT_SPECIFIER #define PRINTF_CHECK_FOR_NUL_IN_FORMAT_SPECIFIER 1 #endif @@ -225,16 +239,20 @@ typedef unsigned long printf_unsigned_value_t; typedef long printf_signed_value_t; #endif +/** // The printf()-family functions return an `int`; it is therefore // unnecessary/inappropriate to use size_t - often larger than int // in practice - for non-negative related values, such as widths, // precisions, offsets into buffers used for printing and the sizes // of these buffers. instead, we use: + */ typedef unsigned int printf_size_t; #define PRINTF_MAX_POSSIBLE_BUFFER_SIZE INT_MAX + /** // If we were to nitpick, this would actually be INT_MAX + 1, // since INT_MAX is the maximum return value, which excludes the // trailing '\0'. + */ #if (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS) #include @@ -294,11 +312,13 @@ typedef union { floating_point_t F; } floating_point_with_bit_access; +/** // This is unnecessary in C99, since compound initializers can be used, // but: // 1. Some compilers are finicky about this; // 2. Some people may want to convert this to C89; // 3. If you try to use it as C++, only C++20 supports compound literals + */ static inline floating_point_with_bit_access get_bit_access(floating_point_t x) { floating_point_with_bit_access dwba; @@ -314,21 +334,26 @@ static inline int get_sign_bit(floating_point_t x) static inline int get_exp2(floating_point_with_bit_access x) { + /** // The exponent in an IEEE-754 floating-point number occupies a contiguous // sequence of bits (e.g. 52..62 for 64-bit doubles), but with a non-trivial representation: An // unsigned offset from some negative value (with the extremal offset values reserved for // special use). + */ return (int)((x.U >> FP_TYPE_STORED_MANTISSA_BITS ) & FP_TYPE_EXPONENT_MASK) - FP_TYPE_BASE_EXPONENT; } #define PRINTF_ABS(_x) ( (_x) > 0 ? (_x) : -(_x) ) #endif // (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS) +/** // Note in particular the behavior here on LONG_MIN or LLONG_MIN; it is valid // and well-defined, but if you're not careful you can easily trigger undefined // behavior with -LONG_MIN or -LLONG_MIN + */ #define ABS_FOR_PRINTING(_x) ((printf_unsigned_value_t) ( (_x) > 0 ? (_x) : -((printf_signed_value_t)_x) )) +/** // wrapper (used as buffer) for output function type // // One of the following must hold: @@ -337,6 +362,7 @@ static inline int get_exp2(floating_point_with_bit_access x) // 3. function is non-null // // ... otherwise bad things will happen. + */ typedef struct { void (*function)(char c, void* extra_arg); void* extra_function_arg; @@ -345,15 +371,19 @@ typedef struct { printf_size_t max_chars; } output_gadget_t; +/** // Note: This function currently assumes it is not passed a '\0' c, // or alternatively, that '\0' can be passed to the function in the output // gadget. The former assumption holds within the printf library. It also // assumes that the output gadget has been properly initialized. + */ static inline void putchar_via_gadget(output_gadget_t* gadget, char c) { printf_size_t write_pos = gadget->pos++; + /** // We're _always_ increasing pos, so as to count how may characters // _would_ have been written if not for the max_chars limitation + */ if (write_pos >= gadget->max_chars) { return; } @@ -362,8 +392,10 @@ static inline void putchar_via_gadget(output_gadget_t* gadget, char c) gadget->function(c, gadget->extra_function_arg); } else { + /** // it must be the case that gadget->buffer != NULL , due to the constraint // on output_gadget_t ; and note we're relying on write_pos being non-negative. + */ gadget->buffer[write_pos] = c; } } @@ -381,8 +413,10 @@ static inline void append_termination_with_gadget(output_gadget_t* gadget) gadget->buffer[null_char_pos] = '\0'; } +/** // We can't use putchar_ as is, since our output gadget // only takes pointers to functions with an extra argument + */ static inline void putchar_wrapper(char c, void* unused) { (void) unused; @@ -426,10 +460,12 @@ static inline output_gadget_t extern_putchar_gadget(void) return function_gadget(putchar_wrapper, NULL); } +/** // internal secure strlen // @return The length of the string (excluding the terminating 0) limited by 'maxsize' // @note strlen uses size_t, but wes only use this function with printf_size_t // variables - hence the signature. + */ static inline printf_size_t strnlen_s_(const char* str, printf_size_t maxsize) { const char* s; @@ -438,8 +474,10 @@ static inline printf_size_t strnlen_s_(const char* str, printf_size_t maxsize) } +/** // internal test if char is a digit (0-9) // @return true if char is a digit + */ static inline bool is_digit_(char ch) { return (ch >= '0') && (ch <= '9'); @@ -483,8 +521,10 @@ static void out_rev_(output_gadget_t* output, const char* buf, printf_size_t len } +/** // Invoked by print_integer after the actual number has been printed, performing necessary // work on the number's prefix (as the number is initially printed in reverse order) + */ static void print_integer_finalization(output_gadget_t* output, char* buf, printf_size_t len, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags) { printf_size_t unpadded_len = len; @@ -513,8 +553,10 @@ static void print_integer_finalization(output_gadget_t* output, char* buf, print // handle hash if (flags & (FLAGS_HASH | FLAGS_POINTER)) { if (!(flags & FLAGS_PRECISION) && len && ((len == precision) || (len == width))) { + /** // Let's take back some padding digits to fit in what will eventually // be the format-specific prefix + */ if (unpadded_len < len) { len--; // This should suffice for BASE_OCTAL } @@ -561,14 +603,18 @@ static void print_integer(output_gadget_t* output, printf_unsigned_value_t value if ( !(flags & FLAGS_PRECISION) ) { buf[len++] = '0'; flags &= ~FLAGS_HASH; + /** // We drop this flag this since either the alternative and regular modes of the specifier // don't differ on 0 values, or (in the case of octal) we've already provided the special // handling for this mode. + */ } else if (base == BASE_HEX) { flags &= ~FLAGS_HASH; + /** // We drop this flag this since either the alternative and regular modes of the specifier // don't differ on 0 values + */ } } else { @@ -584,13 +630,17 @@ static void print_integer(output_gadget_t* output, printf_unsigned_value_t value #if (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS) +/** // Stores a fixed-precision representation of a floating-point number relative // to a fixed precision (which cannot be determined by examining this structure) + */ struct floating_point_components { int_fast64_t integral; int_fast64_t fractional; + /** // ... truncation of the actual fractional part of the floating_point_t value, scaled // by the precision value + */ bool is_negative; }; @@ -601,15 +651,19 @@ static const floating_point_t powers_of_10[PRINTF_MAX_PRECOMPUTED_POWER_OF_10 + #endif }; +/** // Note: This value does not mean that all floating-point values printed with the // library will be correct up to this precision; it is just an upper-bound for // avoiding buffer overruns and such + */ #define PRINTF_MAX_SUPPORTED_PRECISION (NUM_DECIMAL_DIGITS_IN_INT64_T - 1) +/** // Break up a floating-point number - which is known to be a finite non-negative number - // into its base-10 parts: integral - before the decimal point, and fractional - after it. // Taken the precision into account, but does not change it even internally. + */ static struct floating_point_components get_components(floating_point_t number, printf_size_t precision) { struct floating_point_components number_; @@ -631,16 +685,20 @@ static struct floating_point_components get_components(floating_point_t number, } } else if ((remainder == one_half) && (number_.fractional & 1U)) { + /** // Banker's rounding, i.e. round half to even: // 1.5 -> 2, but 2.5 -> 2 + */ ++number_.fractional; } if (precision == 0U) { remainder = abs_number - (floating_point_t) number_.integral; if ((remainder == one_half) && (number_.integral & 1U)) { + /** // Banker's rounding, i.e. round half to even: // 1.5 -> 2, but 2.5 -> 2 + */ ++number_.integral; } } @@ -707,9 +765,11 @@ static struct floating_point_components get_normalized_components(bool negative, bool close_to_representation_extremum = ( (-floored_exp10 + (int) precision) >= FP_TYPE_MAX_10_EXP - 1 ); if (close_to_representation_extremum) { + /** // We can't have a normalization factor which also accounts for the precision, i.e. moves // some decimal digits into the mantissa, since it's unrepresentable, or nearly unrepresentable. // So, we'll give up early on getting extra precision... + */ return get_components(negative ? -scaled : scaled, precision); } components.integral = (int_fast64_t) scaled; @@ -727,11 +787,13 @@ static struct floating_point_components get_normalized_components(bool negative, // banker's rounding: Round towards the even number (making the mean error 0) components.fractional &= ~((int_fast64_t) 0x1); } + /** // handle rollover, e.g. the case of 0.99 with precision 1 becoming (0,100), // and must then be corrected into (1, 0). // Note: for precision = 0, this will "translate" the rounding effect from // the fractional part to the integral part where it should actually be // felt (as prec_power_of_10 is 1) + */ if ((floating_point_t) components.fractional >= prec_power_of_10) { components.fractional = 0; ++components.integral; @@ -760,8 +822,10 @@ static void print_broken_up_decimal( number_.fractional /= 10U; } + /** // ... and even the decimal point if there are no // non-zero fractional part digits (see below) + */ } if (number_.fractional > 0 || !(flags & FLAGS_ADAPT_EXP) || (flags & FLAGS_HASH) ) { @@ -788,8 +852,10 @@ static void print_broken_up_decimal( } } + /** // Write the integer part of the number (it comes after the fractional // since the character order is reversed) + */ while (len < PRINTF_DECIMAL_BUFFER_SIZE) { buf[len++] = (char)('0' + (number_.integral % 10)); if (!(number_.integral /= 10)) { @@ -831,8 +897,10 @@ static void print_decimal_number(output_gadget_t* output, floating_point_t numbe #if PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS +/** // A floor function - but one which only works for numbers whose // floor value is representable by an int. + */ static int bastardized_floor(floating_point_t x) { if (x >= 0) { return (int) x; } @@ -840,10 +908,13 @@ static int bastardized_floor(floating_point_t x) return ( ((floating_point_t) n) == x ) ? n : n-1; } +/** // Computes the base-10 logarithm of the input number - which must be an actual // positive number (not infinity or NaN, nor a sub-normal) + */ static floating_point_t log10_of_positive(floating_point_t positive_number) { + /** // The implementation follows David Gay (https://www.ampl.com/netlib/fp/dtoa.c). // // Since log_10 ( M * 2^x ) = log_10(M) + x , we can separate the components of @@ -851,6 +922,7 @@ static floating_point_t log10_of_positive(floating_point_t positive_number) // the base-2 mantissa is always 1-point-something). In that limited range, a // Taylor series expansion of log10(x) should serve us well enough; and we'll // take the mid-point, 1.5, as the point of expansion. + */ floating_point_with_bit_access dwba = get_bit_access(positive_number); // based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c) @@ -887,8 +959,10 @@ static floating_point_t pow10_of_int(int floored_exp10) const floating_point_t z = (floating_point_t) (floored_exp10 * 2.302585092994046 - exp2 * 0.6931471805599453); const floating_point_t z2 = z * z; dwba.U = ((printf_fp_uint_t)(exp2) + FP_TYPE_BASE_EXPONENT) << FP_TYPE_STORED_MANTISSA_BITS; + /** // compute exp(z) using continued fractions, // see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex + */ dwba.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14))))); return dwba.F; } @@ -922,21 +996,25 @@ static void print_exponential_number(output_gadget_t* output, floating_point_t n normalization.raw_factor = abs_exp10_covered_by_powers_table ? powers_of_10[PRINTF_ABS(floored_exp10)] : p10; } + /** // We now begin accounting for the widths of the two parts of our printed field: // the decimal part after decimal exponent extraction, and the base-10 exponent part. // For both of these, the value of 0 has a special meaning, but not the same one: // a 0 exponent-part width means "don't print the exponent"; a 0 decimal-part width // means "use as many characters as necessary". + */ bool fall_back_to_decimal_only_mode = false; if (flags & FLAGS_ADAPT_EXP) { int required_significant_digits = (precision == 0) ? 1 : (int) precision; // Should we want to fall-back to "%f" mode, and only print the decimal part? fall_back_to_decimal_only_mode = (floored_exp10 >= -4 && floored_exp10 < required_significant_digits); + /** // Now, let's adjust the precision // This also decided how we adjust the precision value - as in "%g" mode, // "precision" is the number of _significant digits_, and this is when we "translate" // the precision value to an actual number of decimal digits. + */ int precision_ = fall_back_to_decimal_only_mode ? (int) precision - 1 - floored_exp10 : (int) precision - 1; // the presence of the exponent ensures only one significant digit comes before the decimal point @@ -963,8 +1041,10 @@ static void print_exponential_number(output_gadget_t* output, floating_point_t n get_components(negative ? -abs_number : abs_number, precision) : get_normalized_components(negative, precision, abs_number, normalization, floored_exp10); + /** // Account for roll-over, e.g. rounding from 9.99 to 100.0 - which effects // the exponent and may require additional tweaking of the parts + */ if (fall_back_to_decimal_only_mode) { if ((flags & FLAGS_ADAPT_EXP) && floored_exp10 >= -1 && decimal_part_components.integral == powers_of_10[floored_exp10 + 1]) { floored_exp10++; // Not strictly necessary, since floored_exp10 is no longer really used @@ -981,23 +1061,33 @@ static void print_exponential_number(output_gadget_t* output, floating_point_t n } } + /** // the floored_exp10 format is "E%+03d" and largest possible floored_exp10 value for a 64-bit double // is "307" (for 2^1023), so we set aside 4-5 characters overall + */ printf_size_t exp10_part_width = fall_back_to_decimal_only_mode ? 0U : (PRINTF_ABS(floored_exp10) < 100) ? 4U : 5U; printf_size_t decimal_part_width = ((flags & FLAGS_LEFT) && exp10_part_width) ? + /** // We're padding on the right, so the width constraint is the exponent part's // problem, not the decimal part's, so we'll use as many characters as we need: + */ 0U : + /** // We're padding on the left; so the width constraint is the decimal part's // problem. Well, can both the decimal part and the exponent part fit within our overall width? + */ ((width > exp10_part_width) ? + /** // Yes, so we limit our decimal part's width. // (Note this is trivially valid even if we've fallen back to "%f" mode) + */ width - exp10_part_width : + /** // No; we just give up on any restriction on the decimal part and use as many // characters as we need + */ 0U); const printf_size_t printed_exponential_start_pos = output->pos; @@ -1040,9 +1130,11 @@ static void print_floating_point(output_gadget_t* output, floating_point_t value if (!prefer_exponential && ((value > PRINTF_FLOAT_NOTATION_THRESHOLD) || (value < -PRINTF_FLOAT_NOTATION_THRESHOLD))) { + /** // The required behavior of standard printf is to print _every_ integral-part digit -- which could mean // printing hundreds of characters, overflowing any fixed internal buffer and necessitating a more complicated // implementation. + */ #if PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS print_exponential_number(output, value, precision, width, flags, buf, len); #endif @@ -1070,8 +1162,10 @@ static void print_floating_point(output_gadget_t* output, floating_point_t value #endif // (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS) +/** // Advances the format pointer past the flags, and returns the parsed flags // due to the characters passed + */ static printf_flags_t parse_flags(const char** format) { printf_flags_t flags = 0U; @@ -1257,10 +1351,12 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma print_integer(output, ABS_FOR_PRINTING(value), value < 0, base, precision, width, flags); } else { + /** // We never try to interpret the argument as something potentially-smaller than int, // due to integer promotion rules: Even if the user passed a short int, short unsigned // etc. - these will come in after promotion, as int's (or unsigned for the case of // short unsigned when it has the same size as int) + */ const int value = (flags & FLAGS_CHAR) ? (signed char) va_arg(args, int) : (flags & FLAGS_SHORT) ? (short int) va_arg(args, int) : @@ -1382,9 +1478,11 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma format++; break; + /** // Many people prefer to disable support for %n, as it lets the caller // engineer a write to an arbitrary location, of a value the caller // effectively controls - which could be a security concern in some cases. + */ #if PRINTF_SUPPORT_WRITEBACK_SPECIFIER case 'n' : { if (flags & FLAGS_CHAR) *(va_arg(args, char*)) = (char) output->pos; @@ -1410,8 +1508,10 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma // internal vsnprintf - used for implementing _all library functions static int vsnprintf_impl(output_gadget_t* output, const char* format, va_list args) { + /** // Note: The library only calls vsnprintf_impl() with output->pos being 0. However, it is // possible to call this function with a non-zero pos value for some "remedial printing". + */ format_string_loop(output, format, args); // termination diff --git a/src/printf/printf.h b/src/printf/printf.h index 48cbade..eb58961 100644 --- a/src/printf/printf.h +++ b/src/printf/printf.h @@ -80,10 +80,12 @@ ATTR_PRINTF((one_based_format_index), 0) # define vprintf_ vprintf #endif +/** // If you want to include this implementation file directly rather than // link against it, this will let you control the functions' visibility, // e.g. make them static so as not to clash with other objects also // using them. + */ #ifndef PRINTF_VISIBILITY #define PRINTF_VISIBILITY #endif From b2eb05853d446384dc8e5359d9e333ca0cefe889 Mon Sep 17 00:00:00 2001 From: Yonggang Luo Date: Fri, 24 Nov 2023 21:16:40 +0800 Subject: [PATCH 2/5] C89 comment for usage printf with rather old compiler that with -ansi compiler option --- src/printf/printf.c | 490 ++++++++++++++++++++++---------------------- src/printf/printf.h | 24 +-- 2 files changed, 257 insertions(+), 257 deletions(-) diff --git a/src/printf/printf.c b/src/printf/printf.c index bcf1792..17d835a 100644 --- a/src/printf/printf.c +++ b/src/printf/printf.c @@ -38,8 +38,8 @@ */ /** -// Define this globally (e.g. gcc -DPRINTF_INCLUDE_CONFIG_H=1 ...) to include the -// printf_config.h header file + * Define this globally (e.g. gcc -DPRINTF_INCLUDE_CONFIG_H=1 ...) to include the + * printf_config.h header file */ #if PRINTF_INCLUDE_CONFIG_H #include "printf_config.h" @@ -54,7 +54,7 @@ #include #include #include -#endif // __cplusplus +#endif /* __cplusplus */ #if PRINTF_ALIAS_STANDARD_FUNCTION_NAMES_HARD # define printf_ printf @@ -67,69 +67,69 @@ /** -// 'ntoa' conversion buffer size, this must be big enough to hold one converted -// numeric number including padded zeros (dynamically created on stack) + * 'ntoa' conversion buffer size, this must be big enough to hold one converted + * numeric number including padded zeros (dynamically created on stack) */ #ifndef PRINTF_INTEGER_BUFFER_SIZE #define PRINTF_INTEGER_BUFFER_SIZE 32 #endif /** -// size of the fixed (on-stack) buffer for printing individual decimal numbers. -// this must be big enough to hold one converted floating-point value including -// padded zeros. + * size of the fixed (on-stack) buffer for printing individual decimal numbers. + * this must be big enough to hold one converted floating-point value including + * padded zeros. */ #ifndef PRINTF_DECIMAL_BUFFER_SIZE #define PRINTF_DECIMAL_BUFFER_SIZE 32 #endif -// Support for the decimal notation floating point conversion specifiers (%f, %F) +/* Support for the decimal notation floating point conversion specifiers (%f, %F) */ #ifndef PRINTF_SUPPORT_DECIMAL_SPECIFIERS #define PRINTF_SUPPORT_DECIMAL_SPECIFIERS 1 #endif -// Support for the exponential notation floating point conversion specifiers (%e, %g, %E, %G) +/* Support for the exponential notation floating point conversion specifiers (%e, %g, %E, %G) */ #ifndef PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS #define PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS 1 #endif -// Support for the length write-back specifier (%n) +/* Support for the length write-back specifier (%n) */ #ifndef PRINTF_SUPPORT_WRITEBACK_SPECIFIER #define PRINTF_SUPPORT_WRITEBACK_SPECIFIER 1 #endif -// Default precision for the floating point conversion specifiers (the C standard sets this at 6) +/* Default precision for the floating point conversion specifiers (the C standard sets this at 6) */ #ifndef PRINTF_DEFAULT_FLOAT_PRECISION #define PRINTF_DEFAULT_FLOAT_PRECISION 6 #endif -// Default choice of type to use for internal floating-point computations +/* Default choice of type to use for internal floating-point computations */ #ifndef PRINTF_USE_DOUBLE_INTERNALLY #define PRINTF_USE_DOUBLE_INTERNALLY 1 #endif /** -// According to the C languages standard, printf() and related functions must be able to print any -// integral number in floating-point notation, regardless of length, when using the %f specifier - -// possibly hundreds of characters, potentially overflowing your buffers. In this implementation, -// all values beyond this threshold are switched to exponential notation. + * According to the C languages standard, printf() and related functions must be able to print any + * integral number in floating-point notation, regardless of length, when using the %f specifier - + * possibly hundreds of characters, potentially overflowing your buffers. In this implementation, + * all values beyond this threshold are switched to exponential notation. */ #ifndef PRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL #define PRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL 9 #endif /** -// Support for the long long integral types (with the ll, z and t length modifiers for specifiers -// %d,%i,%o,%x,%X,%u, and with the %p specifier). + * Support for the long long integral types (with the ll, z and t length modifiers for specifiers + * %d,%i,%o,%x,%X,%u, and with the %p specifier). */ #ifndef PRINTF_SUPPORT_LONG_LONG #define PRINTF_SUPPORT_LONG_LONG 1 #endif /** -// The number of terms in a Taylor series expansion of log_10(x) to -// use for approximation - including the power-zero term (i.e. the -// value at the point of expansion). + * The number of terms in a Taylor series expansion of log_10(x) to + * use for approximation - including the power-zero term (i.e. the + * value at the point of expansion). */ #ifndef PRINTF_LOG10_TAYLOR_TERMS #define PRINTF_LOG10_TAYLOR_TERMS 4 @@ -140,8 +140,8 @@ #endif /** -// Be extra-safe, and don't assume format specifiers are completed correctly -// before the format string end. + * Be extra-safe, and don't assume format specifiers are completed correctly + * before the format string end. */ #ifndef PRINTF_CHECK_FOR_NUL_IN_FORMAT_SPECIFIER #define PRINTF_CHECK_FOR_NUL_IN_FORMAT_SPECIFIER 1 @@ -150,14 +150,14 @@ #define PRINTF_PREFER_DECIMAL false #define PRINTF_PREFER_EXPONENTIAL true -/////////////////////////////////////////////////////////////////////////////// +/*====================================================================================*/ -// The following will convert the number-of-digits into an exponential-notation literal +/* The following will convert the number-of-digits into an exponential-notation literal */ #define PRINTF_CONCATENATE(s1, s2) s1##s2 #define PRINTF_EXPAND_THEN_CONCATENATE(s1, s2) PRINTF_CONCATENATE(s1, s2) #define PRINTF_FLOAT_NOTATION_THRESHOLD ((floating_point_t) PRINTF_EXPAND_THEN_CONCATENATE(1e,PRINTF_MAX_INTEGRAL_DIGITS_FOR_DECIMAL)) -// internal flag definitions +/* internal flag definitions */ #define FLAGS_ZEROPAD (1U << 0U) #define FLAGS_LEFT (1U << 1U) #define FLAGS_PLUS (1U << 2U) @@ -167,16 +167,16 @@ #define FLAGS_CHAR (1U << 6U) #define FLAGS_SHORT (1U << 7U) #define FLAGS_INT (1U << 8U) - // Only used with PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS + /* Only used with PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS */ #define FLAGS_LONG (1U << 9U) #define FLAGS_LONG_LONG (1U << 10U) #define FLAGS_PRECISION (1U << 11U) #define FLAGS_ADAPT_EXP (1U << 12U) #define FLAGS_POINTER (1U << 13U) - // Note: Similar, but not identical, effect as FLAGS_HASH + /* Note: Similar, but not identical, effect as FLAGS_HASH */ #define FLAGS_SIGNED (1U << 14U) #define FLAGS_LONG_DOUBLE (1U << 15U) - // Only used with PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS + /* Only used with PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS */ #ifdef PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS @@ -219,7 +219,7 @@ #error "No basic integer type has a size of 64 bits exactly" #endif -#endif // PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS +#endif /* PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS */ typedef unsigned int printf_flags_t; @@ -240,18 +240,18 @@ typedef long printf_signed_value_t; #endif /** -// The printf()-family functions return an `int`; it is therefore -// unnecessary/inappropriate to use size_t - often larger than int -// in practice - for non-negative related values, such as widths, -// precisions, offsets into buffers used for printing and the sizes -// of these buffers. instead, we use: + * The printf()-family functions return an `int`; it is therefore + * unnecessary/inappropriate to use size_t - often larger than int + * in practice - for non-negative related values, such as widths, + * precisions, offsets into buffers used for printing and the sizes + * of these buffers. instead, we use: */ typedef unsigned int printf_size_t; #define PRINTF_MAX_POSSIBLE_BUFFER_SIZE INT_MAX /** - // If we were to nitpick, this would actually be INT_MAX + 1, - // since INT_MAX is the maximum return value, which excludes the - // trailing '\0'. + * If we were to nitpick, this would actually be INT_MAX + 1, + * since INT_MAX is the maximum return value, which excludes the + * trailing '\0'. */ #if (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS) @@ -313,11 +313,11 @@ typedef union { } floating_point_with_bit_access; /** -// This is unnecessary in C99, since compound initializers can be used, -// but: -// 1. Some compilers are finicky about this; -// 2. Some people may want to convert this to C89; -// 3. If you try to use it as C++, only C++20 supports compound literals + * This is unnecessary in C99, since compound initializers can be used, + * but: + * 1. Some compilers are finicky about this; + * 2. Some people may want to convert this to C89; + * 3. If you try to use it as C++, only C++20 supports compound literals */ static inline floating_point_with_bit_access get_bit_access(floating_point_t x) { @@ -328,40 +328,40 @@ static inline floating_point_with_bit_access get_bit_access(floating_point_t x) static inline int get_sign_bit(floating_point_t x) { - // The sign is stored in the highest bit + /* The sign is stored in the highest bit */ return (int) (get_bit_access(x).U >> (FP_TYPE_SIZE_IN_BITS - 1)); } static inline int get_exp2(floating_point_with_bit_access x) { /** - // The exponent in an IEEE-754 floating-point number occupies a contiguous - // sequence of bits (e.g. 52..62 for 64-bit doubles), but with a non-trivial representation: An - // unsigned offset from some negative value (with the extremal offset values reserved for - // special use). + * The exponent in an IEEE-754 floating-point number occupies a contiguous + * sequence of bits (e.g. 52..62 for 64-bit doubles), but with a non-trivial representation: An + * unsigned offset from some negative value (with the extremal offset values reserved for + * special use). */ return (int)((x.U >> FP_TYPE_STORED_MANTISSA_BITS ) & FP_TYPE_EXPONENT_MASK) - FP_TYPE_BASE_EXPONENT; } #define PRINTF_ABS(_x) ( (_x) > 0 ? (_x) : -(_x) ) -#endif // (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS) +#endif /* (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS) */ /** -// Note in particular the behavior here on LONG_MIN or LLONG_MIN; it is valid -// and well-defined, but if you're not careful you can easily trigger undefined -// behavior with -LONG_MIN or -LLONG_MIN + * Note in particular the behavior here on LONG_MIN or LLONG_MIN; it is valid + * and well-defined, but if you're not careful you can easily trigger undefined + * behavior with -LONG_MIN or -LLONG_MIN */ #define ABS_FOR_PRINTING(_x) ((printf_unsigned_value_t) ( (_x) > 0 ? (_x) : -((printf_signed_value_t)_x) )) /** -// wrapper (used as buffer) for output function type -// -// One of the following must hold: -// 1. max_chars is 0 -// 2. buffer is non-null -// 3. function is non-null -// -// ... otherwise bad things will happen. + * wrapper (used as buffer) for output function type + * + * One of the following must hold: + * 1. max_chars is 0 + * 2. buffer is non-null + * 3. function is non-null + * + * ... otherwise bad things will happen. */ typedef struct { void (*function)(char c, void* extra_arg); @@ -372,35 +372,35 @@ typedef struct { } output_gadget_t; /** -// Note: This function currently assumes it is not passed a '\0' c, -// or alternatively, that '\0' can be passed to the function in the output -// gadget. The former assumption holds within the printf library. It also -// assumes that the output gadget has been properly initialized. + * Note: This function currently assumes it is not passed a '\0' c, + * or alternatively, that '\0' can be passed to the function in the output + * gadget. The former assumption holds within the printf library. It also + * assumes that the output gadget has been properly initialized. */ static inline void putchar_via_gadget(output_gadget_t* gadget, char c) { printf_size_t write_pos = gadget->pos++; /** - // We're _always_ increasing pos, so as to count how may characters - // _would_ have been written if not for the max_chars limitation + * We're _always_ increasing pos, so as to count how may characters + * _would_ have been written if not for the max_chars limitation */ if (write_pos >= gadget->max_chars) { return; } if (gadget->function != NULL) { - // No check for c == '\0' . + /* No check for c == '\0' . */ gadget->function(c, gadget->extra_function_arg); } else { /** - // it must be the case that gadget->buffer != NULL , due to the constraint - // on output_gadget_t ; and note we're relying on write_pos being non-negative. + * it must be the case that gadget->buffer != NULL , due to the constraint + * on output_gadget_t ; and note we're relying on write_pos being non-negative. */ gadget->buffer[write_pos] = c; } } -// Possibly-write the string-terminating '\0' character +/* Possibly-write the string-terminating '\0' character */ static inline void append_termination_with_gadget(output_gadget_t* gadget) { if (gadget->function != NULL || gadget->max_chars == 0) { @@ -414,8 +414,8 @@ static inline void append_termination_with_gadget(output_gadget_t* gadget) } /** -// We can't use putchar_ as is, since our output gadget -// only takes pointers to functions with an extra argument + * We can't use putchar_ as is, since our output gadget + * only takes pointers to functions with an extra argument */ static inline void putchar_wrapper(char c, void* unused) { @@ -461,10 +461,10 @@ static inline output_gadget_t extern_putchar_gadget(void) } /** -// internal secure strlen -// @return The length of the string (excluding the terminating 0) limited by 'maxsize' -// @note strlen uses size_t, but wes only use this function with printf_size_t -// variables - hence the signature. + * internal secure strlen + * @return The length of the string (excluding the terminating 0) limited by 'maxsize' + * @note strlen uses size_t, but wes only use this function with printf_size_t + * variables - hence the signature. */ static inline printf_size_t strnlen_s_(const char* str, printf_size_t maxsize) { @@ -475,8 +475,8 @@ static inline printf_size_t strnlen_s_(const char* str, printf_size_t maxsize) /** -// internal test if char is a digit (0-9) -// @return true if char is a digit + * internal test if char is a digit (0-9) + * @return true if char is a digit */ static inline bool is_digit_(char ch) { @@ -484,7 +484,7 @@ static inline bool is_digit_(char ch) } -// internal ASCII string to printf_size_t conversion +/* internal ASCII string to printf_size_t conversion */ static printf_size_t atou_(const char** str) { printf_size_t i = 0U; @@ -495,24 +495,24 @@ static printf_size_t atou_(const char** str) } -// output the specified string in reverse, taking care of any zero-padding +/* output the specified string in reverse, taking care of any zero-padding */ static void out_rev_(output_gadget_t* output, const char* buf, printf_size_t len, printf_size_t width, printf_flags_t flags) { const printf_size_t start_pos = output->pos; - // pad spaces up to given width + /* pad spaces up to given width */ if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) { for (printf_size_t i = len; i < width; i++) { putchar_via_gadget(output, ' '); } } - // reverse string + /* reverse string */ while (len) { putchar_via_gadget(output, buf[--len]); } - // append pad spaces up to given width + /* append pad spaces up to given width */ if (flags & FLAGS_LEFT) { while (output->pos - start_pos < width) { putchar_via_gadget(output, ' '); @@ -522,14 +522,14 @@ static void out_rev_(output_gadget_t* output, const char* buf, printf_size_t len /** -// Invoked by print_integer after the actual number has been printed, performing necessary -// work on the number's prefix (as the number is initially printed in reverse order) + * Invoked by print_integer after the actual number has been printed, performing necessary + * work on the number's prefix (as the number is initially printed in reverse order) */ static void print_integer_finalization(output_gadget_t* output, char* buf, printf_size_t len, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags) { printf_size_t unpadded_len = len; - // pad with leading zeros + /* pad with leading zeros */ { if (!(flags & FLAGS_LEFT)) { if (width && (flags & FLAGS_ZEROPAD) && (negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) { @@ -545,23 +545,23 @@ static void print_integer_finalization(output_gadget_t* output, char* buf, print } if (base == BASE_OCTAL && (len > unpadded_len)) { - // Since we've written some zeros, we've satisfied the alternative format leading space requirement + /* Since we've written some zeros, we've satisfied the alternative format leading space requirement */ flags &= ~FLAGS_HASH; } } - // handle hash + /* handle hash */ if (flags & (FLAGS_HASH | FLAGS_POINTER)) { if (!(flags & FLAGS_PRECISION) && len && ((len == precision) || (len == width))) { /** - // Let's take back some padding digits to fit in what will eventually - // be the format-specific prefix + * Let's take back some padding digits to fit in what will eventually + * be the format-specific prefix */ if (unpadded_len < len) { - len--; // This should suffice for BASE_OCTAL + len--; /* This should suffice for BASE_OCTAL */ } if (len && (base == BASE_HEX || base == BASE_BINARY) && (unpadded_len < len)) { - len--; // ... and an extra one for 0x or 0b + len--; /* ... and an extra one for 0x or 0b */ } } if ((base == BASE_HEX) && !(flags & FLAGS_UPPERCASE) && (len < PRINTF_INTEGER_BUFFER_SIZE)) { @@ -583,7 +583,7 @@ static void print_integer_finalization(output_gadget_t* output, char* buf, print buf[len++] = '-'; } else if (flags & FLAGS_PLUS) { - buf[len++] = '+'; // ignore the space if the '+' exists + buf[len++] = '+'; /* ignore the space if the '+' exists */ } else if (flags & FLAGS_SPACE) { buf[len++] = ' '; @@ -593,7 +593,7 @@ static void print_integer_finalization(output_gadget_t* output, char* buf, print out_rev_(output, buf, len, width, flags); } -// An internal itoa-like function +/* An internal itoa-like function */ static void print_integer(output_gadget_t* output, printf_unsigned_value_t value, bool negative, numeric_base_t base, printf_size_t precision, printf_size_t width, printf_flags_t flags) { char buf[PRINTF_INTEGER_BUFFER_SIZE]; @@ -604,16 +604,16 @@ static void print_integer(output_gadget_t* output, printf_unsigned_value_t value buf[len++] = '0'; flags &= ~FLAGS_HASH; /** - // We drop this flag this since either the alternative and regular modes of the specifier - // don't differ on 0 values, or (in the case of octal) we've already provided the special - // handling for this mode. + * We drop this flag this since either the alternative and regular modes of the specifier + * don't differ on 0 values, or (in the case of octal) we've already provided the special + * handling for this mode. */ } else if (base == BASE_HEX) { flags &= ~FLAGS_HASH; /** - // We drop this flag this since either the alternative and regular modes of the specifier - // don't differ on 0 values + * We drop this flag this since either the alternative and regular modes of the specifier + * don't differ on 0 values */ } } @@ -631,15 +631,15 @@ static void print_integer(output_gadget_t* output, printf_unsigned_value_t value #if (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS) /** -// Stores a fixed-precision representation of a floating-point number relative -// to a fixed precision (which cannot be determined by examining this structure) + * Stores a fixed-precision representation of a floating-point number relative + * to a fixed precision (which cannot be determined by examining this structure) */ struct floating_point_components { int_fast64_t integral; int_fast64_t fractional; /** - // ... truncation of the actual fractional part of the floating_point_t value, scaled - // by the precision value + * ... truncation of the actual fractional part of the floating_point_t value, scaled + * by the precision value */ bool is_negative; }; @@ -652,17 +652,17 @@ static const floating_point_t powers_of_10[PRINTF_MAX_PRECOMPUTED_POWER_OF_10 + }; /** -// Note: This value does not mean that all floating-point values printed with the -// library will be correct up to this precision; it is just an upper-bound for -// avoiding buffer overruns and such + * Note: This value does not mean that all floating-point values printed with the + * library will be correct up to this precision; it is just an upper-bound for + * avoiding buffer overruns and such */ #define PRINTF_MAX_SUPPORTED_PRECISION (NUM_DECIMAL_DIGITS_IN_INT64_T - 1) /** -// Break up a floating-point number - which is known to be a finite non-negative number - -// into its base-10 parts: integral - before the decimal point, and fractional - after it. -// Taken the precision into account, but does not change it even internally. + * Break up a floating-point number - which is known to be a finite non-negative number - + * into its base-10 parts: integral - before the decimal point, and fractional - after it. + * Taken the precision into account, but does not change it even internally. */ static struct floating_point_components get_components(floating_point_t number, printf_size_t precision) { @@ -671,14 +671,14 @@ static struct floating_point_components get_components(floating_point_t number, floating_point_t abs_number = (number_.is_negative) ? -number : number; number_.integral = (int_fast64_t) abs_number; floating_point_t scaled_remainder = (abs_number - (floating_point_t) number_.integral) * powers_of_10[precision]; - number_.fractional = (int_fast64_t) scaled_remainder; // for precision == 0U, this will be 0 + number_.fractional = (int_fast64_t) scaled_remainder; /* for precision == 0U, this will be 0 */ floating_point_t remainder = scaled_remainder - (floating_point_t) number_.fractional; const floating_point_t one_half = (floating_point_t) 0.5; if (remainder > one_half) { ++number_.fractional; - // handle rollover, e.g. case 0.99 with precision 1 is 1.0 + /* handle rollover, e.g. case 0.99 with precision 1 is 1.0 */ if ((floating_point_t) number_.fractional >= powers_of_10[precision]) { number_.fractional = 0; ++number_.integral; @@ -686,8 +686,8 @@ static struct floating_point_components get_components(floating_point_t number, } else if ((remainder == one_half) && (number_.fractional & 1U)) { /** - // Banker's rounding, i.e. round half to even: - // 1.5 -> 2, but 2.5 -> 2 + * Banker's rounding, i.e. round half to even: + * 1.5 -> 2, but 2.5 -> 2 */ ++number_.fractional; } @@ -696,8 +696,8 @@ static struct floating_point_components get_components(floating_point_t number, remainder = abs_number - (floating_point_t) number_.integral; if ((remainder == one_half) && (number_.integral & 1U)) { /** - // Banker's rounding, i.e. round half to even: - // 1.5 -> 2, but 2.5 -> 2 + * Banker's rounding, i.e. round half to even: + * 1.5 -> 2, but 2.5 -> 2 */ ++number_.integral; } @@ -708,7 +708,7 @@ static struct floating_point_components get_components(floating_point_t number, #if PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS struct scaling_factor { floating_point_t raw_factor; - bool multiply; // if true, need to multiply by raw_factor; otherwise need to divide by it + bool multiply; /* if true, need to multiply by raw_factor; otherwise need to divide by it */ }; static floating_point_t apply_scaling(floating_point_t num, struct scaling_factor normalization) @@ -719,7 +719,7 @@ static floating_point_t apply_scaling(floating_point_t num, struct scaling_facto static floating_point_t unapply_scaling(floating_point_t normalized, struct scaling_factor normalization) { #ifdef __GNUC__ -// accounting for a static analysis bug in GCC 6.x and earlier +/* accounting for a static analysis bug in GCC 6.x and earlier */ #pragma GCC diagnostic push #if !defined(__has_warning) #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" @@ -744,7 +744,7 @@ static struct scaling_factor update_normalization(struct scaling_factor sf, floa int factor_exp2 = get_exp2(get_bit_access(sf.raw_factor)); int extra_factor_exp2 = get_exp2(get_bit_access(extra_multiplicative_factor)); - // Divide the larger-exponent raw raw_factor by the smaller + /* Divide the larger-exponent raw raw_factor by the smaller */ if (PRINTF_ABS(factor_exp2) > PRINTF_ABS(extra_factor_exp2)) { result.multiply = false; result.raw_factor = sf.raw_factor / extra_multiplicative_factor; @@ -766,9 +766,9 @@ static struct floating_point_components get_normalized_components(bool negative, bool close_to_representation_extremum = ( (-floored_exp10 + (int) precision) >= FP_TYPE_MAX_10_EXP - 1 ); if (close_to_representation_extremum) { /** - // We can't have a normalization factor which also accounts for the precision, i.e. moves - // some decimal digits into the mantissa, since it's unrepresentable, or nearly unrepresentable. - // So, we'll give up early on getting extra precision... + * We can't have a normalization factor which also accounts for the precision, i.e. moves + * some decimal digits into the mantissa, since it's unrepresentable, or nearly unrepresentable. + * So, we'll give up early on getting extra precision... */ return get_components(negative ? -scaled : scaled, precision); } @@ -779,20 +779,20 @@ static struct floating_point_components get_normalized_components(bool negative, floating_point_t scaled_remainder = apply_scaling(remainder, account_for_precision); floating_point_t rounding_threshold = 0.5; - components.fractional = (int_fast64_t) scaled_remainder; // when precision == 0, the assigned value should be 0 - scaled_remainder -= (floating_point_t) components.fractional; //when precision == 0, this will not change scaled_remainder + components.fractional = (int_fast64_t) scaled_remainder; /* when precision == 0, the assigned value should be 0 */ + scaled_remainder -= (floating_point_t) components.fractional; /* when precision == 0, this will not change scaled_remainder */ components.fractional += (scaled_remainder >= rounding_threshold); if (scaled_remainder == rounding_threshold) { - // banker's rounding: Round towards the even number (making the mean error 0) + /* banker's rounding: Round towards the even number (making the mean error 0) */ components.fractional &= ~((int_fast64_t) 0x1); } /** - // handle rollover, e.g. the case of 0.99 with precision 1 becoming (0,100), - // and must then be corrected into (1, 0). - // Note: for precision = 0, this will "translate" the rounding effect from - // the fractional part to the integral part where it should actually be - // felt (as prec_power_of_10 is 1) + * handle rollover, e.g. the case of 0.99 with precision 1 becoming (0,100), + * and must then be corrected into (1, 0). + * Note: for precision = 0, this will "translate" the rounding effect from + * the fractional part to the integral part where it should actually be + * felt (as prec_power_of_10 is 1) */ if ((floating_point_t) components.fractional >= prec_power_of_10) { components.fractional = 0; @@ -800,18 +800,18 @@ static struct floating_point_components get_normalized_components(bool negative, } return components; } -#endif // PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS +#endif /* PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS */ static void print_broken_up_decimal( struct floating_point_components number_, output_gadget_t* output, printf_size_t precision, printf_size_t width, printf_flags_t flags, char *buf, printf_size_t len) { if (precision != 0U) { - // do fractional part, as an unsigned number + /* do fractional part, as an unsigned number */ printf_size_t count = precision; - // %g/%G mandates we skip the trailing 0 digits... + /* %g/%G mandates we skip the trailing 0 digits... */ if ((flags & FLAGS_ADAPT_EXP) && !(flags & FLAGS_HASH) && (number_.fractional > 0)) { while(true) { int_fast64_t digit = number_.fractional % 10U; @@ -823,8 +823,8 @@ static void print_broken_up_decimal( } /** - // ... and even the decimal point if there are no - // non-zero fractional part digits (see below) + * ... and even the decimal point if there are no + * non-zero fractional part digits (see below) */ } @@ -836,7 +836,7 @@ static void print_broken_up_decimal( break; } } - // add extra 0s + /* add extra 0s */ while ((len < PRINTF_DECIMAL_BUFFER_SIZE) && (count > 0U)) { buf[len++] = '0'; --count; @@ -853,8 +853,8 @@ static void print_broken_up_decimal( } /** - // Write the integer part of the number (it comes after the fractional - // since the character order is reversed) + * Write the integer part of the number (it comes after the fractional + * since the character order is reversed) */ while (len < PRINTF_DECIMAL_BUFFER_SIZE) { buf[len++] = (char)('0' + (number_.integral % 10)); @@ -863,7 +863,7 @@ static void print_broken_up_decimal( } } - // pad leading zeros + /* pad leading zeros */ if (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD)) { if (width && (number_.is_negative || (flags & (FLAGS_PLUS | FLAGS_SPACE)))) { width--; @@ -878,7 +878,7 @@ static void print_broken_up_decimal( buf[len++] = '-'; } else if (flags & FLAGS_PLUS) { - buf[len++] = '+'; // ignore the space if the '+' exists + buf[len++] = '+'; /* ignore the space if the '+' exists */ } else if (flags & FLAGS_SPACE) { buf[len++] = ' '; @@ -888,7 +888,7 @@ static void print_broken_up_decimal( out_rev_(output, buf, len, width, flags); } -// internal ftoa for fixed decimal floating point +/* internal ftoa for fixed decimal floating point */ static void print_decimal_number(output_gadget_t* output, floating_point_t number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char* buf, printf_size_t len) { struct floating_point_components value_ = get_components(number, precision); @@ -898,8 +898,8 @@ static void print_decimal_number(output_gadget_t* output, floating_point_t numbe #if PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS /** -// A floor function - but one which only works for numbers whose -// floor value is representable by an int. + * A floor function - but one which only works for numbers whose + * floor value is representable by an int. */ static int bastardized_floor(floating_point_t x) { @@ -909,59 +909,59 @@ static int bastardized_floor(floating_point_t x) } /** -// Computes the base-10 logarithm of the input number - which must be an actual -// positive number (not infinity or NaN, nor a sub-normal) + * Computes the base-10 logarithm of the input number - which must be an actual + * positive number (not infinity or NaN, nor a sub-normal) */ static floating_point_t log10_of_positive(floating_point_t positive_number) { /** - // The implementation follows David Gay (https://www.ampl.com/netlib/fp/dtoa.c). - // - // Since log_10 ( M * 2^x ) = log_10(M) + x , we can separate the components of - // our input number, and need only solve log_10(M) for M between 1 and 2 (as - // the base-2 mantissa is always 1-point-something). In that limited range, a - // Taylor series expansion of log10(x) should serve us well enough; and we'll - // take the mid-point, 1.5, as the point of expansion. + * The implementation follows David Gay (https://www.ampl.com/netlib/fp/dtoa.c). + * + * Since log_10 ( M * 2^x ) = log_10(M) + x , we can separate the components of + * our input number, and need only solve log_10(M) for M between 1 and 2 (as + * the base-2 mantissa is always 1-point-something). In that limited range, a + * Taylor series expansion of log10(x) should serve us well enough; and we'll + * take the mid-point, 1.5, as the point of expansion. */ floating_point_with_bit_access dwba = get_bit_access(positive_number); - // based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c) + /* based on the algorithm by David Gay (https://www.ampl.com/netlib/fp/dtoa.c) */ int exp2 = get_exp2(dwba); - // drop the exponent, so dwba.F comes into the range [1,2) + /* drop the exponent, so dwba.F comes into the range [1,2) */ dwba.U = (dwba.U & (((printf_fp_uint_t) (1) << FP_TYPE_STORED_MANTISSA_BITS) - 1U)) | ((printf_fp_uint_t) FP_TYPE_BASE_EXPONENT << FP_TYPE_STORED_MANTISSA_BITS); floating_point_t z = (dwba.F - (floating_point_t) 1.5); return ( - // Taylor expansion around 1.5: - (floating_point_t) 0.1760912590556812420 // Expansion term 0: ln(1.5) / ln(10) - + z * (floating_point_t) 0.2895296546021678851 // Expansion term 1: (M - 1.5) * 2/3 / ln(10) + /* Taylor expansion around 1.5: */ + (floating_point_t) 0.1760912590556812420 /* Expansion term 0: ln(1.5) / ln(10) */ + + z * (floating_point_t) 0.2895296546021678851 /* Expansion term 1: (M - 1.5) * 2/3 / ln(10) */ #if PRINTF_LOG10_TAYLOR_TERMS > 2 - - z*z * (floating_point_t) 0.0965098848673892950 // Expansion term 2: (M - 1.5)^2 * 2/9 / ln(10) + - z*z * (floating_point_t) 0.0965098848673892950 /* Expansion term 2: (M - 1.5)^2 * 2/9 / ln(10) */ #if PRINTF_LOG10_TAYLOR_TERMS > 3 - + z*z*z * (floating_point_t) 0.0428932821632841311 // Expansion term 2: (M - 1.5)^3 * 8/81 / ln(10) + + z*z*z * (floating_point_t) 0.0428932821632841311 /* Expansion term 2: (M - 1.5)^3 * 8/81 / ln(10) */ #endif #endif - // exact log_2 of the exponent x, with logarithm base change - + (floating_point_t) exp2 * (floating_point_t) 0.30102999566398119521 // = exp2 * log_10(2) = exp2 * ln(2)/ln(10) + /* exact log_2 of the exponent x, with logarithm base change */ + + (floating_point_t) exp2 * (floating_point_t) 0.30102999566398119521 /* = exp2 * log_10(2) = exp2 * ln(2)/ln(10) */ ); } static floating_point_t pow10_of_int(int floored_exp10) { - // A crude hack for avoiding undesired behavior with barely-normal or slightly-subnormal values. + /* A crude hack for avoiding undesired behavior with barely-normal or slightly-subnormal values. */ if (floored_exp10 == FP_TYPE_MAX_SUBNORMAL_EXPONENT_OF_10) { return FP_TYPE_MAX_SUBNORMAL_POWER_OF_10; } - // Compute 10^(floored_exp10) but (try to) make sure that doesn't overflow + /* Compute 10^(floored_exp10) but (try to) make sure that doesn't overflow */ floating_point_with_bit_access dwba; int exp2 = bastardized_floor((floating_point_t) (floored_exp10 * 3.321928094887362 + 0.5)); const floating_point_t z = (floating_point_t) (floored_exp10 * 2.302585092994046 - exp2 * 0.6931471805599453); const floating_point_t z2 = z * z; dwba.U = ((printf_fp_uint_t)(exp2) + FP_TYPE_BASE_EXPONENT) << FP_TYPE_STORED_MANTISSA_BITS; /** - // compute exp(z) using continued fractions, - // see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex + * compute exp(z) using continued fractions, + * see https://en.wikipedia.org/wiki/Exponential_function#Continued_fractions_for_ex */ dwba.F *= 1 + 2 * z / (2 - z + (z2 / (6 + (z2 / (10 + z2 / 14))))); return dwba.F; @@ -970,7 +970,7 @@ static floating_point_t pow10_of_int(int floored_exp10) static void print_exponential_number(output_gadget_t* output, floating_point_t number, printf_size_t precision, printf_size_t width, printf_flags_t flags, char* buf, printf_size_t len) { const bool negative = get_sign_bit(number); - // This number will decrease gradually (by factors of 10) as we "extract" the exponent out of it + /* This number will decrease gradually (by factors of 10) as we "extract" the exponent out of it */ floating_point_t abs_number = negative ? -number : number; int floored_exp10; @@ -978,16 +978,16 @@ static void print_exponential_number(output_gadget_t* output, floating_point_t n struct scaling_factor normalization; - // Determine the decimal exponent + /* Determine the decimal exponent */ if (abs_number == (floating_point_t) 0.0) { - // TODO: This is a special-case for 0.0 (and -0.0); but proper handling is required for denormals more generally. - floored_exp10 = 0; // ... and no need to set a normalization factor or check the powers table + /* TODO: This is a special-case for 0.0 (and -0.0); but proper handling is required for denormals more generally. */ + floored_exp10 = 0; /* ... and no need to set a normalization factor or check the powers table */ } else { floating_point_t exp10 = log10_of_positive(abs_number); floored_exp10 = bastardized_floor(exp10); floating_point_t p10 = pow10_of_int(floored_exp10); - // correct for rounding errors + /* correct for rounding errors */ if (abs_number < p10) { floored_exp10--; p10 /= 10; @@ -997,33 +997,33 @@ static void print_exponential_number(output_gadget_t* output, floating_point_t n } /** - // We now begin accounting for the widths of the two parts of our printed field: - // the decimal part after decimal exponent extraction, and the base-10 exponent part. - // For both of these, the value of 0 has a special meaning, but not the same one: - // a 0 exponent-part width means "don't print the exponent"; a 0 decimal-part width - // means "use as many characters as necessary". + * We now begin accounting for the widths of the two parts of our printed field: + * the decimal part after decimal exponent extraction, and the base-10 exponent part. + * For both of these, the value of 0 has a special meaning, but not the same one: + * a 0 exponent-part width means "don't print the exponent"; a 0 decimal-part width + * means "use as many characters as necessary". */ bool fall_back_to_decimal_only_mode = false; if (flags & FLAGS_ADAPT_EXP) { int required_significant_digits = (precision == 0) ? 1 : (int) precision; - // Should we want to fall-back to "%f" mode, and only print the decimal part? + /* Should we want to fall-back to "%f" mode, and only print the decimal part? */ fall_back_to_decimal_only_mode = (floored_exp10 >= -4 && floored_exp10 < required_significant_digits); /** - // Now, let's adjust the precision - // This also decided how we adjust the precision value - as in "%g" mode, - // "precision" is the number of _significant digits_, and this is when we "translate" - // the precision value to an actual number of decimal digits. + * Now, let's adjust the precision + * This also decided how we adjust the precision value - as in "%g" mode, + * "precision" is the number of _significant digits_, and this is when we "translate" + * the precision value to an actual number of decimal digits. */ int precision_ = fall_back_to_decimal_only_mode ? (int) precision - 1 - floored_exp10 : - (int) precision - 1; // the presence of the exponent ensures only one significant digit comes before the decimal point + (int) precision - 1; /* the presence of the exponent ensures only one significant digit comes before the decimal point */ precision = (precision_ > 0 ? (unsigned) precision_ : 0U); - flags |= FLAGS_PRECISION; // make sure print_broken_up_decimal respects our choice above + flags |= FLAGS_PRECISION; /* make sure print_broken_up_decimal respects our choice above */ } #ifdef __GNUC__ -// accounting for a static analysis bug in GCC 6.x and earlier +/* accounting for a static analysis bug in GCC 6.x and earlier */ #pragma GCC diagnostic push #if !defined(__has_warning) #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" @@ -1042,16 +1042,16 @@ static void print_exponential_number(output_gadget_t* output, floating_point_t n get_normalized_components(negative, precision, abs_number, normalization, floored_exp10); /** - // Account for roll-over, e.g. rounding from 9.99 to 100.0 - which effects - // the exponent and may require additional tweaking of the parts + * Account for roll-over, e.g. rounding from 9.99 to 100.0 - which effects + * the exponent and may require additional tweaking of the parts */ if (fall_back_to_decimal_only_mode) { if ((flags & FLAGS_ADAPT_EXP) && floored_exp10 >= -1 && decimal_part_components.integral == powers_of_10[floored_exp10 + 1]) { - floored_exp10++; // Not strictly necessary, since floored_exp10 is no longer really used + floored_exp10++; /* Not strictly necessary, since floored_exp10 is no longer really used */ if (precision > 0U) { precision--; } - // ... and it should already be the case that decimal_part_components.fractional == 0 + /* ... and it should already be the case that decimal_part_components.fractional == 0 */ } - // TODO: What about rollover strictly within the fractional part? + /* TODO: What about rollover strictly within the fractional part? */ } else { if (decimal_part_components.integral >= 10) { @@ -1062,31 +1062,31 @@ static void print_exponential_number(output_gadget_t* output, floating_point_t n } /** - // the floored_exp10 format is "E%+03d" and largest possible floored_exp10 value for a 64-bit double - // is "307" (for 2^1023), so we set aside 4-5 characters overall + * the floored_exp10 format is "E%+03d" and largest possible floored_exp10 value for a 64-bit double + * is "307" (for 2^1023), so we set aside 4-5 characters overall */ printf_size_t exp10_part_width = fall_back_to_decimal_only_mode ? 0U : (PRINTF_ABS(floored_exp10) < 100) ? 4U : 5U; printf_size_t decimal_part_width = ((flags & FLAGS_LEFT) && exp10_part_width) ? /** - // We're padding on the right, so the width constraint is the exponent part's - // problem, not the decimal part's, so we'll use as many characters as we need: + * We're padding on the right, so the width constraint is the exponent part's + * problem, not the decimal part's, so we'll use as many characters as we need: */ 0U : /** - // We're padding on the left; so the width constraint is the decimal part's - // problem. Well, can both the decimal part and the exponent part fit within our overall width? + * We're padding on the left; so the width constraint is the decimal part's + * problem. Well, can both the decimal part and the exponent part fit within our overall width? */ ((width > exp10_part_width) ? /** - // Yes, so we limit our decimal part's width. - // (Note this is trivially valid even if we've fallen back to "%f" mode) + * Yes, so we limit our decimal part's width. + * (Note this is trivially valid even if we've fallen back to "%f" mode) */ width - exp10_part_width : /** - // No; we just give up on any restriction on the decimal part and use as many - // characters as we need + * No; we just give up on any restriction on the decimal part and use as many + * characters as we need */ 0U); @@ -1100,21 +1100,21 @@ static void print_exponential_number(output_gadget_t* output, floating_point_t n floored_exp10 < 0, 10, 0, exp10_part_width - 1, FLAGS_ZEROPAD | FLAGS_PLUS); if (flags & FLAGS_LEFT) { - // We need to right-pad with spaces to meet the width requirement + /* We need to right-pad with spaces to meet the width requirement */ while (output->pos - printed_exponential_start_pos < width) { putchar_via_gadget(output, ' '); } } } } -#endif // PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS +#endif /* PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS */ static void print_floating_point(output_gadget_t* output, floating_point_t value, printf_size_t precision, printf_size_t width, printf_flags_t flags, bool prefer_exponential) { char buf[PRINTF_DECIMAL_BUFFER_SIZE]; printf_size_t len = 0U; - // test for special values + /* test for special values */ if (value != value) { out_rev_(output, "nan", 3, width, flags); return; @@ -1131,9 +1131,9 @@ static void print_floating_point(output_gadget_t* output, floating_point_t value if (!prefer_exponential && ((value > PRINTF_FLOAT_NOTATION_THRESHOLD) || (value < -PRINTF_FLOAT_NOTATION_THRESHOLD))) { /** - // The required behavior of standard printf is to print _every_ integral-part digit -- which could mean - // printing hundreds of characters, overflowing any fixed internal buffer and necessitating a more complicated - // implementation. + * The required behavior of standard printf is to print _every_ integral-part digit -- which could mean + * printing hundreds of characters, overflowing any fixed internal buffer and necessitating a more complicated + * implementation. */ #if PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS print_exponential_number(output, value, precision, width, flags, buf, len); @@ -1141,14 +1141,14 @@ static void print_floating_point(output_gadget_t* output, floating_point_t value return; } - // set default precision, if not set explicitly + /* set default precision, if not set explicitly */ if (!(flags & FLAGS_PRECISION)) { precision = PRINTF_DEFAULT_FLOAT_PRECISION; } - // limit precision so that our integer holding the fractional part does not overflow + /* limit precision so that our integer holding the fractional part does not overflow */ while ((len < PRINTF_DECIMAL_BUFFER_SIZE) && (precision > PRINTF_MAX_SUPPORTED_PRECISION)) { - buf[len++] = '0'; // This respects the precision in terms of result length only + buf[len++] = '0'; /* This respects the precision in terms of result length only */ precision--; } @@ -1160,11 +1160,11 @@ static void print_floating_point(output_gadget_t* output, floating_point_t value print_decimal_number(output, value, precision, width, flags, buf, len); } -#endif // (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS) +#endif /* (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS) */ /** -// Advances the format pointer past the flags, and returns the parsed flags -// due to the characters passed + * Advances the format pointer past the flags, and returns the parsed flags + * due to the characters passed */ static printf_flags_t parse_flags(const char** format) { @@ -1193,17 +1193,17 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma while (*format) { if (*format != '%') { - // A regular content character + /* A regular content character */ putchar_via_gadget(output, *format); format++; continue; } - // We're parsing a format specifier: %[flags][width][.precision][length] + /* We're parsing a format specifier: %[flags][width][.precision][length] */ ADVANCE_IN_FORMAT_STRING(format); printf_flags_t flags = parse_flags(&format); - // evaluate width field + /* evaluate width field */ printf_size_t width = 0U; if (is_digit_(*format)) { width = (printf_size_t) atou_(&format); @@ -1211,7 +1211,7 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma else if (*format == '*') { const int w = va_arg(args, int); if (w < 0) { - flags |= FLAGS_LEFT; // reverse padding + flags |= FLAGS_LEFT; /* reverse padding */ width = (printf_size_t)-w; } else { @@ -1220,7 +1220,7 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma ADVANCE_IN_FORMAT_STRING(format); } - // evaluate precision field + /* evaluate precision field */ printf_size_t precision = 0U; if (*format == '.') { flags |= FLAGS_PRECISION; @@ -1235,12 +1235,12 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma } } - // evaluate length field + /* evaluate length field */ switch (*format) { #ifdef PRINTF_SUPPORT_MSVC_STYLE_INTEGER_SPECIFIERS case 'I' : { ADVANCE_IN_FORMAT_STRING(format); - // Greedily parse for size in bits: 8, 16, 32 or 64 + /* Greedily parse for size in bits: 8, 16, 32 or 64 */ switch(*format) { case '8': flags |= FLAGS_INT8; ADVANCE_IN_FORMAT_STRING(format); @@ -1298,7 +1298,7 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma break; } - // evaluate specifier + /* evaluate specifier */ switch (*format) { case 'd' : case 'i' : @@ -1324,7 +1324,7 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma } else { base = BASE_DECIMAL; - flags &= ~FLAGS_HASH; // decimal integers have no alternative presentation + flags &= ~FLAGS_HASH; /* decimal integers have no alternative presentation */ } if (*format == 'X') { @@ -1332,13 +1332,13 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma } format++; - // ignore '0' flag when precision is given + /* ignore '0' flag when precision is given */ if (flags & FLAGS_PRECISION) { flags &= ~FLAGS_ZEROPAD; } if (flags & FLAGS_SIGNED) { - // A signed specifier: d, i or possibly I + bit size if enabled + /* A signed specifier: d, i or possibly I + bit size if enabled */ if (flags & FLAGS_LONG_LONG) { #if PRINTF_SUPPORT_LONG_LONG @@ -1352,10 +1352,10 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma } else { /** - // We never try to interpret the argument as something potentially-smaller than int, - // due to integer promotion rules: Even if the user passed a short int, short unsigned - // etc. - these will come in after promotion, as int's (or unsigned for the case of - // short unsigned when it has the same size as int) + * We never try to interpret the argument as something potentially-smaller than int, + * due to integer promotion rules: Even if the user passed a short int, short unsigned + * etc. - these will come in after promotion, as int's (or unsigned for the case of + * short unsigned when it has the same size as int) */ const int value = (flags & FLAGS_CHAR) ? (signed char) va_arg(args, int) : @@ -1365,7 +1365,7 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma } } else { - // An unsigned specifier: u, x, X, o, b + /* An unsigned specifier: u, x, X, o, b */ flags &= ~(FLAGS_PLUS | FLAGS_SPACE); @@ -1409,18 +1409,18 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma format++; break; } -#endif // PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS +#endif /* PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS */ case 'c' : { printf_size_t l = 1U; - // pre padding + /* pre padding */ if (!(flags & FLAGS_LEFT)) { while (l++ < width) { putchar_via_gadget(output, ' '); } } - // char output + /* char output */ putchar_via_gadget(output, (char) va_arg(args, int) ); - // post padding + /* post padding */ if (flags & FLAGS_LEFT) { while (l++ < width) { putchar_via_gadget(output, ' '); @@ -1437,7 +1437,7 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma } else { printf_size_t l = strnlen_s_(p, precision ? precision : PRINTF_MAX_POSSIBLE_BUFFER_SIZE); - // pre padding + /* pre padding */ if (flags & FLAGS_PRECISION) { l = (l < precision ? l : precision); } @@ -1446,12 +1446,12 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma putchar_via_gadget(output, ' '); } } - // string output + /* string output */ while ((*p != 0) && (!(flags & FLAGS_PRECISION) || precision)) { putchar_via_gadget(output, *(p++)); --precision; } - // post padding + /* post padding */ if (flags & FLAGS_LEFT) { while (l++ < width) { putchar_via_gadget(output, ' '); @@ -1463,7 +1463,7 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma } case 'p' : { - width = sizeof(void*) * 2U + 2; // 2 hex chars per byte + the "0x" prefix + width = sizeof(void*) * 2U + 2; /* 2 hex chars per byte + the "0x" prefix */ flags |= FLAGS_ZEROPAD | FLAGS_POINTER; uintptr_t value = (uintptr_t)va_arg(args, void*); (value == (uintptr_t) NULL) ? @@ -1479,9 +1479,9 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma break; /** - // Many people prefer to disable support for %n, as it lets the caller - // engineer a write to an arbitrary location, of a value the caller - // effectively controls - which could be a security concern in some cases. + * Many people prefer to disable support for %n, as it lets the caller + * engineer a write to an arbitrary location, of a value the caller + * effectively controls - which could be a security concern in some cases. */ #if PRINTF_SUPPORT_WRITEBACK_SPECIFIER case 'n' : { @@ -1490,12 +1490,12 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma else if (flags & FLAGS_LONG) *(va_arg(args, long*)) = (long) output->pos; #if PRINTF_SUPPORT_LONG_LONG else if (flags & FLAGS_LONG_LONG) *(va_arg(args, long long*)) = (long long int) output->pos; -#endif // PRINTF_SUPPORT_LONG_LONG +#endif /* PRINTF_SUPPORT_LONG_LONG */ else *(va_arg(args, int*)) = (int) output->pos; format++; break; } -#endif // PRINTF_SUPPORT_WRITEBACK_SPECIFIER +#endif /* PRINTF_SUPPORT_WRITEBACK_SPECIFIER */ default : putchar_via_gadget(output, *format); @@ -1505,23 +1505,23 @@ static inline void format_string_loop(output_gadget_t* output, const char* forma } } -// internal vsnprintf - used for implementing _all library functions +/* internal vsnprintf - used for implementing _all library functions */ static int vsnprintf_impl(output_gadget_t* output, const char* format, va_list args) { /** - // Note: The library only calls vsnprintf_impl() with output->pos being 0. However, it is - // possible to call this function with a non-zero pos value for some "remedial printing". + * Note: The library only calls vsnprintf_impl() with output->pos being 0. However, it is + * possible to call this function with a non-zero pos value for some "remedial printing". */ format_string_loop(output, format, args); - // termination + /* termination */ append_termination_with_gadget(output); - // return written chars without terminating \0 + /* return written chars without terminating \0 */ return (int)output->pos; } -/////////////////////////////////////////////////////////////////////////////// +/*====================================================================================*/ int vprintf_(const char* format, va_list arg) { diff --git a/src/printf/printf.h b/src/printf/printf.h index eb58961..491a593 100644 --- a/src/printf/printf.h +++ b/src/printf/printf.h @@ -81,10 +81,10 @@ ATTR_PRINTF((one_based_format_index), 0) #endif /** -// If you want to include this implementation file directly rather than -// link against it, this will let you control the functions' visibility, -// e.g. make them static so as not to clash with other objects also -// using them. + * If you want to include this implementation file directly rather than + * link against it, this will let you control the functions' visibility, + * e.g. make them static so as not to clash with other objects also + * using them. */ #ifndef PRINTF_VISIBILITY #define PRINTF_VISIBILITY @@ -131,12 +131,12 @@ void putchar_(char c); * @return The number of characters written into @p s, not counting the * terminating null character */ - ///@{ +/*@{*/ PRINTF_VISIBILITY int printf_(const char* format, ...) ATTR_PRINTF(1, 2); PRINTF_VISIBILITY int vprintf_(const char* format, va_list arg) ATTR_VPRINTF(1); -///@} +/*@}*/ /** @@ -155,12 +155,12 @@ int vprintf_(const char* format, va_list arg) ATTR_VPRINTF(1); * @return The number of characters written into @p s, not counting the * terminating null character */ -///@{ +/*@{*/ PRINTF_VISIBILITY int sprintf_(char* s, const char* format, ...) ATTR_PRINTF(2, 3); PRINTF_VISIBILITY int vsprintf_(char* s, const char* format, va_list arg) ATTR_VPRINTF(2); -///@} +/*@}*/ /** @@ -183,12 +183,12 @@ int vsprintf_(char* s, const char* format, va_list arg) ATTR_VPRINTF(2); * and less than @p n, the null-terminated string has been fully and * successfully printed. */ -///@{ +/*@{*/ PRINTF_VISIBILITY int snprintf_(char* s, size_t count, const char* format, ...) ATTR_PRINTF(3, 4); PRINTF_VISIBILITY int vsnprintf_(char* s, size_t count, const char* format, va_list arg) ATTR_VPRINTF(3); -///@} +/*@}*/ /** * printf/vprintf with user-specified output function @@ -214,7 +214,7 @@ PRINTF_VISIBILITY int vfctprintf(void (*out)(char c, void* extra_arg), void* extra_arg, const char* format, va_list arg) ATTR_VPRINTF(3); #ifdef __cplusplus -} // extern "C" +} /* extern "C" */ #endif #if PRINTF_ALIAS_STANDARD_FUNCTION_NAMES_HARD @@ -235,4 +235,4 @@ int vfctprintf(void (*out)(char c, void* extra_arg), void* extra_arg, const char #endif #endif -#endif // PRINTF_H_ +#endif /* PRINTF_H_ */ From b54fa49be00ae247fd3fdcc84a62563eaa8dfc97 Mon Sep 17 00:00:00 2001 From: Yonggang Luo Date: Sat, 16 Dec 2023 02:39:25 +0800 Subject: [PATCH 3/5] Convert printf_config.h.in use block comment Signed-off-by: Yonggang Luo --- printf_config.h.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/printf_config.h.in b/printf_config.h.in index 702d9de..e14e8c3 100644 --- a/printf_config.h.in +++ b/printf_config.h.in @@ -18,5 +18,5 @@ #define PRINTF_LOG10_TAYLOR_TERMS @LOG10_TAYLOR_TERMS@ #define PRINTF_CHECK_FOR_NUL_IN_FORMAT_SPECIFIER @PRINTF_CHECK_FOR_NUL_IN_FORMAT_SPECIFIER@ -#endif // PRINTF_CONFIG_H_ +#endif /* PRINTF_CONFIG_H_ */ From 657338aa56808a4bf7e702ae0f35aa9c78841d16 Mon Sep 17 00:00:00 2001 From: Yonggang Luo Date: Sat, 16 Dec 2023 02:38:26 +0800 Subject: [PATCH 4/5] always enable -ansi option Signed-off-by: Yonggang Luo --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 2782631..19f7d34 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -109,7 +109,7 @@ if (CMAKE_C_COMPILER_ID STREQUAL "MSVC") target_compile_options(printf PRIVATE /W4) elseif (CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "Clang") - target_compile_options(printf PRIVATE -Wall -Wextra -pedantic -Wconversion) + target_compile_options(printf PRIVATE -Wall -Wextra -pedantic -Wconversion -ansi) if (ALIAS_STANDARD_FUNCTION_NAMES) # This is important for preventing our aliased implementation # from being replaced, e.g. printf("%c", 'a') by putchar('a'); From 5a555609c86844fa2886e21fc8eef26832a34dd8 Mon Sep 17 00:00:00 2001 From: Yonggang Luo Date: Sat, 16 Dec 2023 02:40:41 +0800 Subject: [PATCH 5/5] testing double comment --- src/printf/printf.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/printf/printf.c b/src/printf/printf.c index 17d835a..33a392c 100644 --- a/src/printf/printf.c +++ b/src/printf/printf.c @@ -454,7 +454,7 @@ static inline output_gadget_t function_gadget(void (*function)(char, void*), voi result.max_chars = PRINTF_MAX_POSSIBLE_BUFFER_SIZE; return result; } - +// cause double comment static inline output_gadget_t extern_putchar_gadget(void) { return function_gadget(putchar_wrapper, NULL);