#include <corecrt_internal_stdio_input.h>

Collaboration diagram for __crt_stdio_input::input_processor< Character, InputAdapter >:

[legend]

Public Types
using	traits = __acrt_stdio_char_traits< Character >

using	char_type = Character

using	unsigned_char_type = typename traits::unsigned_char_type

using	int_type = typename traits::int_type

Public Member Functions
	input_processor (InputAdapter const &input_adapter, uint64_t const options, char_type const *const format, _locale_t const locale, va_list const arglist) throw ()

int	process () throw ()

Private Member Functions
bool	process_state () throw ()

bool	process_whitespace () throw ()

bool	process_literal_character () throw ()

bool	process_literal_character_tchar (char const initial_character) throw ()

bool	process_literal_character_tchar (wchar_t) throw ()

bool	process_conversion_specifier () throw ()

bool	process_string_specifier (conversion_mode const mode) throw ()

template<typename BufferCharacter >
bool	process_string_specifier_tchar (conversion_mode const mode, BufferCharacter) throw ()

bool	write_character (char const buffer, size_t const buffer_count, char &buffer_pointer, size_t &buffer_remaining, char const c) throw ()

bool	write_character (char const buffer, size_t const buffer_count, char &buffer_pointer, size_t &buffer_remaining, wchar_t const c) throw ()

bool	write_character (wchar_t _UNALIGNED const buffer, size_t const buffer_count, wchar_t _UNALIGNED &buffer_pointer, size_t &buffer_remaining, char const c) throw ()

bool	write_character (wchar_t _UNALIGNED const buffer, size_t const buffer_count, wchar_t _UNALIGNED &buffer_pointer, size_t &buffer_remaining, wchar_t const c) throw ()

bool	is_character_allowed_in_string (conversion_mode const mode, int_type const c) const throw ()

bool	process_integer_specifier (unsigned base, bool const is_signed) throw ()

template<typename FloatingType >
bool	process_floating_point_specifier_t () throw ()

bool	process_floating_point_specifier () throw ()

bool	process_character_count_specifier () throw ()

bool	write_integer (uint64_t const value) throw ()

template<typename FloatingType >
bool	write_floating_point (FloatingType const &value) throw ()

bool	secure_buffers () const throw ()

Static Private Member Functions
template<typename BufferCharacter >
static void	fill_buffer (BufferCharacter _UNALIGNED *const buffer, size_t const buffer_count, size_t const buffer_remaining) throw ()

template<typename BufferCharacter >
static void	reset_buffer (BufferCharacter _UNALIGNED *const buffer, size_t const buffer_count) throw ()

Private Attributes
uint64_t	_options

InputAdapter	_input_adapter

format_string_parser< char_type >	_format_parser

_locale_t	_locale

va_list	_valist

size_t	_receiving_arguments_assigned

Detailed Description

template<typename Character, typename InputAdapter>
class __crt_stdio_input::input_processor< Character, InputAdapter >

Definition at line 1065 of file corecrt_internal_stdio_input.h.

Member Typedef Documentation

◆ char_type

template<typename Character , typename InputAdapter >

using __crt_stdio_input::input_processor< Character, InputAdapter >::char_type = Character

Definition at line 1070 of file corecrt_internal_stdio_input.h.

◆ int_type

template<typename Character , typename InputAdapter >

using __crt_stdio_input::input_processor< Character, InputAdapter >::int_type = typename traits::int_type

Definition at line 1072 of file corecrt_internal_stdio_input.h.

◆ traits

template<typename Character , typename InputAdapter >

using __crt_stdio_input::input_processor< Character, InputAdapter >::traits = __acrt_stdio_char_traits<Character>

Definition at line 1069 of file corecrt_internal_stdio_input.h.

◆ unsigned_char_type

template<typename Character , typename InputAdapter >

using __crt_stdio_input::input_processor< Character, InputAdapter >::unsigned_char_type = typename traits::unsigned_char_type

Definition at line 1071 of file corecrt_internal_stdio_input.h.

Constructor & Destructor Documentation

◆ input_processor()

template<typename Character , typename InputAdapter >

__crt_stdio_input::input_processor< Character, InputAdapter >::input_processor	(	InputAdapter const &	input_adapter,
		uint64_t const	options,
		char_type const *const	format,
		_locale_t const	locale,
		va_list const	arglist
	)
throw	(
	)

inline

Definition at line 1074 of file corecrt_internal_stdio_input.h.

        : _options                        {options                                                     },
          _input_adapter                  {input_adapter                                               },
          _format_parser                  {options, reinterpret_cast<unsigned_char_type const*>(format)},
          _locale                         {locale                                                      },
          _valist                         {arglist                                                     },
          _receiving_arguments_assigned   {0                                                           }
    {
    }

Member Function Documentation

◆ fill_buffer()

template<typename Character , typename InputAdapter >

template<typename BufferCharacter >

static void __crt_stdio_input::input_processor< Character, InputAdapter >::fill_buffer	(	BufferCharacter _UNALIGNED *const	buffer,
		size_t const	buffer_count,
		size_t const	buffer_remaining
	)
throw	(
	)

inlinestaticprivate

Definition at line 1441 of file corecrt_internal_stdio_input.h.

    {
        UNREFERENCED_PARAMETER(buffer);
        UNREFERENCED_PARAMETER(buffer_remaining);
 
        if (buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE)
            return;
 
        _FILL_STRING(buffer, buffer_count, buffer_count - buffer_remaining);
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_string_specifier_tchar().

◆ is_character_allowed_in_string()

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::is_character_allowed_in_string	(	conversion_mode const	mode,
		int_type const	c
	)		const
throw	(
	)

inlineprivate

Definition at line 1470 of file corecrt_internal_stdio_input.h.

    {
        if (c == traits::eof)
            return false;
 
        switch (mode)
        {
        case conversion_mode::character:
        {
            return true;
        }
 
        case conversion_mode::string:
        {
            if (c >= '\t' && c <= '\r')
                return false;
 
            if (c == ' ')
                return false;
 
            return true;
        }
 
        case conversion_mode::scanset:
        {
            if (!_format_parser.scanset().test(static_cast<unsigned_char_type>(c)))
                return false;
 
            return true;
        }
        }
 
        return false;
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_string_specifier_tchar().

◆ process()

template<typename Character , typename InputAdapter >

int __crt_stdio_input::input_processor< Character, InputAdapter >::process	(	)
throw	(
	)

inline

Definition at line 1090 of file corecrt_internal_stdio_input.h.

    {
        if (!_input_adapter.validate())
            return EOF;
 
        if (!_format_parser.validate())
            return EOF;
 
        while (_format_parser.advance())
        {
            if (!process_state())
                break;
        }
 
        // Return value is number of receiving arguments assigned,
        // or EOF if read failure occurs before the first receiving argument was assigned.
        int result{static_cast<int>(_receiving_arguments_assigned)};
 
        // If we haven't reached the 'end_of_string' parse, then a read error occurred.
        if (_receiving_arguments_assigned == 0 && _format_parser.kind() != format_directive_kind::end_of_string)
        {
            int_type const c{_input_adapter.get()};
            if (c == traits::eof)
                result = EOF;
 
            _input_adapter.unget(c);
        }
 
        if (secure_buffers())
        {
            _VALIDATE_RETURN(_format_parser.error_code() == 0, _format_parser.error_code(), result);
        }
 
        return result;
    }

◆ process_character_count_specifier()

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::process_character_count_specifier	(	)
throw	(
	)

inlineprivate

Definition at line 1556 of file corecrt_internal_stdio_input.h.

    {
        if (_format_parser.suppress_assignment())
            return true;
 
        return write_integer(_input_adapter.characters_read());
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_conversion_specifier().

◆ process_conversion_specifier()

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::process_conversion_specifier	(	)
throw	(
	)

inlineprivate

Definition at line 1206 of file corecrt_internal_stdio_input.h.

    {
        switch (_format_parser.mode())
        {
        case conversion_mode::character:              return process_string_specifier(conversion_mode::character);
        case conversion_mode::string:                 return process_string_specifier(conversion_mode::string);
        case conversion_mode::scanset:                return process_string_specifier(conversion_mode::scanset);
 
        case conversion_mode::signed_unknown:         return process_integer_specifier( 0,  true);
        case conversion_mode::signed_decimal:         return process_integer_specifier(10,  true);
        case conversion_mode::unsigned_octal:         return process_integer_specifier( 8, false);
        case conversion_mode::unsigned_decimal:       return process_integer_specifier(10, false);
        case conversion_mode::unsigned_hexadecimal:   return process_integer_specifier(16, false);
 
        case conversion_mode::floating_point:         return process_floating_point_specifier();
 
        case conversion_mode::report_character_count: return process_character_count_specifier();
        }
 
        return false;
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_state().

◆ process_floating_point_specifier()

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::process_floating_point_specifier	(	)
throw	(
	)

inlineprivate

Definition at line 1544 of file corecrt_internal_stdio_input.h.

    {
        process_whitespace();
 
        switch (_format_parser.length())
        {
        case sizeof(float):  return process_floating_point_specifier_t<float >();
        case sizeof(double): return process_floating_point_specifier_t<double>();
        default:             return false;
        }
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_conversion_specifier().

◆ process_floating_point_specifier_t()

template<typename Character , typename InputAdapter >

template<typename FloatingType >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::process_floating_point_specifier_t	(	)
throw	(
	)

inlineprivate

Definition at line 1526 of file corecrt_internal_stdio_input.h.

    {
        bool succeeded{false};
        FloatingType value{};
        SLD_STATUS const status{__crt_strtox::parse_floating_point(
            _locale,
            __crt_strtox::make_input_adapter_character_source(&_input_adapter, _format_parser.width(), &succeeded),
            &value)};
 
        if (!succeeded || status == SLD_NODIGITS)
            return false;
 
        if (_format_parser.suppress_assignment())
            return true;
 
        return write_floating_point(value);
    }

◆ process_integer_specifier()

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::process_integer_specifier	(	unsigned	base,
		bool const	is_signed
	)
throw	(
	)

inlineprivate

Definition at line 1505 of file corecrt_internal_stdio_input.h.

    {
        process_whitespace();
 
        bool succeeded{false};
        uint64_t const number{__crt_strtox::parse_integer<uint64_t>(
            _locale,
            __crt_strtox::make_input_adapter_character_source(&_input_adapter, _format_parser.width(), &succeeded),
            base,
            is_signed)};
 
        if (!succeeded)
            return false;
 
        if (_format_parser.suppress_assignment())
            return true;
 
        return write_integer(number);
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_conversion_specifier().

◆ process_literal_character()

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::process_literal_character	(	)
throw	(
	)

inlineprivate

Definition at line 1166 of file corecrt_internal_stdio_input.h.

    {
        int_type const c{_input_adapter.get()};
        if (c == traits::eof)
        {
            return false;
        }
 
        if (c != _format_parser.literal_character_lead())
        {
            _input_adapter.unget(c);
            return false;
        }
 
        return process_literal_character_tchar(static_cast<char_type>(c));
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_state().

◆ process_literal_character_tchar() [1/2]

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::process_literal_character_tchar	(	char const	initial_character	)
throw	(
	)

inlineprivate

Definition at line 1183 of file corecrt_internal_stdio_input.h.

    {
        if (isleadbyte(static_cast<unsigned char>(initial_character)) == 0)
        {
            return true;
        }
 
        int_type const c{_input_adapter.get()};
        if (c != _format_parser.literal_character_trail())
        {
            _input_adapter.unget(c);
            _input_adapter.unget(initial_character);
            return false;
        }
 
        return true;
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_literal_character().

◆ process_literal_character_tchar() [2/2]

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::process_literal_character_tchar	(	wchar_t	)
throw	(
	)

inlineprivate

Definition at line 1201 of file corecrt_internal_stdio_input.h.

    {
        return true; // No-op for Unicode
    }

◆ process_state()

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::process_state	(	)
throw	(
	)

inlineprivate

Definition at line 1128 of file corecrt_internal_stdio_input.h.

    {
        switch (_format_parser.kind())
        {
        case format_directive_kind::whitespace:
        {
            return process_whitespace();
        }
 
        case format_directive_kind::literal_character:
        {
            return process_literal_character();
        }
 
        case format_directive_kind::conversion_specifier:
        {
            bool const result{process_conversion_specifier()};
            // %n and suppressed conversion specifiers are not considered receiving arguments
            if (result
                && _format_parser.mode() != conversion_mode::report_character_count
                && !_format_parser.suppress_assignment())
            {
                ++_receiving_arguments_assigned;
            }
 
            return result;
        }
        }
 
        return false;
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process().

◆ process_string_specifier()

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::process_string_specifier	(	conversion_mode const	mode	)
throw	(
	)

inlineprivate

Definition at line 1228 of file corecrt_internal_stdio_input.h.

    {
        if (mode == conversion_mode::string)
        {
            process_whitespace();
        }
 
        switch (_format_parser.length())
        {
        case sizeof(char):    return process_string_specifier_tchar(mode, char());
        case sizeof(wchar_t): return process_string_specifier_tchar(mode, wchar_t());
        default:              return false;
        }
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_conversion_specifier().

◆ process_string_specifier_tchar()

template<typename Character , typename InputAdapter >

template<typename BufferCharacter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::process_string_specifier_tchar	(	conversion_mode const	mode,
		BufferCharacter
	)
throw	(
	)

inlineprivate

Definition at line 1244 of file corecrt_internal_stdio_input.h.

    {
        BufferCharacter _UNALIGNED* buffer{nullptr};
        if (!_format_parser.suppress_assignment())
        {
            buffer = va_arg(_valist, BufferCharacter _UNALIGNED*);
            _VALIDATE_RETURN(buffer != nullptr, EINVAL, false);
        }
 
        size_t const buffer_count{buffer != nullptr && secure_buffers()
            ? va_arg(_valist, unsigned)
            : _CRT_UNBOUNDED_BUFFER_SIZE
        };
 
        if (buffer_count == 0)
        {
            if (_options & _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY)
            {
                // For legacy compatibility:  in the old implementation, we failed
                // to unget the last character read if the buffer had a size of zero
                _input_adapter.get();
 
                // Additionally, we wrote a terminator to the buffer, even though
                // the caller said the buffer had zero elements
                buffer[0] = '\0';
            }
 
            errno = ENOMEM;
            return false;
        }
 
        uint64_t const width{_format_parser.width()};
 
        BufferCharacter _UNALIGNED* buffer_pointer  {buffer      };
        size_t                      buffer_remaining{buffer_count};
 
        if (mode != conversion_mode::character && buffer_remaining != _CRT_UNBOUNDED_BUFFER_SIZE)
        {
            --buffer_remaining; // Leave room for terminator when scanning strings
        }
 
        uint64_t width_consumed{0};
        for (; width == 0 || width_consumed != width; ++width_consumed)
        {
            int_type c{_input_adapter.get()};
 
            if (!is_character_allowed_in_string(mode, c))
            {
                _input_adapter.unget(c);
                break;
            }
 
            if (_format_parser.suppress_assignment())
            {
                continue;
            }
 
            if (buffer_remaining == 0)
            {
                reset_buffer(buffer, buffer_count);
                errno = ENOMEM;
                return false;
            }
 
            if (!write_character(buffer, buffer_count, buffer_pointer, buffer_remaining, static_cast<char_type>(c)))
            {
                break;
            }
        }
 
        if (width_consumed == 0)
        {
            return false;
        }
 
        // The %c conversion specifier "matches a sequence of characters of exactly
        // the number specified by the field width."  The legacy behavior was to
        // match a sequence of up to that many characters.  If legacy mode was not
        // requested, fail if we did not match the requested number of characters:
        if (mode == conversion_mode::character &&
            width_consumed != width &&
            (_options & _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY) == 0)
        {
            return false;
        }
 
        if (_format_parser.suppress_assignment())
        {
            return true;
        }
 
        if (mode != conversion_mode::character)
        {
            *buffer_pointer = '\0';
            fill_buffer(buffer, buffer_count, buffer_remaining);
        }
 
        return true;
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_string_specifier().

◆ process_whitespace()

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::process_whitespace	(	)
throw	(
	)

inlineprivate

Definition at line 1160 of file corecrt_internal_stdio_input.h.

    {
        _input_adapter.unget(skip_whitespace(_input_adapter, _locale));
        return true;
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_floating_point_specifier(), __crt_stdio_input::input_processor< Character, InputAdapter >::process_integer_specifier(), __crt_stdio_input::input_processor< Character, InputAdapter >::process_state(), and __crt_stdio_input::input_processor< Character, InputAdapter >::process_string_specifier().

◆ reset_buffer()

template<typename Character , typename InputAdapter >

template<typename BufferCharacter >

static void __crt_stdio_input::input_processor< Character, InputAdapter >::reset_buffer	(	BufferCharacter _UNALIGNED *const	buffer,
		size_t const	buffer_count
	)
throw	(
	)

inlinestaticprivate

Definition at line 1457 of file corecrt_internal_stdio_input.h.

    {
        UNREFERENCED_PARAMETER(buffer);
 
        if (buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE)
            return;
 
        _RESET_STRING(buffer, buffer_count);
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_string_specifier_tchar(), and __crt_stdio_input::input_processor< Character, InputAdapter >::write_character().

◆ secure_buffers()

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::secure_buffers	(	)	const
throw	(
	)

inlineprivate

Definition at line 1600 of file corecrt_internal_stdio_input.h.

    {
        return (_options & _CRT_INTERNAL_SCANF_SECURECRT) != 0;
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process(), and __crt_stdio_input::input_processor< Character, InputAdapter >::process_string_specifier_tchar().

◆ write_character() [1/4]

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::write_character	(	char *const	buffer,
		size_t const	buffer_count,
		char *&	buffer_pointer,
		size_t &	buffer_remaining,
		char const	c
	)
throw	(
	)

inlineprivate

Definition at line 1346 of file corecrt_internal_stdio_input.h.

    {
        UNREFERENCED_PARAMETER(buffer);
        UNREFERENCED_PARAMETER(buffer_count);
 
        *buffer_pointer++ = c;
        --buffer_remaining;
        return true;
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_string_specifier_tchar().

◆ write_character() [2/4]

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::write_character	(	char *const	buffer,
		size_t const	buffer_count,
		char *&	buffer_pointer,
		size_t &	buffer_remaining,
		wchar_t const	c
	)
throw	(
	)

inlineprivate

Definition at line 1362 of file corecrt_internal_stdio_input.h.

    {
        if (buffer_count == _CRT_UNBOUNDED_BUFFER_SIZE)
        {
            int narrow_count{0};
            if (_ERRCHECK_EINVAL_ERANGE(wctomb_s(&narrow_count, buffer_pointer, MB_LEN_MAX, c)) == 0)
            {
                buffer_pointer   += narrow_count;
                buffer_remaining -= narrow_count;
            }
        }
        else
        {
            int narrow_count{0};
            if (wctomb_s(&narrow_count, buffer_pointer, buffer_remaining, c) == ERANGE)
            {
                reset_buffer(buffer, buffer_count);
                return false;
            }
 
            if (narrow_count > 0)
            {
                buffer_pointer   += narrow_count;
                buffer_remaining -= narrow_count;
            }
        }
 
        return true;
    }

◆ write_character() [3/4]

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::write_character	(	wchar_t _UNALIGNED *const	buffer,
		size_t const	buffer_count,
		wchar_t _UNALIGNED *&	buffer_pointer,
		size_t &	buffer_remaining,
		char const	c
	)
throw	(
	)

inlineprivate

Definition at line 1398 of file corecrt_internal_stdio_input.h.

    {
        UNREFERENCED_PARAMETER(buffer);
        UNREFERENCED_PARAMETER(buffer_count);
 
        char narrow_temp[2]{c, '\0'};
        if (isleadbyte(static_cast<unsigned char>(c)))
        {
            narrow_temp[1] = static_cast<char>(_input_adapter.get());
        }
 
        wchar_t wide_temp{'?'};
 
        _mbtowc_l(&wide_temp, narrow_temp, _locale->locinfo->_public._locale_mb_cur_max, _locale);
 
        *buffer_pointer++ = c;
        --buffer_remaining;
        return true;
    }

◆ write_character() [4/4]

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::write_character	(	wchar_t _UNALIGNED *const	buffer,
		size_t const	buffer_count,
		wchar_t _UNALIGNED *&	buffer_pointer,
		size_t &	buffer_remaining,
		wchar_t const	c
	)
throw	(
	)

inlineprivate

Definition at line 1424 of file corecrt_internal_stdio_input.h.

    {
        UNREFERENCED_PARAMETER(buffer);
        UNREFERENCED_PARAMETER(buffer_count);
 
        *buffer_pointer++ = c;
        --buffer_remaining;
        return true;
    }

◆ write_floating_point()

template<typename Character , typename InputAdapter >

template<typename FloatingType >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::write_floating_point	(	FloatingType const &	value	)
throw	(
	)

inlineprivate

Definition at line 1582 of file corecrt_internal_stdio_input.h.

    {
        using integer_type = uintn_t<sizeof(FloatingType)>;
 
        void* const result_pointer{va_arg(_valist, void*)};
        _VALIDATE_RETURN(result_pointer != nullptr, EINVAL, false);
 
        _ASSERTE(sizeof(FloatingType) == _format_parser.length());
 
        // We write through the pointer as if it were an integer pointer, to
        // avoid floating point instructions that cause information loss for
        // special NaNs (signaling NaNs, indeterminates):
        *static_cast<integer_type*>(result_pointer) = reinterpret_cast<integer_type const&>(value);
        return true;
    }

Referenced by __crt_stdio_input::input_processor< Character, InputAdapter >::process_floating_point_specifier_t().

◆ write_integer()

template<typename Character , typename InputAdapter >

bool __crt_stdio_input::input_processor< Character, InputAdapter >::write_integer	(	uint64_t const	value	)
throw	(
	)

inlineprivate

Definition at line 1564 of file corecrt_internal_stdio_input.h.

    {
        void* const result_pointer{va_arg(_valist, void*)};
        _VALIDATE_RETURN(result_pointer != nullptr, EINVAL, false);
 
        switch (_format_parser.length())
        {
        case sizeof(uint8_t ): *static_cast<uint8_t *>(result_pointer) = static_cast<uint8_t >(value); return true;
        case sizeof(uint16_t): *static_cast<uint16_t*>(result_pointer) = static_cast<uint16_t>(value); return true;
        case sizeof(uint32_t): *static_cast<uint32_t*>(result_pointer) = static_cast<uint32_t>(value); return true;
        case sizeof(uint64_t): *static_cast<uint64_t*>(result_pointer) = static_cast<uint64_t>(value); return true;
        default:
            _ASSERTE(("Unexpected length specifier", false));
            return false;
        }
    }