Get rid of bit fields

include/fmt/printf.h

@@ -200,7 +200,7 @@ class printf_width_handler {
   auto operator()(T value) -> unsigned {
     auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
     if (detail::is_negative(value)) {
-      specs_.align = align::left;
+      specs_.set_align(align::left);
       width = 0 - width;
     }
     unsigned int_max = to_unsigned(max_value<int>());
@@ -234,7 +234,7 @@ class printf_arg_formatter : public arg_formatter<Char> {
 
   void write_null_pointer(bool is_string = false) {
     auto s = this->specs;
-    s.type = presentation_type::none;
+    s.set_type(presentation_type::none);
     write_bytes<Char>(this->out, is_string ? "(null)" : "(nil)", s);
   }
 
@@ -254,16 +254,17 @@ class printf_arg_formatter : public arg_formatter<Char> {
       return;
     }
     format_specs s = this->specs;
-    if (s.type != presentation_type::none && s.type != presentation_type::chr) {
+    if (s.type() != presentation_type::none &&
+        s.type() != presentation_type::chr) {
       return (*this)(static_cast<int>(value));
     }
-    s.sign = sign::none;
-    s.alt = false;
-    s.fill = ' ';  // Ignore '0' flag for char types.
+    s.set_sign(sign::none);
+    s.clear_alt();
+    s.set_fill(' ');  // Ignore '0' flag for char types.
     // align::numeric needs to be overwritten here since the '0' flag is
     // ignored for non-numeric types
-    if (s.align == align::none || s.align == align::numeric)
-      s.align = align::right;
+    if (s.align() == align::none || s.align() == align::numeric)
+      s.set_align(align::right);
     write<Char>(this->out, static_cast<Char>(value), s);
   }
 
@@ -276,14 +277,14 @@ class printf_arg_formatter : public arg_formatter<Char> {
     if (value)
       base::operator()(value);
     else
-      write_null_pointer(this->specs.type != presentation_type::pointer);
+      write_null_pointer(this->specs.type() != presentation_type::pointer);
   }
 
   void operator()(const wchar_t* value) {
     if (value)
       base::operator()(value);
     else
-      write_null_pointer(this->specs.type != presentation_type::pointer);
+      write_null_pointer(this->specs.type() != presentation_type::pointer);
   }
 
   void operator()(basic_string_view<Char> value) { base::operator()(value); }
@@ -306,19 +307,19 @@ void parse_flags(format_specs& specs, const Char*& it, const Char* end) {
   for (; it != end; ++it) {
     switch (*it) {
     case '-':
-      specs.align = align::left;
+      specs.set_align(align::left);
       break;
     case '+':
-      specs.sign = sign::plus;
+      specs.set_sign(sign::plus);
       break;
     case '0':
-      specs.fill = '0';
+      specs.set_fill('0');
       break;
     case ' ':
-      if (specs.sign != sign::plus) specs.sign = sign::space;
+      if (specs.sign() != sign::plus) specs.set_sign(sign::space);
       break;
     case '#':
-      specs.alt = true;
+      specs.set_alt();
       break;
     default:
       return;
@@ -339,7 +340,7 @@ auto parse_header(const Char*& it, const Char* end, format_specs& specs,
       ++it;
       arg_index = value != -1 ? value : max_value<int>();
     } else {
-      if (c == '0') specs.fill = '0';
+      if (c == '0') specs.set_fill('0');
       if (value != 0) {
         // Nonzero value means that we parsed width and don't need to
         // parse it or flags again, so return now.
@@ -444,7 +445,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
     write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
 
     auto specs = format_specs();
-    specs.align = align::right;
+    specs.set_align(align::right);
 
     // Parse argument index, flags and width.
     int arg_index = parse_header(it, end, specs, get_arg);
@@ -470,7 +471,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
     // specified, the '0' flag is ignored
     if (specs.precision >= 0 && arg.is_integral()) {
       // Ignore '0' for non-numeric types or if '-' present.
-      specs.fill = ' ';
+      specs.set_fill(' ');
     }
     if (specs.precision >= 0 && arg.type() == type::cstring_type) {
       auto str = arg.visit(get_cstring<Char>());
@@ -480,13 +481,14 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
           str, to_unsigned(nul != str_end ? nul - str : specs.precision));
       arg = make_arg<basic_printf_context<Char>>(sv);
     }
-    if (specs.alt && arg.visit(is_zero_int())) specs.alt = false;
-    if (specs.fill.template get<Char>() == '0') {
-      if (arg.is_arithmetic() && specs.align != align::left)
-        specs.align = align::numeric;
-      else
-        specs.fill = ' ';  // Ignore '0' flag for non-numeric types or if '-'
-                           // flag is also present.
+    if (specs.alt() && arg.visit(is_zero_int())) specs.clear_alt();
+    if (specs.fill_unit<Char>() == '0') {
+      if (arg.is_arithmetic() && specs.align() != align::left) {
+        specs.set_align(align::numeric);
+      } else {
+        // Ignore '0' flag for non-numeric types or if '-' flag is also present.
+        specs.set_fill(' ');
+      }
     }
 
     // Parse length and convert the argument to the required type.
@@ -545,10 +547,10 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
       }
     }
     bool upper = false;
-    specs.type = parse_printf_presentation_type(type, arg.type(), upper);
-    if (specs.type == presentation_type::none)
+    specs.set_type(parse_printf_presentation_type(type, arg.type(), upper));
+    if (specs.type() == presentation_type::none)
       report_error("invalid format specifier");
-    specs.upper = upper;
+    if (upper) specs.set_upper();
 
     start = it;