__crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase > Class Template Reference

#include <corecrt_internal_stdio_output.h>

Inheritance diagram for __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >:

Collaboration diagram for __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >:

Public Types
using	oad_base = typename ProcessorBase::output_adapter_data
using	common_data_base = typename ProcessorBase::common_data_base
typedef __acrt_stdio_char_traits< Character >	char_traits

Public Member Functions
	output_processor (OutputAdapter const &output_adapter, uint64_t const options, Character const *const format, __crt_cached_ptd_host &ptd, va_list const arglist) throw ()
int	process () throw ()

Private Member Functions
__forceinline bool	state_case_normal () throw ()
__forceinline bool	state_case_normal_common () throw ()
__forceinline bool	state_case_normal_tchar (char) throw ()
__forceinline bool	state_case_normal_tchar (wchar_t) throw ()
__forceinline bool	state_case_percent () throw ()
__forceinline bool	state_case_flag () throw ()
bool	parse_int_from_format_string (int *const result) throw ()
__forceinline bool	state_case_width () throw ()
__forceinline bool	state_case_dot () throw ()
__forceinline bool	state_case_precision () throw ()
bool	state_case_size () throw ()
bool	state_case_type () throw ()
bool	type_case_c () throw ()
bool	type_case_c_tchar (char) throw ()
bool	type_case_c_tchar (wchar_t) throw ()
bool	type_case_Z () throw ()
bool	type_case_s () throw ()
int	type_case_s_compute_narrow_string_length (int const maximum_length, char) throw ()
int	type_case_s_compute_narrow_string_length (int const maximum_length, wchar_t) throw ()
bool	type_case_a () throw ()
bool	type_case_d () throw ()
bool	type_case_u () throw ()
bool	type_case_o () throw ()
bool	type_case_X () throw ()
bool	type_case_x () throw ()
bool	type_case_p () throw ()
template<unsigned Radix>
bool	type_case_integer (bool const capital_hexits=false) throw ()
template<typename UnsignedInteger , unsigned Radix>
void	type_case_integer_parse_into_buffer (UnsignedInteger number, bool const capital_hexits) throw ()
bool	type_case_n () throw ()
__forceinline bool	write_stored_string_tchar (char) throw ()
__forceinline bool	write_stored_string_tchar (wchar_t) throw ()
bool	has_flag (unsigned const f) const throw ()
void	set_flag (unsigned const f) throw ()
void	unset_flag (unsigned const f) throw ()
state	find_next_state (Character const c, state const previous_state) const throw ()

Static Private Member Functions
static char __cdecl	adjust_hexit (int const value, bool const capitalize) throw ()
static char *__cdecl	narrow_null_string () throw ()
static wchar_t *__cdecl	wide_null_string () throw ()

Detailed Description

template<typename Character, typename OutputAdapter, typename ProcessorBase>
class __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >

Definition at line 1697 of file corecrt_internal_stdio_output.h.

Member Typedef Documentation

char_traits

template<typename Character , typename OutputAdapter , typename ProcessorBase >

typedef __acrt_stdio_char_traits<Character> __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::char_traits

Definition at line 1735 of file corecrt_internal_stdio_output.h.

common_data_base

template<typename Character , typename OutputAdapter , typename ProcessorBase >

using __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::common_data_base = typename ProcessorBase::common_data_base

Definition at line 1716 of file corecrt_internal_stdio_output.h.

oad_base

template<typename Character , typename OutputAdapter , typename ProcessorBase >

using __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::oad_base = typename ProcessorBase::output_adapter_data

Definition at line 1714 of file corecrt_internal_stdio_output.h.

Constructor & Destructor Documentation

output_processor()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

__crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::output_processor ( OutputAdapter const &  output_adapter, uint64_t const  options, Character const *const  format, __crt_cached_ptd_host &  ptd, va_list const  arglist  ) throw ( )

inline

Definition at line 1737 of file corecrt_internal_stdio_output.h.

        : ProcessorBase{output_adapter, options, format, ptd, arglist}
    {
    }

Member Function Documentation

adjust_hexit()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

static char __cdecl __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::adjust_hexit ( int const  value, bool const  capitalize  ) throw ( )

inlinestaticprivate

Definition at line 2884 of file corecrt_internal_stdio_output.h.

    {
        int const base  {capitalize ? 'A' : 'a'};
        int const offset{base - '9' - 1        };
 
        return static_cast<char>(offset + value);
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type(), and __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_integer_parse_into_buffer().

find_next_state()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

state __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::find_next_state ( Character const  c, state const  previous_state  ) const throw ( )

inlineprivate

Definition at line 2867 of file corecrt_internal_stdio_output.h.

    {
        auto const& lookup_table = state_transition_table();
 
        unsigned const current_class = static_cast<unsigned>((c < ' ' || c > 'z')
            ? character_type::other
            : static_cast<character_type>(lookup_table[c - ' '].current_class));
 
        auto const index = current_class * state_count() + static_cast<unsigned>(previous_state);
        return static_cast<state>(lookup_table[index].next_state);
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::process().

has_flag()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::has_flag ( unsigned const  f ) const throw ( )

inlineprivate

Definition at line 2863 of file corecrt_internal_stdio_output.h.

{ return (_flags & f) != 0; }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type(), __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_a(), __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_integer(), and __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_o().

narrow_null_string()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

static char *__cdecl __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::narrow_null_string ( ) throw ( )

inlinestaticprivate

Definition at line 2893 of file corecrt_internal_stdio_output.h.

{ return  "(null)"; }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_s(), and __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_Z().

parse_int_from_format_string()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::parse_int_from_format_string ( int *const  result ) throw ( )

inlineprivate

Definition at line 1900 of file corecrt_internal_stdio_output.h.

    {
        auto const reset_errno = _ptd.get_errno().create_guard();
 
        Character* end{};
        *result = static_cast<int>(_tcstol_internal(_ptd,
            _format_it - 1,
            &end,
            10));
 
        if (_ptd.get_errno().check(ERANGE))
        {
            return false;
        }
 
        if (end < _format_it)
        {
            return false;
        }
 
        _format_it = end;
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_precision(), and __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_width().

process()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

int __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::process ( ) throw ( )

inline

Definition at line 1751 of file corecrt_internal_stdio_output.h.

    {
        if (!_output_adapter.validate(_ptd))
        {
            return -1;
        }
 
        _UCRT_VALIDATE_RETURN(_ptd, _format_it != nullptr, EINVAL, -1);
 
        while (advance_to_next_pass())
        {
            // At the start of each pass, we have no buffered string and we are
            // in the normal state:
            _string_length = 0;
            _state         = state::normal;
 
            // Iterate over the format string until we reach the end, encounter
            // an I/O error, or fail due to some other error:
            while ((_format_char = *_format_it++) != '\0' && _characters_written >= 0)
            {
                _state = find_next_state(_format_char, _state);
 
                if (!validate_and_update_state_at_beginning_of_format_character())
                {
                    return -1;
                }
 
                if (_state >= state::invalid)
                {
                    _UCRT_VALIDATE_RETURN(_ptd, ("Incorrect format specifier", 0), EINVAL, -1);
                }
 
                bool result = false;
 
                switch (_state)
                {
                case state::normal:    result = state_case_normal   (); break;
                case state::percent:   result = state_case_percent  (); break;
                case state::flag:      result = state_case_flag     (); break;
                case state::width:     result = state_case_width    (); break;
                case state::dot:       result = state_case_dot      (); break;
                case state::precision: result = state_case_precision(); break;
                case state::size:      result = state_case_size     (); break;
                case state::type:      result = state_case_type     (); break;
                }
 
                // If the state-specific operation failed, return immediately.
                // The individual state cases are responsible for invoking the
                // invalid parameter handler if the failure is due to an invalid
                // parameter.
                if (!result)
                    return -1;
            }
 
            if (!validate_and_update_state_at_end_of_format_string())
                return -1;
        }
 
        return _characters_written;
    }

set_flag()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

void __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::set_flag ( unsigned const  f ) throw ( )

inlineprivate

Definition at line 2864 of file corecrt_internal_stdio_output.h.

{ _flags |= f;              }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_flag(), __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_width(), __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_a(), __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_d(), __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_integer(), and __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_o().

state_case_dot()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

__forceinline bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_dot ( ) throw ( )

inlineprivate

Definition at line 1955 of file corecrt_internal_stdio_output.h.

    {
        // Reset the precision to zero.  If the dot is not followed by a number,
        // it means a precision of zero, not the default precision (per the C
        // Standard Library specification).  (Note:  We represent the default
        // precision with -1.)
        _precision = 0;
 
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::process().

state_case_flag()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

__forceinline bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_flag ( ) throw ( )

inlineprivate

Definition at line 1880 of file corecrt_internal_stdio_output.h.

    {
        // Set the flag based on which flag character:
        switch (_format_char)
        {
        case '-': set_flag(FL_LEFT     ); break; // '-' => left justify
        case '+': set_flag(FL_SIGN     ); break; // '+' => force sign indicator
        case ' ': set_flag(FL_SIGNSP   ); break; // ' ' => force sign or space
        case '#': set_flag(FL_ALTERNATE); break; // '#' => alternate form
        case '0': set_flag(FL_LEADZERO ); break; // '0' => pad with leading zeros
        }
 
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::process().

state_case_normal()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

__forceinline bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_normal ( ) throw ( )

inlineprivate

Definition at line 1821 of file corecrt_internal_stdio_output.h.

    {
        if (should_skip_normal_state_processing())
            return true;
 
        _UCRT_VALIDATE_RETURN(_ptd, state_case_normal_common(), EINVAL, false);
 
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::process().

state_case_normal_common()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

__forceinline bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_normal_common ( ) throw ( )

inlineprivate

Definition at line 1831 of file corecrt_internal_stdio_output.h.

    {
        if (!state_case_normal_tchar(Character()))
            return false;
 
        _output_adapter.write_character(_format_char, &_characters_written, _ptd);
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_normal().

state_case_normal_tchar() [1/2]

template<typename Character , typename OutputAdapter , typename ProcessorBase >

__forceinline bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_normal_tchar ( char  ) throw ( )

inlineprivate

Definition at line 1840 of file corecrt_internal_stdio_output.h.

    {
        _string_is_wide = false;
 
        if (__acrt_isleadbyte_l_noupdate(_format_char, _ptd.get_locale()))
        {
            _output_adapter.write_character(_format_char, &_characters_written, _ptd);
            _format_char = *_format_it++;
 
            // Ensure that we do not fall off the end of the format string:
            _UCRT_VALIDATE_RETURN(_ptd, _format_char != '\0', EINVAL, false);
        }
 
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_normal_common().

state_case_normal_tchar() [2/2]

template<typename Character , typename OutputAdapter , typename ProcessorBase >

__forceinline bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_normal_tchar ( wchar_t  ) throw ( )

inlineprivate

Definition at line 1856 of file corecrt_internal_stdio_output.h.

    {
        _string_is_wide = true;
        return true;
    }

state_case_percent()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

__forceinline bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_percent ( ) throw ( )

inlineprivate

Definition at line 1865 of file corecrt_internal_stdio_output.h.

    {
        _field_width     =  0;
        _suppress_output =  false;
        _flags           =  0;
        _precision       = -1;
        _length          =  length_modifier::none;
        _string_is_wide  =  false;
 
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::process().

state_case_precision()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

__forceinline bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_precision ( ) throw ( )

inlineprivate

Definition at line 1969 of file corecrt_internal_stdio_output.h.

    {
        if (_format_char != '*')
        {
            return parse_int_from_format_string(&_precision);
        }
 
        // If the format character is an asterisk, we read the width from the
        // varargs.  If we read a negative value, we treat it as indicating the
        // default precision.
        if (!update_precision())
            return false;
 
        if (!should_format())
            return true;
 
        if (_precision < 0)
            _precision = -1;
 
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::process().

state_case_size()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_size ( ) throw ( )

inlineprivate

Definition at line 1993 of file corecrt_internal_stdio_output.h.

    {
        if (_format_char == 'F')
        {
            // We hand the 'F' character as a length modifier because the length
            // modifier occurs before the type specifier.  If we find an 'F' and
            // we are in the legacy compatibility mode that supports the 'F' length
            // modifier, we just ignore it (it has no meaning).  Otherwise we are
            // not in compatibility mode so we switch out to the type case to handle
            // the 'F' as a %F format specifier:
            if ((_options & _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY) == 0)
            {
                _state = state::type;
                return state_case_type();
            }
 
            return true;
        }
 
        if (_format_char == 'N')
        {
            // If we find an 'N' and we are in the legacy compatibility mode that
            // supports the 'N' length modifier, we just ignore it (it has no
            // meaning).  Otherwise, we are not in compatibility mode, so we
            // invoke the invalid parameter handler and return failure.
            if ((_options & _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY) == 0)
            {
                _state = state::invalid;
#pragma warning(suppress: __WARNING_IGNOREDBYCOMMA) // 6319 comma operator
                _UCRT_VALIDATE_RETURN(_ptd, ("N length modifier not specifier", false), EINVAL, false);
                return false;
            }
 
            return true;
        }
 
        _UCRT_VALIDATE_RETURN(_ptd, _length == length_modifier::none, EINVAL, false);
 
        // We just read a size specifier; set the flags based on it:
        switch (_format_char)
        {
        case 'h':
        {
            if (*_format_it == 'h')
            {
                ++_format_it;
                _length = length_modifier::hh;
            }
            else
            {
                _length = length_modifier::h;
            }
 
            return true;
        }
 
        case 'I':
        {
            // The I32, I64, and I length modifiers are Microsoft extensions.
 
            if (*_format_it == '3' && *(_format_it + 1) == '2')
            {
                _format_it += 2;
                _length = length_modifier::I32;
            }
            else if (*_format_it == '6' && *(_format_it + 1) == '4')
            {
                _format_it += 2;
                _length = length_modifier::I64;
            }
            else if (*_format_it == 'd' ||
                     *_format_it == 'i' ||
                     *_format_it == 'o' ||
                     *_format_it == 'u' ||
                     *_format_it == 'x' ||
                     *_format_it == 'X')
            {
                // If we support positional parameters, then %I without a following
                // 32 or 64 is platform-dependent:
                _length = length_modifier::I;
            }
 
            return true;
        }
 
        case 'l':
        {
            if (*_format_it == 'l')
            {
                ++_format_it;
                _length = length_modifier::ll;
            }
            else
            {
                _length = length_modifier::l;
            }
 
            return true;
        }
 
        case 'L':
        {
            _length = length_modifier::L;
            return true;
        }
 
        case 'j':
        {
            _length = length_modifier::j;
            return true;
        }
 
        case 't':
        {
            _length = length_modifier::t;
            return true;
        }
 
        case 'z':
        {
            _length = length_modifier::z;
            return true;
        }
 
        case 'w':
        {
            _length = length_modifier::w;
            return true;
        }
 
        case 'T':
        {
            _length = length_modifier::T;
            return true;
        }
        }
 
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::process().

state_case_type()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type ( ) throw ( )

inlineprivate

Definition at line 2137 of file corecrt_internal_stdio_output.h.

    {
        // Each of the subfunctions is responsible for [1] extracting the next
        // argument from the varargs, [2] formatting that argument into the
        // internal buffer, and [3] updating the string state variables with
        // the correct data for the format operation (either _narrow_string or
        // _wide_string must be set correctly, the _string_length must be set
        // correctly, and _string_is_wide must be true if the wide string
        // should be used.
        bool result{false};
        switch (_format_char)
        {
        // Individual character output:
        case 'C':
        case 'c': result = type_case_c(); break;
 
        // String output:
        case 'Z': result = type_case_Z(); break;
        case 'S':
        case 's': result = type_case_s(); break;
 
        // Floating-point output:
        case 'A':
        case 'E':
        case 'F':
        case 'G':
        case 'a':
        case 'e':
        case 'f':
        case 'g': result = type_case_a(); break;
 
        // Integer and pointer output:
        case 'd':
        case 'i': result = type_case_d(); break;
        case 'u': result = type_case_u(); break;
        case 'o': result = type_case_o(); break;
        case 'X': result = type_case_X(); break;
        case 'x': result = type_case_x(); break;
        case 'p': result = type_case_p(); break;
 
        // State reporting (no output):
        case 'n': result = type_case_n(); break;
        }
 
        // If the case-specific logic failed, return immediately.  The case-
        // specific function is responsible for invoking the invalid parameter
        // handler if it needs to do so.
        if (!result)
            return false;
 
        // Check to see whether the output operation should be skipped (we skip
        // the output part e.g. during the positional scan pass when positional
        // formatting is used).
        if (should_skip_type_state_output())
            return true;
 
        // At this point, we've completed the bulk of the formatting operation
        // and the string is ready to be printed.  We now justify the string,
        // pre-pend any required prefix and leading zeroes, then print it.  Well,
        // unless output is suppressed, that is... :-)
        if (_suppress_output)
            return true;
 
        // Compute the prefix, if one is required...
        Character  prefix[3]{};
        size_t     prefix_length{0};
 
        if (has_flag(FL_SIGNED))
        {
            if (has_flag(FL_NEGATIVE))
            {
                prefix[prefix_length++] = '-';
            }
            else if (has_flag(FL_SIGN))
            {
                prefix[prefix_length++] = '+';
            }
            else if (has_flag(FL_SIGNSP))
            {
                prefix[prefix_length++] = ' ';
            }
        }
 
        bool const print_integer_0x{(_format_char == 'x' || _format_char == 'X') && has_flag(FL_ALTERNATE)};
        bool const print_floating_point_0x{_format_char == 'a' || _format_char == 'A'};
 
        if (print_integer_0x || print_floating_point_0x)
        {
            prefix[prefix_length++] = '0';
            prefix[prefix_length++] = adjust_hexit('x' - 'a' + '9' + 1, _format_char == 'X' || _format_char == 'A');
        }
 
        // Compute the amount of padding required to get to the desired field
        // width, then output the left padding, prefix, leading zeroes, the
        // string, and right padding, in that order.
        int const padding = static_cast<int>(_field_width - _string_length - prefix_length);
 
        if (!has_flag(FL_LEFT | FL_LEADZERO))
        {
            // Left-pad with spaces
            write_multiple_characters(_output_adapter, ' ', padding, &_characters_written, _ptd);
        }
 
        // Write the prefix
        _output_adapter.write_string(prefix, static_cast<int>(prefix_length), &_characters_written, _ptd);
 
        if (has_flag(FL_LEADZERO) && !has_flag(FL_LEFT))
        {
            // Write leading zeroes
            write_multiple_characters(_output_adapter, '0', padding, &_characters_written, _ptd);
        }
 
        // Write the string
        write_stored_string_tchar(Character());
 
        if (_characters_written >= 0 && has_flag(FL_LEFT))
        {
            // Right-pad with spaces
            write_multiple_characters(_output_adapter, ' ', padding, &_characters_written, _ptd);
        }
 
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::process(), and __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_size().

state_case_width()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

__forceinline bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_width ( ) throw ( )

inlineprivate

Definition at line 1928 of file corecrt_internal_stdio_output.h.

    {
        if (_format_char != '*')
        {
            return parse_int_from_format_string(&_field_width);
        }
 
        // If the format character is an asterisk, we read the width from the
        // varargs.  If we read a negative value, we treat it as the '-' flag
        // followed by a positive width (per the C Standard Library spec).
        if (!update_field_width())
            return false;
 
        if (!should_format())
            return true;
 
        if (_field_width < 0)
        {
            set_flag(FL_LEFT);
            _field_width = -_field_width;
        }
 
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::process().

type_case_a()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_a ( ) throw ( )

inlineprivate

Definition at line 2468 of file corecrt_internal_stdio_output.h.

    {
        // The double type is signed:
        set_flag(FL_SIGNED);
 
        if (!validate_state_for_type_case_a())
            return false;
 
        if (!should_format())
            return true;
 
        // First, we need to compute the actual precision to use, limited by
        // both the maximum precision and the size of the buffer that we can
        // allocate.
        if (_precision < 0)
        {
            // The default precision depends on the format specifier used.  For
            // %e, %f, and %g, C specifies that the default precision is 6.  For
            // %a, C specifies that "if the precision is missing and FLT_RADIX
            // is a power of 2, then the precision is sufficient for an exact
            // representation of the value" (C11 7.21.6.1/8).
            //
            // The 64-bit double has 53 bits of precision.  When printing in
            // hexadecimal form, we print one bit of precision to the left of the
            // radix point and the remaining 52 bits of precision to the right.
            // Thus, the default precision is 13 (13 * 4 == 52).
            if (_format_char == 'a' || _format_char == 'A')
            {
                _precision = 13;
            }
            else
            {
                _precision = 6;
            }
        }
        else if (_precision == 0 && (_format_char == 'g' || _format_char == 'G'))
        {
            _precision = 1; // Per C Standard Library specification.
        }
 
        if (!_buffer.template ensure_buffer_is_big_enough<char>(_CVTBUFSIZE + _precision, _ptd))
        {
            // If we fail to enlarge the buffer, cap precision so that the
            // statically-sized buffer may be used for the formatting:
            _precision = static_cast<int>(_buffer.template count<char>() - _CVTBUFSIZE);
        }
 
        _narrow_string = _buffer.template data<char>();
 
        // Note that we separately handle the FORMAT_POSSCAN_PASS above.
        _CRT_DOUBLE tmp{};
        if (!this->template extract_argument_from_va_list<_CRT_DOUBLE>(tmp))
        {
            return false;
        }
 
        // Format the number into the buffer:
        __acrt_fp_format(
            &tmp.x,
            _buffer.template data<char>(),
            _buffer.template count<char>(),
            _buffer.template scratch_data<char>(),
            _buffer.template scratch_count<char>(),
            static_cast<char>(_format_char),
            _precision,
            _options,
            __acrt_rounding_mode::standard,
            _ptd);
 
        // If the precision is zero but the '#' flag is part of the specifier,
        // we force a decimal point:
        if (has_flag(FL_ALTERNATE) && _precision == 0)
        {
            force_decimal_point(_narrow_string, _ptd.get_locale());
        }
 
        // The 'g' format specifier indicates that zeroes should be cropped
        // unless the '#' flag is part of the specifier.
        if ((_format_char == 'g' || _format_char == 'G') && !has_flag(FL_ALTERNATE))
        {
            crop_zeroes(_narrow_string, _ptd.get_locale());
        }
 
        // If the result was negative, we save the '-' for later and advance past
        // the negative sign (we handle the '-' separately, in code shared with
        // the integer formatting, to correctly handle flags).
        if (*_narrow_string == '-')
        {
            set_flag(FL_NEGATIVE);
            ++_narrow_string;
        }
 
        // If the result was a special infinity or a nan string, suppress output
        // of the "0x" prefix by treating the special string as just a string:
        if (*_narrow_string == 'i' || *_narrow_string == 'I' ||
            *_narrow_string == 'n' || *_narrow_string == 'N')
        {
            unset_flag(FL_LEADZERO); // padded with spaces, not zeros.
            _format_char = 's';
        }
 
        _string_length = static_cast<int>(strlen(_narrow_string));
 
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type().

type_case_c()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_c ( ) throw ( )

inlineprivate

Definition at line 2265 of file corecrt_internal_stdio_output.h.

    {
        return type_case_c_tchar(Character());
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type().

type_case_c_tchar() [1/2]

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_c_tchar ( char  ) throw ( )

inlineprivate

Definition at line 2270 of file corecrt_internal_stdio_output.h.

    {
        // If the character is a wide character, we translate it to multibyte
        // to be output, storing the multibyte string in the internal buffer:
        if (is_wide_character_specifier(_options, _format_char, _length))
        {
            wchar_t wide_character{};
            if (!this->template extract_argument_from_va_list<wchar_t>(wide_character))
            {
                return false;
            }
 
            if (!should_format())
            {
                return true;
            }
 
            // Convert to multibyte.  If the conversion fails, we suppress the
            // output operation but we do not fail the entire operation:
            errno_t const status{_wctomb_internal(&_string_length, _buffer.template data<char>(), _buffer.template count<char>(), wide_character, _ptd)};
            if (status != 0)
            {
                _suppress_output = true;
            }
        }
        // If the character is a narrow character, we can just write it directly
        // to the output, as-is.
        else
        {
            if (!this->template extract_argument_from_va_list<unsigned short>(_buffer.template data<char>()[0]))
            {
                return false;
            }
 
            if (!should_format())
            {
                return true;
            }
 
            _string_length = 1;
        }
 
        _narrow_string = _buffer.template data<char>();
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_c().

type_case_c_tchar() [2/2]

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_c_tchar ( wchar_t  ) throw ( )

inlineprivate

Definition at line 2316 of file corecrt_internal_stdio_output.h.

    {
        // If the output adapter accepts wide characters, then we must transform
        // the character into a wide character to be output.
        _string_is_wide = true;
 
        wchar_t wide_character{};
        if (!this->template extract_argument_from_va_list<wchar_t>(wide_character))
            return false;
 
        if (!should_format())
            return true;
 
        if (!is_wide_character_specifier(_options, _format_char, _length))
        {
            // If the character is actually a multibyte character, then we must
            // transform it into the equivalent wide character.  If the translation
            // is unsuccessful, we ignore this character but do not fail the entire
            // output operation.
            char const local_buffer[2]{ static_cast<char>(wide_character & 0x00ff), '\0' };
            int const mbc_length{_mbtowc_internal(
                _buffer.template data<wchar_t>(),
                local_buffer,
                _ptd.get_locale()->locinfo->_public._locale_mb_cur_max,
                _ptd
                )};
            if (mbc_length < 0)
            {
                _suppress_output = true;
            }
        }
        else
        {
            _buffer.template data<wchar_t>()[0] = wide_character;
        }
 
        _wide_string   = _buffer.template data<wchar_t>();
        _string_length = 1;
        return true;
    }

type_case_d()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_d ( ) throw ( )

inlineprivate

Definition at line 2578 of file corecrt_internal_stdio_output.h.

    {
        set_flag(FL_SIGNED);
 
        return type_case_integer<10>();
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type().

type_case_integer()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

template<unsigned Radix>

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_integer ( bool const  capital_hexits = false ) throw ( )

inlineprivate

Definition at line 2631 of file corecrt_internal_stdio_output.h.

    {
        size_t const integer_size = to_integer_size(_length);
 
        // First, extract the argument of the required type from the varargs:
        __int64 original_number  {};
        bool    extraction_result{};
        switch (integer_size)
        {
        case sizeof(int8_t):
            extraction_result = has_flag(FL_SIGNED)
                ? this->template extract_argument_from_va_list<int8_t >(original_number)
                : this->template extract_argument_from_va_list<uint8_t>(original_number);
            break;
        case sizeof(int16_t):
            extraction_result = has_flag(FL_SIGNED)
                ? this->template extract_argument_from_va_list<int16_t >(original_number)
                : this->template extract_argument_from_va_list<uint16_t>(original_number);
            break;
        case sizeof(int32_t):
            extraction_result = has_flag(FL_SIGNED)
                ? this->template extract_argument_from_va_list<int32_t >(original_number)
                : this->template extract_argument_from_va_list<uint32_t>(original_number);
            break;
        case sizeof(int64_t):
            extraction_result = has_flag(FL_SIGNED)
                ? this->template extract_argument_from_va_list<int64_t >(original_number)
                : this->template extract_argument_from_va_list<uint64_t>(original_number);
            break;
        default:
            _UCRT_VALIDATE_RETURN(_ptd, ("Invalid integer length modifier", 0), EINVAL, false);
            break;
        }
 
        if (!extraction_result)
            return false;
 
        // If we're not formatting, then we're done; we just needed to read the
        // argument from the varargs.
        if (!should_format())
            return true;
 
        // Check the sign of the number.  If it is negative, convert it to
        // positive for formatting.  We'll handle the minus sign later (after
        // we return from this function).
        unsigned __int64 number{};
 
        if (has_flag(FL_SIGNED) && original_number < 0)
        {
            number = static_cast<unsigned __int64>(-original_number);
            set_flag(FL_NEGATIVE);
        }
        else
        {
            number = static_cast<unsigned __int64>(original_number);
        }
 
        // Check the precision to see if the default precision was specified.  If
        // a non-default precision was specified, we turn off the zero flag, per
        // the C Standard Library specification.
        if (_precision < 0)
        {
            _precision = 1; // Default precision
        }
        else
        {
            unset_flag(FL_LEADZERO);
            _buffer.template ensure_buffer_is_big_enough<Character>(_precision, _ptd);
        }
 
        // If the number is zero, we do not want to print the hex prefix ("0x"),
        // even if it was requested:
        if (number == 0)
        {
            unset_flag(FL_ALTERNATE);
        }
 
        _string_is_wide = sizeof(Character) == sizeof(wchar_t);
 
        if (integer_size == sizeof(int64_t))
        {
            type_case_integer_parse_into_buffer<uint64_t, Radix>(number, capital_hexits);
        }
        else
        {
            type_case_integer_parse_into_buffer<uint32_t, Radix>(static_cast<uint32_t>(number), capital_hexits);
        }
 
        // If the FORCEOCTAL flag is set, then we output a leading zero, unless
        // the formatted string already has a leading zero:
        if (has_flag(FL_FORCEOCTAL) && (_string_length == 0 || tchar_string()[0] != '0'))
        {
            *--tchar_string() = '0';
            ++_string_length;
        }
 
        return true;
    }

type_case_integer_parse_into_buffer()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

template<typename UnsignedInteger , unsigned Radix>

void __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_integer_parse_into_buffer ( UnsignedInteger  number, bool const  capital_hexits  ) throw ( )

inlineprivate

Definition at line 2735 of file corecrt_internal_stdio_output.h.

    {
        // Format the number into the formatting buffer.  Note that we format the
        // buffer at the end of the formatting buffer, which allows us to perform
        // the formatting from least to greatest magnitude, which maps well to
        // the math.
        Character* const last_digit{_buffer.template data<Character>() + _buffer.template count<Character>() - 1};
 
        Character*& string_pointer = tchar_string();
 
        string_pointer = last_digit;
        while (_precision > 0 || number != 0)
        {
            --_precision;
 
            Character digit{static_cast<Character>(number % Radix + '0')};
            number /= Radix;
 
            // If the digit is greater than 9, we need to convert it to the
            // corresponding letter hexit in the required case:
            if (digit > '9')
            {
                digit = adjust_hexit(digit, capital_hexits);
            }
 
            *string_pointer-- = static_cast<char>(digit);
        }
 
        _string_length = static_cast<int>(last_digit - string_pointer);
        ++string_pointer;
    }

type_case_n()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_n ( ) throw ( )

inlineprivate

Definition at line 2773 of file corecrt_internal_stdio_output.h.

    {
        void* p{nullptr};
        if (!this->template extract_argument_from_va_list<void*>(p))
            return false;
 
        if (!should_format())
            return true;
 
        if (!_get_printf_count_output())
        {
            _UCRT_VALIDATE_RETURN(_ptd, ("'n' format specifier disabled", 0), EINVAL, false);
            return false; // Unreachable
        }
 
        switch (to_integer_size(_length))
        {
        case sizeof(int8_t):  *static_cast<int8_t *>(p) = static_cast<int8_t >(_characters_written);   break;
        case sizeof(int16_t): *static_cast<int16_t*>(p) = static_cast<int16_t>(_characters_written);   break;
        case sizeof(int32_t): *static_cast<int32_t*>(p) = static_cast<int32_t>(_characters_written);   break;
        case sizeof(int64_t): *static_cast<int64_t*>(p) = static_cast<int64_t>(_characters_written);   break;
        default:              _UCRT_VALIDATE_RETURN(_ptd, ("Invalid integer length modifier", 0), EINVAL, false); break;
        }
 
        // This format specifier never corresponds to an output operation:
        _suppress_output = true;
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type().

type_case_o()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_o ( ) throw ( )

inlineprivate

Definition at line 2590 of file corecrt_internal_stdio_output.h.

    {
        // If the alternate flag is set, we force a leading 0:
        if (has_flag(FL_ALTERNATE))
            set_flag(FL_FORCEOCTAL);
 
        return type_case_integer<8>();
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type().

type_case_p()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_p ( ) throw ( )

inlineprivate

Definition at line 2611 of file corecrt_internal_stdio_output.h.

    {
        // We force the precision to be 2 * sizeof(void*), which is the number
        // of hexits required to represent the pointer, so that it is zero-
        // padded.
        _precision = 2 * sizeof(void*);
 
        // Ensure that we read a 32-bit integer on 32-bit architectures, and
        // a 64-bit integer on 64-bit platforms:
        _length = sizeof(void*) == 4
            ? length_modifier::I32
            : length_modifier::I64;
 
        return type_case_integer<16>(true);
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type().

type_case_s()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_s ( ) throw ( )

inlineprivate

Definition at line 2402 of file corecrt_internal_stdio_output.h.

    {
        // If this format specifier has the default precision, then the entire
        // string is output.  If a precision is given, then we output the minimum
        // of the length of the C string and the given precision.  Note that the
        // string needs not be null-terminated if a precision is given, so we
        // cannot call strlen to compute the length of the string.
        if (!this->template extract_argument_from_va_list<char*>(_narrow_string))
            return false;
 
        if (!should_format())
            return true;
 
        int const maximum_length{(_precision == -1) ? INT_MAX : _precision};
 
        if (is_wide_character_specifier(_options, _format_char, _length))
        {
            if (!_wide_string)
                _wide_string = wide_null_string();
 
            _string_is_wide = true;
            _string_length  = static_cast<int>(wcsnlen(_wide_string, maximum_length));
        }
        else
        {
            if (!_narrow_string)
                _narrow_string = narrow_null_string();
 
            _string_length = type_case_s_compute_narrow_string_length(maximum_length, Character());
        }
 
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type().

type_case_s_compute_narrow_string_length() [1/2]

template<typename Character , typename OutputAdapter , typename ProcessorBase >

int __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_s_compute_narrow_string_length ( int const  maximum_length, char    ) throw ( )

inlineprivate

Definition at line 2441 of file corecrt_internal_stdio_output.h.

    {
        return static_cast<int>(strnlen(_narrow_string, maximum_length));
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_s().

type_case_s_compute_narrow_string_length() [2/2]

template<typename Character , typename OutputAdapter , typename ProcessorBase >

int __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_s_compute_narrow_string_length ( int const  maximum_length, wchar_t    ) throw ( )

inlineprivate

Definition at line 2446 of file corecrt_internal_stdio_output.h.

    {
        _locale_t locale = _ptd.get_locale();
        int string_length{0};
 
        for (char const* p{_narrow_string}; string_length < maximum_length && *p; ++string_length)
        {
            if (__acrt_isleadbyte_l_noupdate(static_cast<unsigned char>(*p), locale))
            {
                ++p;
            }
 
            ++p;
        }
 
        return string_length;
    }

type_case_u()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_u ( ) throw ( )

inlineprivate

Definition at line 2585 of file corecrt_internal_stdio_output.h.

    {
        return type_case_integer<10>();
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type().

type_case_X()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_X ( ) throw ( )

inlineprivate

Definition at line 2599 of file corecrt_internal_stdio_output.h.

    {
        return type_case_integer<16>(true);
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type().

type_case_x()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_x ( ) throw ( )

inlineprivate

Definition at line 2604 of file corecrt_internal_stdio_output.h.

    {
        return type_case_integer<16>();
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type().

type_case_Z()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_Z ( ) throw ( )

inlineprivate

Definition at line 2362 of file corecrt_internal_stdio_output.h.

    {
        // This matches the representation of the Windows SDK types ANSI_STRING
        // and UNICODE_STRING, which represent a counted string.
        struct ansi_string
        {
            unsigned short _length;
            unsigned short _maximum_length;
            char*          _buffer;
        };
 
        ansi_string* string{};
        if (!this->template extract_argument_from_va_list<ansi_string*>(string))
            return false;
 
        if (!should_format())
            return true;
 
        if (!string || string->_buffer == nullptr)
        {
            _narrow_string  = narrow_null_string();
            _string_length  = static_cast<int>(strlen(_narrow_string));
            _string_is_wide = false;
        }
        else if (is_wide_character_specifier(_options, _format_char, _length))
        {
            _wide_string    = reinterpret_cast<wchar_t*>(string->_buffer);
            _string_length  = string->_length / static_cast<int>(sizeof(wchar_t));
            _string_is_wide = true;
        }
        else
        {
            _narrow_string  = string->_buffer;
            _string_length  = string->_length;
            _string_is_wide = false;
        }
 
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type().

unset_flag()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

void __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::unset_flag ( unsigned const  f ) throw ( )

inlineprivate

Definition at line 2865 of file corecrt_internal_stdio_output.h.

{ _flags &= ~f;             }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_a(), and __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_integer().

wide_null_string()

template<typename Character , typename OutputAdapter , typename ProcessorBase >

static wchar_t *__cdecl __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::wide_null_string ( ) throw ( )

inlinestaticprivate

Definition at line 2894 of file corecrt_internal_stdio_output.h.

{ return L"(null)"; }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::type_case_s().

write_stored_string_tchar() [1/2]

template<typename Character , typename OutputAdapter , typename ProcessorBase >

__forceinline bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::write_stored_string_tchar ( char  ) throw ( )

inlineprivate

Definition at line 2804 of file corecrt_internal_stdio_output.h.

    {
        if (!_string_is_wide || _string_length <= 0)
        {
            _output_adapter.write_string(_narrow_string, _string_length, &_characters_written, _ptd);
        }
        else
        {
            wchar_t* p{_wide_string};
            for (int i{0}; i != _string_length; ++i)
            {
                char local_buffer[MB_LEN_MAX + 1];
 
                int mbc_length{0};
                errno_t const status{_wctomb_internal(&mbc_length, local_buffer, _countof(local_buffer), *p++, _ptd)};
                if (status != 0 || mbc_length == 0)
                {
                    _characters_written = -1;
                    return true;
                }
 
                _output_adapter.write_string(local_buffer, mbc_length, &_characters_written, _ptd);
            }
        }
 
        return true;
    }

Referenced by __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::state_case_type().

write_stored_string_tchar() [2/2]

template<typename Character , typename OutputAdapter , typename ProcessorBase >

__forceinline bool __crt_stdio_output::output_processor< Character, OutputAdapter, ProcessorBase >::write_stored_string_tchar ( wchar_t  ) throw ( )

inlineprivate

Definition at line 2832 of file corecrt_internal_stdio_output.h.

    {
        if (_string_is_wide || _string_length <= 0)
        {
            _output_adapter.write_string(_wide_string, _string_length, &_characters_written, _ptd);
        }
        else
        {
            _locale_t locale_ptr = _ptd.get_locale();
            char* p{_narrow_string};
            for (int i{0}; i != _string_length; ++i)
            {
                wchar_t wide_character{};
                int mbc_length{_mbtowc_internal(&wide_character, p, locale_ptr->locinfo->_public._locale_mb_cur_max, _ptd)};
 
                if (mbc_length <= 0)
                {
                    _characters_written = -1;
                    return true;
                }
 
                _output_adapter.write_character(wide_character, &_characters_written, _ptd);
                p += mbc_length;
            }
        }
 
        return true;
    }

---

The documentation for this class was generated from the following file:

• sdk/lib/ucrt/inc/corecrt_internal_stdio_output.h