Regards mpaland#77: Expanded use of typedefs instead of plain unsigned int all over.

Author: eyalroz

src/printf/printf.c

@@ -137,6 +137,7 @@ extern "C" {
 #define FLAGS_ADAPT_EXP (1U << 11U)
 #define FLAGS_POINTER   (1U << 12U)
 // Note: Similar, but not identical, effect as FLAGS_HASH
+typedef unsigned int printf_flags_t;
 
 #define BASE_BINARY    2
 #define BASE_OCTAL     8
@@ -153,6 +154,9 @@ typedef long          printf_signed_value_t;
 
 typedef uint8_t numeric_base_t;
 
+typedef unsigned int printf_precision_t;
+typedef unsigned int printf_width_t;
+
 #if (PRINTF_SUPPORT_DECIMAL_SPECIFIERS || PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS)
 #include <float.h>
 #if FLT_RADIX != 2
@@ -266,11 +270,11 @@ static inline void out_wrapped_function(char character, void* wrapped_function,
 
 // internal secure strlen
 // @return The length of the string (excluding the terminating 0) limited by 'maxsize'
-static inline unsigned int strnlen_s_(const char* str, size_t maxsize)
+static inline size_t strnlen_s_(const char* str, size_t maxsize)
 {
   const char* s;
   for (s = str; *s && maxsize--; ++s);
-  return (unsigned int)(s - str);
+  return (size_t)(s - str);
 }
 
 
@@ -294,7 +298,7 @@ static unsigned int atoi_(const char** str)
 
 
 // output the specified string in reverse, taking care of any zero-padding
-static size_t out_rev_(out_fct_type out, char* buffer, size_t idx, size_t maxlen, const char* buf, size_t len, unsigned int width, unsigned int flags)
+static size_t out_rev_(out_fct_type out, char* buffer, size_t idx, size_t maxlen, const char* buf, size_t len, printf_width_t width, printf_flags_t flags)
 {
   const size_t start_idx = idx;
 
@@ -323,7 +327,7 @@ static size_t out_rev_(out_fct_type out, char* buffer, size_t idx, size_t maxlen
 
 // 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 size_t print_integer_finalization(out_fct_type out, char* buffer, size_t idx, size_t maxlen, char* buf, size_t len, bool negative, numeric_base_t base, unsigned int precision, unsigned int width, unsigned int flags)
+static size_t print_integer_finalization(out_fct_type out, char* buffer, size_t idx, size_t maxlen, char* buf, size_t len, bool negative, numeric_base_t base, printf_precision_t precision, printf_width_t width, printf_flags_t flags)
 {
   size_t unpadded_len = len;
 
@@ -390,7 +394,7 @@ static size_t print_integer_finalization(out_fct_type out, char* buffer, size_t
 }
 
 // An internal itoa-like function
-static size_t print_integer(out_fct_type out, char* buffer, size_t idx, size_t maxlen, printf_unsigned_value_t value, bool negative, numeric_base_t base, unsigned int precision, unsigned int width, unsigned int flags)
+static size_t print_integer(out_fct_type out, char* buffer, size_t idx, size_t maxlen, printf_unsigned_value_t value, bool negative, numeric_base_t base, printf_precision_t precision, printf_width_t width, printf_flags_t flags)
 {
   char buf[PRINTF_INTEGER_BUFFER_SIZE];
   size_t len = 0U;
@@ -441,7 +445,7 @@ static const double powers_of_10[NUM_DECIMAL_DIGITS_IN_INT64_T] = {
 // Break up a double 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 double_components get_components(double number, unsigned int precision)
+static struct double_components get_components(double number, printf_precision_t precision)
 {
   struct double_components number_;
   number_.is_negative = get_sign(number);
@@ -516,7 +520,7 @@ static struct scaling_factor update_normalization(struct scaling_factor sf, doub
   return result;
 }
 
-static struct double_components get_normalized_components(bool negative, unsigned int precision, double non_normalized, struct scaling_factor normalization)
+static struct double_components get_normalized_components(bool negative, printf_precision_t precision, double non_normalized, struct scaling_factor normalization)
 {
   struct double_components components;
   components.is_negative = negative;
@@ -556,8 +560,8 @@ static struct double_components get_normalized_components(bool negative, unsigne
 #endif
 
 static size_t print_broken_up_decimal(
-  struct double_components number_, out_fct_type out, char *buffer, size_t idx, size_t maxlen, unsigned int precision,
-  unsigned int width, unsigned int flags, char *buf, size_t len)
+  struct double_components number_, out_fct_type out, char *buffer, size_t idx, size_t maxlen, printf_precision_t precision,
+  printf_width_t width, printf_flags_t flags, char *buf, size_t len)
 {
   if (precision != 0U) {
     // do fractional part, as an unsigned number
@@ -638,15 +642,15 @@ static size_t print_broken_up_decimal(
 }
 
       // internal ftoa for fixed decimal floating point
-static size_t print_decimal_number(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double number, unsigned int precision, unsigned int width, unsigned int flags, char* buf, size_t len)
+static size_t print_decimal_number(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double number, printf_precision_t precision, printf_width_t width, printf_flags_t flags, char* buf, size_t len)
 {
   struct double_components value_ = get_components(number, precision);
   return print_broken_up_decimal(value_, out, buffer, idx, maxlen, precision, width, flags, buf, len);
 }
 
 #if PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
 // internal ftoa variant for exponential floating-point type, contributed by Martijn Jasperse <[email protected]>
-static size_t print_exponential_number(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double number, unsigned int precision, unsigned int width, unsigned int flags, char* buf, size_t len)
+static size_t print_exponential_number(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double number, printf_precision_t precision, printf_width_t width, printf_flags_t flags, char* buf, size_t len)
 {
   const bool negative = get_sign(number);
   // This number will decrease gradually (by factors of 10) as we "extract" the exponent out of it
@@ -737,9 +741,9 @@ static size_t print_exponential_number(out_fct_type out, char* buffer, size_t id
 
   // the exp10 format is "E%+03d" and largest possible exp10 value for a 64-bit double
   // is "307" (for 2^1023), so we set aside 4-5 characters overall
-  unsigned int exp10_part_width = fall_back_to_decimal_only_mode ? 0U : (PRINTF_ABS(exp10) < 100) ? 4U : 5U;
+  printf_width_t exp10_part_width = fall_back_to_decimal_only_mode ? 0U : (PRINTF_ABS(exp10) < 100) ? 4U : 5U;
 
-  unsigned int decimal_part_width =
+  printf_width_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:
@@ -772,8 +776,7 @@ static size_t print_exponential_number(out_fct_type out, char* buffer, size_t id
 }
 #endif  // PRINTF_SUPPORT_EXPONENTIAL_SPECIFIERS
 
-
-static size_t print_floating_point(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int precision, unsigned int width, unsigned int flags, bool prefer_exponential)
+static size_t print_floating_point(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, printf_precision_t precision, printf_width_t width, printf_flags_t flags, bool prefer_exponential)
 {
   char buf[PRINTF_FTOA_BUFFER_SIZE];
   size_t len  = 0U;
@@ -821,7 +824,10 @@ static size_t print_floating_point(out_fct_type out, char* buffer, size_t idx, s
 // internal vsnprintf
 static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const char* format, va_list va)
 {
-  unsigned int flags, width, precision, n;
+  printf_flags_t flags;
+  printf_width_t width;
+  printf_precision_t precision;
+  unsigned int n;
   size_t idx = 0U;
 
   if (!buffer) {
@@ -865,10 +871,10 @@ static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const
       const int w = va_arg(va, int);
       if (w < 0) {
         flags |= FLAGS_LEFT;    // reverse padding
-        width = (unsigned int)-w;
+        width = (printf_width_t)-w;
       }
       else {
-        width = (unsigned int)w;
+        width = (printf_width_t)w;
       }
       format++;
     }
@@ -883,7 +889,7 @@ static int _vsnprintf(out_fct_type out, char* buffer, const size_t maxlen, const
       }
       else if (*format == '*') {
         const int precision_ = va_arg(va, int);
-        precision = precision_ > 0 ? (unsigned int)precision_ : 0U;
+        precision = precision_ > 0 ? (printf_precision_t)precision_ : 0U;
         format++;
       }
     }
@@ -1183,4 +1189,4 @@ int vfctprintf(void (*out)(char character, void* arg), void* arg, const char* fo
 
 #ifdef __cplusplus
 } // extern "C"
-#endif
+#endif