__crt_stdio_output Namespace Reference

Classes
class	common_data
class	console_output_adapter
class	format_validation_base
class	formatting_buffer
class	output_adapter_common
class	output_adapter_data
class	output_processor
class	positional_parameter_base
class	spectre_mitigated_lookup_table
class	standard_base
struct	state_transition_pair
class	stream_output_adapter
class	string_output_adapter
struct	string_output_adapter_context

Typedefs
using	printf_state_transition_table = spectre_mitigated_lookup_table< state_transition_pair, 128 >

Enumerations
enum class	state : unsigned char {   normal , percent , flag , width ,   dot , precision , size , type ,   invalid }
enum class	character_type : unsigned char {   other , percent , dot , star ,   zero , digit , flag , size ,   type }
enum	FLAG : unsigned {   FL_SIGN = 0x01 , FL_SIGNSP = 0x02 , FL_LEFT = 0x04 , FL_LEADZERO = 0x08 ,   FL_SIGNED = 0x10 , FL_ALTERNATE = 0x20 , FL_NEGATIVE = 0x40 , FL_FORCEOCTAL = 0x80 }
enum class	length_modifier {   none , hh , h , l ,   ll , j , z , t ,   L , I , I32 , I64 ,   w , T , enumerator_count }

Functions
template<typename T >
T	read_va_arg (va_list &arglist) throw ()
template<typename T >
T	peek_va_arg (va_list arglist) throw ()
template<typename OutputAdapter , typename Character >
__forceinline void	write_multiple_characters (OutputAdapter const &adapter, Character const c, int const count, int *const count_written, __crt_cached_ptd_host &ptd) throw ()
void __cdecl	force_decimal_point (_Inout_z_ char *buffer, _locale_t const locale) throw ()
void __cdecl	crop_zeroes (_Inout_z_ char *buffer, _locale_t const locale) throw ()
	__declspec (selectany) printf_state_transition_table const standard_lookup_table_spectre
size_t __cdecl	to_integer_size (length_modifier const length) throw ()
template<typename Character >
bool __cdecl	is_wide_character_specifier (uint64_t const options, Character const format_type, length_modifier const length) throw ()

Typedef Documentation

printf_state_transition_table

using __crt_stdio_output::printf_state_transition_table = typedef spectre_mitigated_lookup_table<state_transition_pair, 128>

Definition at line 590 of file corecrt_internal_stdio_output.h.

Enumeration Type Documentation

character_type

enum class __crt_stdio_output::character_type : unsigned char

strong

Enumerator
other
percent
dot
star
zero
digit
flag
size
type

Definition at line 550 of file corecrt_internal_stdio_output.h.

{
    other,   // character with no special meaning
    percent, // '%'
    dot,     // '.'
    star,    // '*'
    zero,    // '0'
    digit,   // '1'..'9'
    flag,    // ' ', '+', '-', '#'
    size,    // 'h', 'l', 'L', 'N', 'F', 'w'
    type     // type specifying character
};

FLAG

enum __crt_stdio_output::FLAG : unsigned

Enumerator
FL_SIGN
FL_SIGNSP
FL_LEFT
FL_LEADZERO
FL_SIGNED
FL_ALTERNATE
FL_NEGATIVE
FL_FORCEOCTAL

Definition at line 792 of file corecrt_internal_stdio_output.h.

{
    FL_SIGN       = 0x01, // Put plus or minus in front
    FL_SIGNSP     = 0x02, // Put space or minus in front
    FL_LEFT       = 0x04, // Left justify
    FL_LEADZERO   = 0x08, // Pad with leading zeros
    FL_SIGNED     = 0x10, // Signed data given
    FL_ALTERNATE  = 0x20, // Alternate form requested
    FL_NEGATIVE   = 0x40, // Value is negative
    FL_FORCEOCTAL = 0x80, // Force leading '0' for octals
};

length_modifier

enum class __crt_stdio_output::length_modifier

strong

Enumerator
none
hh
h
l
ll
j
z
t
L
I
I32
I64
w
T
enumerator_count

Definition at line 804 of file corecrt_internal_stdio_output.h.

{
    none,
    hh,
    h,
    l,
    ll,
    j,
    z,
    t,
    L,
    I,
    I32,
    I64,
    w,
    T,
    enumerator_count
};

state

enum class __crt_stdio_output::state : unsigned char

strong

Enumerator
normal
percent
flag
width
dot
precision
size
type
invalid

Definition at line 533 of file corecrt_internal_stdio_output.h.

{
    normal,    // Normal state; outputting literal chars
    percent,   // Just read '%'
    flag,      // Just read flag character
    width,     // Just read width specifier
    dot,       // Just read '.'
    precision, // Just read precision specifier
    size,      // Just read size specifier
    type,      // Just read type specifier
    invalid    // Invalid format
};

Function Documentation

__declspec()

__crt_stdio_output::__declspec

(

selectany

)

const

Definition at line 594 of file corecrt_internal_stdio_output.h.

{
    /* prev state -> cur char ->    new state                   character type */
    /* normal     -> other    -> */ state::normal,    /* ' ' */ character_type::flag,
    /* percent    -> other    -> */ state::normal,    /* '!' */ character_type::other,
    /* flag       -> other    -> */ state::normal,    /* '"' */ character_type::other,
    /* width      -> other    -> */ state::normal,    /* '#' */ character_type::flag,
    /* dot        -> other    -> */ state::normal,    /* '$' */ character_type::other,
    /* precision  -> other    -> */ state::normal,    /* '%' */ character_type::percent,
    /* size       -> other    -> */ state::normal,    /* '&' */ character_type::other,
    /* type       -> other    -> */ state::normal,    /* ''' */ character_type::other,
    /* normal     -> percent  -> */ state::percent,   /* '(' */ character_type::other,
    /* percent    -> percent  -> */ state::normal,    /* ')' */ character_type::other,
    /* flag       -> percent  -> */ state::normal,    /* '*' */ character_type::star,
    /* width      -> percent  -> */ state::normal,    /* '+' */ character_type::flag,
    /* dot        -> percent  -> */ state::normal,    /* ',' */ character_type::other,
    /* precision  -> percent  -> */ state::normal,    /* '-' */ character_type::flag,
    /* size       -> percent  -> */ state::normal,    /* '.' */ character_type::dot,
    /* type       -> percent  -> */ state::percent,   /* '/' */ character_type::other,
    /* normal     -> dot      -> */ state::normal,    /* '0' */ character_type::zero,
    /* percent    -> dot      -> */ state::dot,       /* '1' */ character_type::digit,
    /* flag       -> dot      -> */ state::dot,       /* '2' */ character_type::digit,
    /* width      -> dot      -> */ state::dot,       /* '3' */ character_type::digit,
    /* dot        -> dot      -> */ state::normal,    /* '4' */ character_type::digit,
    /* precision  -> dot      -> */ state::normal,    /* '5' */ character_type::digit,
    /* size       -> dot      -> */ state::normal,    /* '6' */ character_type::digit,
    /* type       -> dot      -> */ state::normal,    /* '7' */ character_type::digit,
    /* normal     -> star     -> */ state::normal,    /* '8' */ character_type::digit,
    /* percent    -> star     -> */ state::width,     /* '9' */ character_type::digit,
    /* flag       -> star     -> */ state::width,     /* ':' */ character_type::other,
    /* width      -> star     -> */ state::normal,    /* ';' */ character_type::other,
    /* dot        -> star     -> */ state::precision, /* '<' */ character_type::other,
    /* precision  -> star     -> */ state::normal,    /* '=' */ character_type::other,
    /* size       -> star     -> */ state::normal,    /* '>' */ character_type::other,
    /* type       -> star     -> */ state::normal,    /* '?' */ character_type::other,
    /* normal     -> zero     -> */ state::normal,    /* '@' */ character_type::other,
    /* percent    -> zero     -> */ state::flag,      /* 'A' */ character_type::type,
    /* flag       -> zero     -> */ state::flag,      /* 'B' */ character_type::other,
    /* width      -> zero     -> */ state::width,     /* 'C' */ character_type::type,
    /* dot        -> zero     -> */ state::precision, /* 'D' */ character_type::other,
    /* precision  -> zero     -> */ state::precision, /* 'E' */ character_type::type,
    /* size       -> zero     -> */ state::normal,    /* 'F' */ character_type::size,
    /* type       -> zero     -> */ state::normal,    /* 'G' */ character_type::type,
    /* normal     -> digit    -> */ state::normal,    /* 'H' */ character_type::other,
    /* percent    -> digit    -> */ state::width,     /* 'I' */ character_type::size,
    /* flag       -> digit    -> */ state::width,     /* 'J' */ character_type::other,
    /* width      -> digit    -> */ state::width,     /* 'K' */ character_type::other,
    /* dot        -> digit    -> */ state::precision, /* 'L' */ character_type::size,
    /* precision  -> digit    -> */ state::precision, /* 'M' */ character_type::other,
    /* size       -> digit    -> */ state::normal,    /* 'N' */ character_type::size,
    /* type       -> digit    -> */ state::normal,    /* 'O' */ character_type::other,
    /* normal     -> flag     -> */ state::normal,    /* 'P' */ character_type::other,
    /* percent    -> flag     -> */ state::flag,      /* 'Q' */ character_type::other,
    /* flag       -> flag     -> */ state::flag,      /* 'R' */ character_type::other,
    /* width      -> flag     -> */ state::normal,    /* 'S' */ character_type::type,
    /* dot        -> flag     -> */ state::normal,    /* 'T' */ character_type::size,
    /* precision  -> flag     -> */ state::normal,    /* 'U' */ character_type::other,
    /* size       -> flag     -> */ state::normal,    /* 'V' */ character_type::other,
    /* type       -> flag     -> */ state::normal,    /* 'W' */ character_type::other,
    /* normal     -> size     -> */ state::normal,    /* 'X' */ character_type::type,
    /* percent    -> size     -> */ state::size,      /* 'Y' */ character_type::other,
    /* flag       -> size     -> */ state::size,      /* 'Z' */ character_type::type,
    /* width      -> size     -> */ state::size,      /* '[' */ character_type::other,
    /* dot        -> size     -> */ state::size,      /* '\' */ character_type::other,
    /* precision  -> size     -> */ state::size,      /* ']' */ character_type::other,
    /* size       -> size     -> */ state::size,      /* '^' */ character_type::other,
    /* type       -> size     -> */ state::normal,    /* '_' */ character_type::other,
    /* normal     -> type     -> */ state::normal,    /* '`' */ character_type::other,
    /* percent    -> type     -> */ state::type,      /* 'a' */ character_type::type,
    /* flag       -> type     -> */ state::type,      /* 'b' */ character_type::other,
    /* width      -> type     -> */ state::type,      /* 'c' */ character_type::type,
    /* dot        -> type     -> */ state::type,      /* 'd' */ character_type::type,
    /* precision  -> type     -> */ state::type,      /* 'e' */ character_type::type,
    /* size       -> type     -> */ state::type,      /* 'f' */ character_type::type,
    /* type       -> type     -> */ state::normal,    /* 'g' */ character_type::type,
    /* unused                    */ state::normal,    /* 'h' */ character_type::size,
    /* unused                    */ state::normal,    /* 'i' */ character_type::type,
    /* unused                    */ state::normal,    /* 'j' */ character_type::size,
    /* unused                    */ state::normal,    /* 'k' */ character_type::other,
    /* unused                    */ state::normal,    /* 'l' */ character_type::size,
    /* unused                    */ state::normal,    /* 'm' */ character_type::other,
    /* unused                    */ state::normal,    /* 'n' */ character_type::type,
    /* unused                    */ state::normal,    /* 'o' */ character_type::type,
    /* unused                    */ state::normal,    /* 'p' */ character_type::type,
    /* unused                    */ state::normal,    /* 'q' */ character_type::other,
    /* unused                    */ state::normal,    /* 'r' */ character_type::other,
    /* unused                    */ state::normal,    /* 's' */ character_type::type,
    /* unused                    */ state::normal,    /* 't' */ character_type::size,
    /* unused                    */ state::normal,    /* 'u' */ character_type::type,
    /* unused                    */ state::normal,    /* 'v' */ character_type::other,
    /* unused                    */ state::normal,    /* 'w' */ character_type::size,
    /* unused                    */ state::normal,    /* 'x' */ character_type::type,
    /* unused                    */ state::normal,    /* 'y' */ character_type::other,
    /* unused                    */ state::normal,    /* 'z' */ character_type::size
};

crop_zeroes()

void __cdecl __crt_stdio_output::crop_zeroes ( _Inout_z_ char *  buffer, _locale_t const  locale  ) throw ( )

inline

Definition at line 496 of file corecrt_internal_stdio_output.h.

{
    char const decimal_point = *locale->locinfo->lconv->decimal_point;
 
    while (*buffer && *buffer != decimal_point)
        ++buffer;
 
    if (*buffer++)
    {
        while (*buffer && *buffer != 'e' && *buffer != 'E')
            ++buffer;
 
        char* stop = buffer--;
 
        while (*buffer == '0')
            --buffer;
 
        if (*buffer == decimal_point)
            --buffer;
 
        while((*++buffer = *stop++) != '\0') { }
    }
}

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

force_decimal_point()

void __cdecl __crt_stdio_output::force_decimal_point ( _Inout_z_ char *  buffer, _locale_t const  locale  ) throw ( )

inline

Definition at line 451 of file corecrt_internal_stdio_output.h.

{
    if (_tolower_fast_internal(static_cast<unsigned char>(*buffer), locale) != 'e')
    {
        do
        {
            ++buffer;
        }
        while (_isdigit_fast_internal(static_cast<unsigned char>(*buffer), locale));
    }
 
    // Check if the buffer is in hexadecimal format (cfr %a or %A and fp_format_a):
    if (_tolower_fast_internal(*buffer, locale) == 'x')
    {
        // The buffer is in the form: [-]0xhP+d, and buffer points to the 'x':
        // we want to put the decimal point after the h digit: [-]0xh.P+d
        buffer += 2; // REVIEW This can skip terminal nul?
    }
 
    char holdchar = *buffer;
 
    *buffer++ = *locale->locinfo->lconv->decimal_point;
 
    do
    {
        char const nextchar = *buffer;
        *buffer  = holdchar;
        holdchar = nextchar;
    }
    while (*buffer++);
}

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

is_wide_character_specifier()

template<typename Character >

bool __cdecl __crt_stdio_output::is_wide_character_specifier	(	uint64_t const	options,
		Character const	format_type,
		length_modifier const	length
	)
throw	(
	)

Definition at line 843 of file corecrt_internal_stdio_output.h.

{
    UNREFERENCED_PARAMETER(options);
 
    // If a length specifier was used, use that width:
    switch (length)
    {
    case length_modifier::l: return true;
    case length_modifier::w: return true;
    case length_modifier::h: return false;
    }
 
    if (length == length_modifier::T)
    {
        return sizeof(Character) == sizeof(wchar_t);
    }
 
    bool const is_naturally_wide{
        sizeof(Character) == sizeof(wchar_t) &&
        (options & _CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS) != 0
    };
 
    bool const is_natural_width{
        format_type == 'c' ||
        format_type == 's'
    };
 
    return is_naturally_wide == is_natural_width;
}

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

peek_va_arg()

template<typename T >

T __crt_stdio_output::peek_va_arg	(	va_list	arglist	)
throw	(
	)

Definition at line 53 of file corecrt_internal_stdio_output.h.

{
#if defined(__GNUC__) || defined(__clang__)
    return (T)(va_arg(arglist, typename _va_arg_promoted_tye<T>::type));
#else
    return va_arg(arglist, T);
#endif
}

read_va_arg()

template<typename T >

T __crt_stdio_output::read_va_arg	(	va_list &	arglist	)
throw	(
	)

Definition at line 43 of file corecrt_internal_stdio_output.h.

{
#if defined(__GNUC__) || defined(__clang__)
    return (T)(va_arg(arglist, typename _va_arg_promoted_tye<T>::type));
#else
    return va_arg(arglist, T);
#endif
}

to_integer_size()

size_t __cdecl __crt_stdio_output::to_integer_size ( length_modifier const  length ) throw ( )

inline

Definition at line 823 of file corecrt_internal_stdio_output.h.

{
    switch (length)
    {
    case length_modifier::none: return sizeof(int      );
    case length_modifier::hh:   return sizeof(char     );
    case length_modifier::h:    return sizeof(short    );
    case length_modifier::l:    return sizeof(long     );
    case length_modifier::ll:   return sizeof(long long);
    case length_modifier::j:    return sizeof(intmax_t );
    case length_modifier::z:    return sizeof(size_t   );
    case length_modifier::t:    return sizeof(ptrdiff_t);
    case length_modifier::I:    return sizeof(void*    );
    case length_modifier::I32:  return sizeof(int32_t  );
    case length_modifier::I64:  return sizeof(int64_t  );
    default:                    return 0;
    }
}

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

write_multiple_characters()

template<typename OutputAdapter , typename Character >

__forceinline void __crt_stdio_output::write_multiple_characters	(	OutputAdapter const &	adapter,
		Character const	c,
		int const	count,
		int *const	count_written,
		__crt_cached_ptd_host &	ptd
	)
throw	(
	)

Definition at line 334 of file corecrt_internal_stdio_output.h.

{
    for (int i{0}; i < count; ++i)
    {
        adapter.write_character(c, count_written, ptd);
        if (*count_written == -1)
            break;
    }
}

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