#include <corecrt_internal_stdio_output.h>

Inheritance diagram for __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >:

[legend]

Collaboration diagram for __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >:

[legend]

Classes
struct	parameter_data

Protected Types
typedef positional_parameter_base	self_type

typedef format_validation_base< Character, OutputAdapter >	base_type

typedef __crt_char_traits< Character >	char_traits

Protected Types inherited from __crt_stdio_output::format_validation_base< Character, OutputAdapter >
using	common_data_base = typename standard_base< Character, OutputAdapter >::template output_adapter_data< Character, OutputAdapter >::template common_data< Character >

Protected Types inherited from __crt_stdio_output::standard_base< Character, OutputAdapter >
using	common_data_base = typename output_adapter_data< Character, OutputAdapter >::template common_data< Character >

Protected Member Functions
template<typename... Ts>
	positional_parameter_base (Ts &&... arguments) throw ()

bool	advance_to_next_pass () throw ()

bool	validate_and_update_state_at_end_of_format_string () throw ()

bool	should_format () throw ()

template<typename RequestedParameterType , typename ActualParameterType >
bool	extract_argument_from_va_list (ActualParameterType &result) throw ()

bool	update_field_width () throw ()

bool	update_precision () throw ()

bool	validate_state_for_type_case_a () throw ()

bool	should_skip_normal_state_processing () throw ()

bool	validate_and_update_state_at_beginning_of_format_character () throw ()

bool	should_skip_type_state_output () const throw ()

Protected Member Functions inherited from __crt_stdio_output::format_validation_base< Character, OutputAdapter >
template<typename... Ts>
	format_validation_base (Ts &&... arguments) throw ()

__forceinline bool	validate_and_update_state_at_end_of_format_string () throw ()

Protected Member Functions inherited from __crt_stdio_output::standard_base< Character, OutputAdapter >
template<typename... Ts>
	standard_base (Ts &&... arguments) throw ()

bool	advance_to_next_pass () throw ()

__forceinline bool	validate_and_update_state_at_end_of_format_string () const throw ()

bool	should_format () throw ()

template<typename RequestedParameterType , typename ActualParameterType >
bool	extract_argument_from_va_list (ActualParameterType &result) throw ()

bool	update_field_width () throw ()

bool	update_precision () throw ()

bool	validate_state_for_type_case_a () const throw ()

bool	should_skip_normal_state_processing () throw ()

bool	validate_and_update_state_at_beginning_of_format_character () throw ()

bool	should_skip_type_state_output () const throw ()

Protected Member Functions inherited from __crt_stdio_output::output_adapter_data< Character, OutputAdapter >
	output_adapter_data (OutputAdapter const &output_adapter, uint64_t const options, Character const *const format, __crt_cached_ptd_host &ptd, va_list const arglist) throw ()

Protected Member Functions inherited from __crt_stdio_output::common_data< Character >
	common_data (__crt_cached_ptd_host &ptd)

char *&	tchar_string (char) throw ()

wchar_t *&	tchar_string (wchar_t) throw ()

Character *&	tchar_string () throw ()

Private Types
enum class	pass : unsigned { not_started , position_scan , output , finished }

enum class	mode : unsigned { unknown , nonpositional , positional }

enum class	parameter_type : unsigned { unused , int32 , int64 , pointer , real64 }

Private Member Functions
bool	is_positional_parameter_reappearance_consistent (parameter_data const &parameter, parameter_type const actual_type, Character const format_type, length_modifier const length) throw ()

bool	validate_and_store_parameter_data (parameter_data &parameter, parameter_type const actual_type, Character const format_type, length_modifier const length) throw ()

Static Private Member Functions
template<typename T >
static parameter_type __cdecl	get_parameter_type (T *) throw ()

static parameter_type __cdecl	get_parameter_type (short) throw ()

static parameter_type __cdecl	get_parameter_type (unsigned short) throw ()

static parameter_type __cdecl	get_parameter_type (wchar_t) throw ()

static parameter_type __cdecl	get_parameter_type (int) throw ()

static parameter_type __cdecl	get_parameter_type (unsigned int) throw ()

static parameter_type __cdecl	get_parameter_type (__int64) throw ()

static parameter_type __cdecl	get_parameter_type (unsigned __int64) throw ()

static parameter_type __cdecl	get_parameter_type (_CRT_DOUBLE) throw ()

template<typename Character2 >
static bool __cdecl	is_pointer_specifier (Character2 const specifier) throw ()

template<typename Character2 >
static bool __cdecl	is_string_specifier (Character2 const specifier) throw ()

template<typename Character2 >
static bool __cdecl	is_character_specifier (Character2 const specifier) throw ()

template<typename Character2 >
static bool __cdecl	is_integral_specifier (Character2 const specifier) throw ()

Private Attributes
pass	_current_pass

mode	_format_mode

Character const *	_format

parameter_data	_parameters [_ARGMAX]

int	_maximum_index

int	_type_index

Additional Inherited Members
Static Protected Member Functions inherited from __crt_stdio_output::format_validation_base< Character, OutputAdapter >
static unsigned	state_count () throw ()

static printf_state_transition_table const &	state_transition_table () throw ()

Static Protected Member Functions inherited from __crt_stdio_output::standard_base< Character, OutputAdapter >
static unsigned	state_count () throw ()

static printf_state_transition_table const &	state_transition_table () throw ()

Protected Attributes inherited from __crt_stdio_output::output_adapter_data< Character, OutputAdapter >
OutputAdapter	_output_adapter

Protected Attributes inherited from __crt_stdio_output::common_data< Character >
uint64_t	_options

__crt_cached_ptd_host &	_ptd

Character const *	_format_it

va_list	_valist_it

int	_characters_written

state	_state

unsigned	_flags

int	_field_width

int	_precision

length_modifier	_length

bool	_suppress_output

Character	_format_char

union {
char * _narrow_string

wchar_t * _wide_string

};

int	_string_length

bool	_string_is_wide

formatting_buffer	_buffer

Detailed Description

template<typename Character, typename OutputAdapter>
class __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >

Definition at line 1193 of file corecrt_internal_stdio_output.h.

Member Typedef Documentation

◆ base_type

template<typename Character , typename OutputAdapter >

typedef format_validation_base<Character, OutputAdapter> __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::base_type

protected

Definition at line 1212 of file corecrt_internal_stdio_output.h.

◆ char_traits

template<typename Character , typename OutputAdapter >

typedef __crt_char_traits<Character> __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::char_traits

protected

Definition at line 1213 of file corecrt_internal_stdio_output.h.

◆ self_type

template<typename Character , typename OutputAdapter >

typedef positional_parameter_base __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::self_type

protected

Definition at line 1211 of file corecrt_internal_stdio_output.h.

Member Enumeration Documentation

◆ mode

template<typename Character , typename OutputAdapter >

enum class __crt_stdio_output::positional_parameter_base::mode : unsigned

strongprivate

Enumerator
unknown
nonpositional
positional

Definition at line 1501 of file corecrt_internal_stdio_output.h.

    {
        unknown,
        nonpositional,
        positional
    };

◆ parameter_type

template<typename Character , typename OutputAdapter >

enum class __crt_stdio_output::positional_parameter_base::parameter_type : unsigned

strongprivate

Enumerator
unused
int32
int64
pointer
real64

Definition at line 1511 of file corecrt_internal_stdio_output.h.

    {
        unused,
        int32,
        int64,
        pointer,
        real64
    };

◆ pass

template<typename Character , typename OutputAdapter >

enum class __crt_stdio_output::positional_parameter_base::pass : unsigned

strongprivate

Enumerator
not_started
position_scan
output
finished

Definition at line 1490 of file corecrt_internal_stdio_output.h.

    {
        not_started,
        position_scan,
        output,
        finished
    };

Constructor & Destructor Documentation

◆ positional_parameter_base()

template<typename Character , typename OutputAdapter >

template<typename... Ts>

__crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::positional_parameter_base	(	Ts &&...	arguments	)
throw	(
	)

inlineprotected

Definition at line 1216 of file corecrt_internal_stdio_output.h.

        : format_validation_base<Character, OutputAdapter>{arguments...     },
          _current_pass         {pass::not_started},
          _format_mode          {mode::unknown    },
          _format               {_format_it       },
          _type_index           {-1               },
          _maximum_index        {-1               }
    {
        // Note that we do not zero-initialize the parameter data table until
        // the first positional parameter is encountered in the format string.
    }

Member Function Documentation

◆ advance_to_next_pass()

template<typename Character , typename OutputAdapter >

bool __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::advance_to_next_pass	(	)
throw	(
	)

inlineprotected

Definition at line 1228 of file corecrt_internal_stdio_output.h.

    {
        _current_pass = static_cast<pass>(static_cast<unsigned>(_current_pass) + 1);
        if (_current_pass == pass::finished)
            return false;
 
        // If we are in the output pass but the format string is a non-positional,
        // ordinary format string, then we do not need a second pass:
        if (_current_pass == pass::output && _format_mode == mode::nonpositional)
            return false;
 
        // All characters before the first format specifier are output in the
        // first pass.  We reset the format mode to 'unknown' to ensure that
        // they are not output again during the second pass.
        _format_mode = mode::unknown;
 
        _maximum_index = -1;
        _type_index    = -1;
 
        _field_width = 0;
        _precision   = 0;
        _format_it   = _format;
 
        return true;
    }

◆ extract_argument_from_va_list()

template<typename Character , typename OutputAdapter >

template<typename RequestedParameterType , typename ActualParameterType >

bool __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::extract_argument_from_va_list	(	ActualParameterType &	result	)
throw	(
	)

inlineprotected

Definition at line 1295 of file corecrt_internal_stdio_output.h.

    {
        if (_format_mode == mode::nonpositional)
        {
            return base_type::template extract_argument_from_va_list<RequestedParameterType>(result);
        }
 
        _UCRT_VALIDATE_RETURN(_ptd, _type_index >= 0 && _type_index < _ARGMAX, EINVAL, false);
 
        if (_current_pass == pass::position_scan)
        {
            return validate_and_store_parameter_data(
                _parameters[_type_index],
                get_parameter_type(RequestedParameterType()),
                _format_char,
                _length
            );
        }
        else
        {
            result = static_cast<ActualParameterType>(peek_va_arg<RequestedParameterType>(_parameters[_type_index]._valist_it));
            return true;
        }
    }

◆ get_parameter_type() [1/9]

template<typename Character , typename OutputAdapter >

static parameter_type __cdecl __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::get_parameter_type	(	__int64	)
throw	(
	)

inlinestaticprivate

Definition at line 1546 of file corecrt_internal_stdio_output.h.

1546{ return parameter_type::int64; }

◆ get_parameter_type() [2/9]

template<typename Character , typename OutputAdapter >

static parameter_type __cdecl __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::get_parameter_type	(	_CRT_DOUBLE	)
throw	(
	)

inlinestaticprivate

Definition at line 1548 of file corecrt_internal_stdio_output.h.

1548{ return parameter_type::real64; }

◆ get_parameter_type() [3/9]

template<typename Character , typename OutputAdapter >

static parameter_type __cdecl __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::get_parameter_type	(	int	)
throw	(
	)

inlinestaticprivate

Definition at line 1544 of file corecrt_internal_stdio_output.h.

1544{ return parameter_type::int32; }

◆ get_parameter_type() [4/9]

template<typename Character , typename OutputAdapter >

static parameter_type __cdecl __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::get_parameter_type	(	short	)
throw	(
	)

inlinestaticprivate

Definition at line 1541 of file corecrt_internal_stdio_output.h.

1541{ return parameter_type::int32; }

◆ get_parameter_type() [5/9]

template<typename Character , typename OutputAdapter >

template<typename T >

static parameter_type __cdecl __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::get_parameter_type	(	T *	)
throw	(
	)

inlinestaticprivate

Definition at line 1540 of file corecrt_internal_stdio_output.h.

1540{ return parameter_type::pointer; }

Referenced by __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::extract_argument_from_va_list().

◆ get_parameter_type() [6/9]

template<typename Character , typename OutputAdapter >

static parameter_type __cdecl __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::get_parameter_type	(	unsigned	__int64	)
throw	(
	)

inlinestaticprivate

Definition at line 1547 of file corecrt_internal_stdio_output.h.

1547{ return parameter_type::int64; }

◆ get_parameter_type() [7/9]

template<typename Character , typename OutputAdapter >

static parameter_type __cdecl __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::get_parameter_type	(	unsigned int	)
throw	(
	)

inlinestaticprivate

Definition at line 1545 of file corecrt_internal_stdio_output.h.

1545{ return parameter_type::int32; }

◆ get_parameter_type() [8/9]

template<typename Character , typename OutputAdapter >

static parameter_type __cdecl __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::get_parameter_type	(	unsigned short	)
throw	(
	)

inlinestaticprivate

Definition at line 1542 of file corecrt_internal_stdio_output.h.

1542{ return parameter_type::int32; }

◆ get_parameter_type() [9/9]

template<typename Character , typename OutputAdapter >

static parameter_type __cdecl __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::get_parameter_type	(	wchar_t	)
throw	(
	)

inlinestaticprivate

Definition at line 1543 of file corecrt_internal_stdio_output.h.

1543{ return parameter_type::int32; }

◆ is_character_specifier()

template<typename Character , typename OutputAdapter >

template<typename Character2 >

static bool __cdecl __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::is_character_specifier	(	Character2 const	specifier	)
throw	(
	)

inlinestaticprivate

Definition at line 1653 of file corecrt_internal_stdio_output.h.

    {
        return specifier == 'c' || specifier == 'C';
    }

Referenced by __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::is_positional_parameter_reappearance_consistent().

◆ is_integral_specifier()

template<typename Character , typename OutputAdapter >

template<typename Character2 >

static bool __cdecl __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::is_integral_specifier	(	Character2 const	specifier	)
throw	(
	)

inlinestaticprivate

Definition at line 1659 of file corecrt_internal_stdio_output.h.

    {
        return specifier == 'd' || specifier == 'i' || specifier == 'o'
            || specifier == 'u' || specifier == 'x' || specifier == 'X'
            || specifier == '*';
    }

Referenced by __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::is_positional_parameter_reappearance_consistent().

◆ is_pointer_specifier()

template<typename Character , typename OutputAdapter >

template<typename Character2 >

static bool __cdecl __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::is_pointer_specifier	(	Character2 const	specifier	)
throw	(
	)

inlinestaticprivate

Definition at line 1641 of file corecrt_internal_stdio_output.h.

    {
        return specifier == 'p';
    }

Referenced by __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::is_positional_parameter_reappearance_consistent().

◆ is_positional_parameter_reappearance_consistent()

template<typename Character , typename OutputAdapter >

bool __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::is_positional_parameter_reappearance_consistent	(	parameter_data const &	parameter,
		parameter_type const	actual_type,
		Character const	format_type,
		length_modifier const	length
	)
throw	(
	)

inlineprivate

Definition at line 1559 of file corecrt_internal_stdio_output.h.

    {
        // Pointer format specifiers are exclusive; a parameter that previously
        // appeared as a pointer may not reappear as a non-pointer, and vice-
        // versa.
        bool const old_is_pointer{is_pointer_specifier(parameter._format_type)};
        bool const new_is_pointer{is_pointer_specifier(format_type)};
        if (old_is_pointer || new_is_pointer)
        {
            return old_is_pointer == new_is_pointer;
        }
 
        // String format specifiers are exclusive, just like pointer specifiers.
        // We must also ensure that the two appearances match in string type:
        // either both must be wide or both must be narrow.
        bool const old_is_string{is_string_specifier(parameter._format_type)};
        bool const new_is_string{is_string_specifier(format_type)};
 
        bool const old_is_character{is_character_specifier(parameter._format_type)};
        bool const new_is_character{is_character_specifier(format_type)};
        if (old_is_string || new_is_string || old_is_character || new_is_character)
        {
            if (old_is_string != new_is_string || old_is_character != new_is_character)
                return false;
 
            bool const old_is_wide{is_wide_character_specifier(_options, parameter._format_type, parameter._length)};
            bool const new_is_wide{is_wide_character_specifier(_options, format_type, length)};
            if (old_is_wide != new_is_wide)
                return false;
 
            return true;
        }
 
        // Numeric specifiers are exclusive:  either both appearances must be
        // numeric specifiers or neither appearance may be a numeric specifier.
        // Additionally, if both appearances are numeric specifiers, they must
        // both have the same width.
        bool const old_is_integral{is_integral_specifier(parameter._format_type)};
        bool const new_is_integral{is_integral_specifier(format_type)};
        if (old_is_integral || new_is_integral)
        {
            if (old_is_integral != new_is_integral)
                return false;
 
            if ((parameter._length == length_modifier::I) != (length == length_modifier::I))
                return false;
 
            return to_integer_size(parameter._length) == to_integer_size(length);
        }
 
        return parameter._actual_type == actual_type;
    }

Referenced by __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::validate_and_store_parameter_data().

◆ is_string_specifier()

template<typename Character , typename OutputAdapter >

template<typename Character2 >

static bool __cdecl __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::is_string_specifier	(	Character2 const	specifier	)
throw	(
	)

inlinestaticprivate

Definition at line 1647 of file corecrt_internal_stdio_output.h.

    {
        return specifier == 's' || specifier == 'S';
    }

Referenced by __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::is_positional_parameter_reappearance_consistent().

◆ should_format()

template<typename Character , typename OutputAdapter >

bool __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::should_format	(	)
throw	(
	)

inlineprotected

Definition at line 1289 of file corecrt_internal_stdio_output.h.

    {
        return _current_pass != pass::position_scan || _format_mode == mode::nonpositional;
    }

◆ should_skip_normal_state_processing()

template<typename Character , typename OutputAdapter >

bool __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::should_skip_normal_state_processing	(	)
throw	(
	)

inlineprotected

Definition at line 1404 of file corecrt_internal_stdio_output.h.

    {
        if (_current_pass == pass::position_scan && _format_mode == mode::positional)
            return true;
 
        if (_current_pass == pass::output && _format_mode == mode::unknown)
            return true;
 
        // We do not output during the first pass if we have already come across
        // a positional format specifier.  All characters before the first format
        // specifier are output in the first pass.  We need to check the format
        // type during the second pass to ensure that they are not output a second
        // time.
        return false;
    }

◆ should_skip_type_state_output()

template<typename Character , typename OutputAdapter >

bool __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::should_skip_type_state_output	(	)	const
throw	(
	)

inlineprotected

Definition at line 1476 of file corecrt_internal_stdio_output.h.

    {
        return _format_mode == mode::positional && _current_pass == pass::position_scan;
    }

◆ update_field_width()

template<typename Character , typename OutputAdapter >

bool __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::update_field_width	(	)
throw	(
	)

inlineprotected

Definition at line 1320 of file corecrt_internal_stdio_output.h.

    {
        if (_format_mode == mode::nonpositional)
        {
            return base_type::update_field_width();
        }
 
        Character* end_pointer{nullptr};
        int const width_index{_tcstol_internal(_ptd, _format_it, &end_pointer, 10) - 1};
        _format_it = end_pointer + 1;
 
        if (_current_pass == pass::position_scan)
        {
            _UCRT_VALIDATE_RETURN(_ptd, width_index >= 0 && *end_pointer == '$' && width_index < _ARGMAX, EINVAL, false);
 
            _maximum_index = width_index > _maximum_index
                ? width_index
                : _maximum_index;
 
            return validate_and_store_parameter_data(
                _parameters[width_index],
                parameter_type::int32,
                _format_char,
                _length
            );
        }
        else
        {
            _field_width = peek_va_arg<int>(_parameters[width_index]._valist_it);
        }
 
        return true;
    }

◆ update_precision()

template<typename Character , typename OutputAdapter >

bool __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::update_precision	(	)
throw	(
	)

inlineprotected

Definition at line 1354 of file corecrt_internal_stdio_output.h.

    {
        if (_format_mode == mode::nonpositional)
        {
            return base_type::update_precision();
        }
 
        Character* end_pointer{nullptr};
        int const precision_index{_tcstol_internal(_ptd, _format_it, &end_pointer, 10) - 1};
        _format_it = end_pointer + 1;
 
        if (_current_pass == pass::position_scan)
        {
            _UCRT_VALIDATE_RETURN(_ptd, precision_index >= 0 && *end_pointer == '$' && precision_index < _ARGMAX, EINVAL, false);
 
            _maximum_index = precision_index > _maximum_index
                ? precision_index
                : _maximum_index;
 
            return validate_and_store_parameter_data(
                _parameters[precision_index],
                parameter_type::int32,
                _format_char,
                _length
            );
        }
        else
        {
            _precision = peek_va_arg<int>(_parameters[precision_index]._valist_it);
        }
 
        return true;
    }

◆ validate_and_store_parameter_data()

template<typename Character , typename OutputAdapter >

bool __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::validate_and_store_parameter_data	(	parameter_data &	parameter,
		parameter_type const	actual_type,
		Character const	format_type,
		length_modifier const	length
	)
throw	(
	)

inlineprivate

Definition at line 1617 of file corecrt_internal_stdio_output.h.

    {
        if (parameter._actual_type == parameter_type::unused)
        {
            parameter._actual_type = actual_type;
            parameter._format_type = format_type;
            parameter._length      = length;
        }
        else
        {
            _UCRT_VALIDATE_RETURN(_ptd, is_positional_parameter_reappearance_consistent(
                parameter, actual_type, format_type, length
            ), EINVAL, false);
        }
 
        return true;
    }

Referenced by __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::extract_argument_from_va_list(), __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::update_field_width(), __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::update_precision(), and __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::validate_state_for_type_case_a().

◆ validate_and_update_state_at_beginning_of_format_character()

template<typename Character , typename OutputAdapter >

bool __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::validate_and_update_state_at_beginning_of_format_character	(	)
throw	(
	)

inlineprotected

Definition at line 1420 of file corecrt_internal_stdio_output.h.

    {
        // We're looking for a format specifier, so we'll have just seen a '%'
        // and the next character is not a '%':
        if (_state != state::percent || *_format_it == '%')
            return true;
 
        // When we encounter the first format specifier, we determine whether
        // the format string is a positional format string or a standard format
        // string.
        if (_format_mode == mode::unknown)
        {
            Character* end_pointer{nullptr};
 
            // Only digits are permitted between the % and the $ in the positional format specifier.
            if (*_format_it < '0' || *_format_it > '9')
            {
                _format_mode = mode::nonpositional;
            }
            else if (_tcstol_internal(_ptd, _format_it, &end_pointer, 10) > 0 && *end_pointer == '$')
            {
                if (_current_pass == pass::position_scan)
                {
                    memset(_parameters, 0, sizeof(_parameters));
                }
 
                _format_mode = mode::positional;
            }
            else
            {
                _format_mode = mode::nonpositional;
            }
        }
 
        if (_format_mode != mode::positional)
        {
            return true;
        }
 
        Character* end_pointer{nullptr};
        _type_index = _tcstol_internal(_ptd, _format_it, &end_pointer, 10) - 1;
        _format_it = end_pointer + 1;
 
        if (_current_pass != pass::position_scan)
            return true;
 
        // We do not re-perform the type validations during the second pass...
        _UCRT_VALIDATE_RETURN(_ptd, _type_index >= 0 && *end_pointer == '$' && _type_index < _ARGMAX, EINVAL, false);
 
        _maximum_index = _type_index > _maximum_index
            ? _type_index
            : _maximum_index;
 
        return true;
    }

◆ validate_and_update_state_at_end_of_format_string()

template<typename Character , typename OutputAdapter >

bool __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::validate_and_update_state_at_end_of_format_string	(	)
throw	(
	)

inlineprotected

Definition at line 1254 of file corecrt_internal_stdio_output.h.

    {
        if (!base_type::validate_and_update_state_at_end_of_format_string())
            return false;
 
        if (_format_mode != mode::positional || _current_pass != pass::position_scan)
            return true;
 
        // At the end of the first pass, we have the types filled into the
        // arg_type member for each positional parameter.  We now need to get
        // the argument pointer for each positional parameter and store it
        // into the arg_ptr member.
        parameter_data* const first{_parameters};
        parameter_data* const last {_parameters + _maximum_index + 1};
        for (parameter_data* it{first}; it != last; ++it)
        {
            it->_valist_it = _valist_it;
 
            switch (it->_actual_type)
            {
            case parameter_type::int32:   read_va_arg<int        >(_valist_it); break;
            case parameter_type::int64:   read_va_arg<__int64    >(_valist_it); break;
            case parameter_type::pointer: read_va_arg<void*      >(_valist_it); break;
            case parameter_type::real64:  read_va_arg<_CRT_DOUBLE>(_valist_it); break;
 
            default:
                // We should never reach this point:
                _UCRT_VALIDATE_RETURN(_ptd, ("Missing position in the format string", 0), EINVAL, false);
                break;
            }
        }
 
        return true;
    }

◆ validate_state_for_type_case_a()

template<typename Character , typename OutputAdapter >

bool __crt_stdio_output::positional_parameter_base< Character, OutputAdapter >::validate_state_for_type_case_a	(	)
throw	(
	)

inlineprotected

Definition at line 1388 of file corecrt_internal_stdio_output.h.

    {
        if (_format_mode == mode::positional && _current_pass == pass::position_scan)
        {
            _UCRT_VALIDATE_RETURN(_ptd, _type_index >= 0 && _type_index < _ARGMAX, EINVAL, false);
            return validate_and_store_parameter_data(
                _parameters[_type_index],
                parameter_type::real64,
                _format_char,
                _length
            );
        }
 
        return true;
    }