corecrt_internal_stdio.h File Reference

#include <corecrt_internal.h>
#include <corecrt_internal_lowio.h>
#include <corecrt_internal_traits.h>
#include <io.h>
#include <mbstring.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

Include dependency graph for corecrt_internal_stdio.h:

Go to the source code of this file.

Classes
struct	__crt_stdio_stream_data
class	__crt_stdio_stream
struct	__acrt_stdio_char_traits< char >
struct	__acrt_stdio_char_traits< wchar_t >
struct	__acrt_stdio_stream_mode

Enumerations
enum	: long {   _IOREAD = 0x0001 , _IOWRITE = 0x0002 , _IOUPDATE = 0x0004 , _IOEOF = 0x0008 ,   _IOERROR = 0x0010 , _IOCTRLZ = 0x0020 , _IOBUFFER_CRT = 0x0040 , _IOBUFFER_USER = 0x0080 ,   _IOBUFFER_SETVBUF = 0x0100 , _IOBUFFER_STBUF = 0x0200 , _IOBUFFER_NONE = 0x0400 , _IOCOMMIT = 0x0800 ,   _IOSTRING = 0x1000 , _IOALLOCATED = 0x2000 }

Functions
_Check_return_opt_ int __cdecl	_putch_nolock_internal (_In_ int _Ch, _Inout_ __crt_cached_ptd_host &_Ptd)
_Check_return_opt_ wint_t __cdecl	_putwch_nolock_internal (_In_ wchar_t _Ch, _Inout_ __crt_cached_ptd_host &_Ptd)
_Check_return_opt_ wint_t __cdecl	_fputwc_nolock_internal (_In_ wchar_t _Character, _Inout_ FILE *_Stream, _Inout_ __crt_cached_ptd_host &_Ptd)
	_Success_ (return !=EOF) _Check_return_opt_ extern "C" int __cdecl _fputc_nolock_internal(_In_ int _Character
_Check_return_opt_ size_t __cdecl	_fwrite_nolock_internal (_In_reads_bytes_(_ElementSize *_ElementCount) void const *_Buffer, _In_ size_t _ElementSize, _In_ size_t _ElementCount, _Inout_ FILE *_Stream, _Inout_ __crt_cached_ptd_host &_Ptd)
_Check_return_ __int64 __cdecl	_ftelli64_nolock_internal (_Inout_ FILE *_Stream, _Inout_ __crt_cached_ptd_host &_Ptd)
__crt_stdio_stream __cdecl	__acrt_stdio_allocate_stream () throw ()
void __cdecl	__acrt_stdio_free_stream (__crt_stdio_stream _Stream) throw ()
template<typename Action >
auto	__acrt_lock_stream_and_call (FILE *const stream, Action &&action) -> decltype(action()) throw ()
bool	__acrt_stdio_is_initialized ()
	__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0 (_Success_(return !=0) char *, __RETURN_POLICY_SAME, _ACRTIMP, gets, _Pre_notnull_ _Post_z_ _Out_writes_z_(((size_t) -1)), char, _Buffer) __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_CGETS(_Success_(return !=0) char *
	_At_ (_Buffer, _Pre_notnull_ _In_reads_(1)) _At_(_Buffer+1
_Pre_notnull_	_Out_writes_ (1)) _At_(_Buffer+2
_Pre_notnull_ _Pre_notnull_ _Post_z_	_Out_writes_to_ (_Buffer[0], _Buffer[1]))
_Pre_notnull_ _Pre_notnull_ _Post_z_ _Buffer	__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0 (_Success_(return !=0) wchar_t *, __RETURN_POLICY_SAME, _ACRTIMP, _getws, _Pre_notnull_ _Post_z_, wchar_t, _Buffer) __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_CGETS(_Post_satisfies_(return
bool	__acrt_stdio_parse_mode_plus (__acrt_stdio_stream_mode &result, bool &seen_plus) throw ()
bool	__acrt_stdio_parse_mode_b (__acrt_stdio_stream_mode &result) throw ()
bool	__acrt_stdio_parse_mode_t (__acrt_stdio_stream_mode &result) throw ()
bool	__acrt_stdio_parse_mode_c (__acrt_stdio_stream_mode &result, bool &seen_commit_mode) throw ()
bool	__acrt_stdio_parse_mode_n (__acrt_stdio_stream_mode &result, bool &seen_commit_mode) throw ()
bool	__acrt_stdio_parse_mode_S (__acrt_stdio_stream_mode &result, bool &seen_scan_mode) throw ()
bool	__acrt_stdio_parse_mode_R (__acrt_stdio_stream_mode &result, bool &seen_scan_mode) throw ()
bool	__acrt_stdio_parse_mode_T (__acrt_stdio_stream_mode &result) throw ()
bool	__acrt_stdio_parse_mode_D (__acrt_stdio_stream_mode &result) throw ()
bool	__acrt_stdio_parse_mode_N (__acrt_stdio_stream_mode &result) throw ()
bool	__acrt_stdio_parse_mode_x (__acrt_stdio_stream_mode &result) throw ()
template<typename Character >
__acrt_stdio_stream_mode __cdecl	__acrt_stdio_parse_mode (Character const *const mode) throw ()
bool __cdecl	__crt_stdio_path_requires_backslash (char const *const first) throw ()
bool __cdecl	__crt_stdio_path_requires_backslash (wchar_t const *const first) throw ()
void __cdecl	__acrt_stdio_reset_buffer (__crt_stdio_stream const stream) throw ()

Variables
_Inout_ FILE *	_Stream
_Inout_ FILE _Inout_ __crt_cached_ptd_host &	_Ptd
int	_nstream
__crt_stdio_stream_data **	__piob
	_DCRTIMP
	_cgets
_Pre_notnull_ _Pre_notnull_ _Post_z_	char

Enumeration Type Documentation

anonymous enum

anonymous enum : long

Enumerator
_IOREAD
_IOWRITE
_IOUPDATE
_IOEOF
_IOERROR
_IOCTRLZ
_IOBUFFER_CRT
_IOBUFFER_USER
_IOBUFFER_SETVBUF
_IOBUFFER_STBUF
_IOBUFFER_NONE
_IOCOMMIT
_IOSTRING
_IOALLOCATED

Definition at line 30 of file corecrt_internal_stdio.h.

{
    // Mode bits:  These bits control the stream mode.  A stream may be in one
    // of three modes:  read mode, write mode, or update (read/write) mode.  At
    // least one of these bits will be set for any open stream.
    //
    // If the stream is open in read mode or write mode, then only the _IOREAD
    // or _IOWRITE bit will be set.
    //
    // If the stream is open in update (read/write) mode, then the _IOUPDATE bit
    // will be set.  Further state must also be tracked for update mode streams.
    // Read and write operations cannot be mixed willy-nilly:  in most cases, a
    // flush or reposition must take place in order to transition between reading
    // and writing.  So, for update mode streams, if the next operation must be
    // a read, the _IOREAD bit is set, and if the next operation must be a write,
    // the _IOWRITE bit is set.
    _IOREAD           = 0x0001,
    _IOWRITE          = 0x0002,
    _IOUPDATE         = 0x0004,
 
    // Stream state bits:  These bits track the state of the stream.  The _IOEOF
    // and _IOERROR flags track the end-of-file and error states, respectively,
    // which are reported by feof() and ferror().  The _IOCTRLZ flag is when the
    // last read ended because a Ctrl+Z was read; it corresponds to the lowio
    // FEOFLAG state.
    _IOEOF            = 0x0008,
    _IOERROR          = 0x0010,
    _IOCTRLZ          = 0x0020,
 
    // Buffering state bits:  These track the buffering mode of the stream:
    //
    // (*) CRT:      The buffer was allocated by the CRT via the usual mechanism
    //               (typically via __acrt_stdio_allocate_buffer_nolock, and of
    //               size _INTERNAL_BUFSIZ).
    //
    // (*) USER:     The buffer was allocated by the user and was configured via
    //               the setvbuf() function.
    //
    // (*) SETVBUF:  The buffer was set via the setvbuf() function.  This flag
    //               may be combined with either the CRT or USER flag, depending
    //               on who owns the buffer (based on how setvbuf() was called).
    //
    // (*) STBUF:    The buffer was set via a call to the
    //               __acrt_stdio_begin_temporary_buffering_nolock() function,
    //               which provides a temporary buffer for console I/O operations
    //               to improve the performance of bulk read or write operations.
    //
    // (*) NONE:     Buffering is disabled, either because it was explicitly
    //               disabled or because the CRT attempted to allocate a buffer
    //               but allocation failed.  When this flag is set, the internal
    //               two-byte character buffer is used.
    //
    // Note that these flags are related to, but distinct from, the public stdio
    // buffering flags that are used with setvbuf (_IOFBF, _IOLBF, and _IONBF).
    // Specifically, note that those flags are never or'ed into the flags for a
    // stream.
    _IOBUFFER_CRT     = 0x0040,
    _IOBUFFER_USER    = 0x0080,
    _IOBUFFER_SETVBUF = 0x0100,
    _IOBUFFER_STBUF   = 0x0200,
    _IOBUFFER_NONE    = 0x0400,
 
    // Commit-on-flush state bit:  When this flag is set, every flush operation
    // on the stream also commits the file to disk.
    _IOCOMMIT         = 0x0800,
 
    // String state bit:  When this flag is set, it indicates that the stream is
    // backed by a string, not a file.  String-backed streams are not exposed to
    // user code; they are created internally to support formatted I/O to string
    // buffers (e.g. the sprintf and sscanf families of functions).  If a stream
    // is backed by a string, its lock is not initialized and no synchronization
    // is required.
    _IOSTRING         = 0x1000,
 
    // Allocation state bit:  When this flag is set it indicates that the stream
    // is currently allocated and in-use.  If this flag is not set, it indicates
    // that the stream is free and available for use.
    _IOALLOCATED      = 0x2000,
};

Function Documentation

__acrt_lock_stream_and_call()

template<typename Action >

auto __acrt_lock_stream_and_call	(	FILE *const	stream,
		Action &&	action
	)		-> decltype(action())
throw	(
	)

Definition at line 294 of file corecrt_internal_stdio.h.

{
    return __crt_seh_guarded_call<decltype(action())>()(
        [stream]() { _lock_file(stream); },
        action,
        [stream]() { _unlock_file(stream); });
}

Referenced by _fputs_internal(), _fputws_internal(), _fwrite_internal(), _puts_internal(), _putws_internal(), _setvbuf_internal(), common_flush_all(), common_vfprintf(), common_vfscanf(), and fflush().

__acrt_stdio_allocate_stream()

__crt_stdio_stream __cdecl __acrt_stdio_allocate_stream	(		)
throw	(
	)

Definition at line 71 of file stream.cpp.

{
    __crt_stdio_stream stream;
 
    __acrt_lock(__acrt_stdio_index_lock);
    __try
    {
        stream = find_or_allocate_unused_stream_nolock();
        if (!stream.valid())
            __leave;
 
        stream->_cnt = 0;
        stream->_tmpfname = nullptr;
        stream->_ptr = nullptr;
        stream->_base = nullptr;
        stream->_file = -1;
    }
    __finally
    {
        __acrt_unlock(__acrt_stdio_index_lock);
    }
    __endtry
 
    return stream;
}

Referenced by _Success_(), common_fdopen(), and common_fsopen().

__acrt_stdio_free_stream()

void __cdecl __acrt_stdio_free_stream	(	__crt_stdio_stream	_Stream	)
throw	(
	)

Definition at line 97 of file stream.cpp.

{
    stream->_ptr      = nullptr;
    stream->_base     = nullptr;
    stream->_cnt      =  0;
    stream->_file     = -1;
    stream->_charbuf  =  0;
    stream->_bufsiz   =  0;
    stream->_tmpfname = nullptr;
    stream.deallocate();
}

Referenced by _fclose_internal(), _fclose_nolock_internal(), _Success_(), and common_fsopen().

__acrt_stdio_is_initialized()

bool __acrt_stdio_is_initialized ( )

inline

Definition at line 321 of file corecrt_internal_stdio.h.

                                          {
    return __piob != 0;
}

Referenced by __acrt_uninitialize().

__acrt_stdio_parse_mode()

template<typename Character >

__acrt_stdio_stream_mode __cdecl __acrt_stdio_parse_mode	(	Character const *const	mode	)
throw	(
	)

Definition at line 659 of file corecrt_internal_stdio.h.

{
    typedef __acrt_stdio_char_traits<Character> stdio_traits;
 
    // Note that we value initialize the result, so the success flag is false
    // by default.  This ensures that any premature return will return failure.
    __acrt_stdio_stream_mode result = __acrt_stdio_stream_mode();
    result._stdio_mode = _commode;
 
    // Advance past any leading spaces:
    Character const* it = mode;
    while (*it == ' ')
        ++it;
 
    // Read the first character.  It must be one of 'r', 'w' , or 'a':
    switch (*it)
    {
    case 'r':
        result._lowio_mode = _O_RDONLY;
        result._stdio_mode = _IOREAD;
        break;
 
    case 'w':
        result._lowio_mode = _O_WRONLY | _O_CREAT | _O_TRUNC;
        result._stdio_mode = _IOWRITE;
        break;
 
    case 'a':
        result._lowio_mode = _O_WRONLY | _O_CREAT | _O_APPEND;
        result._stdio_mode = _IOWRITE;
        break;
 
    default:
        _VALIDATE_RETURN(("Invalid file open mode", 0), EINVAL, result);
    }
 
    // Advance past the first character:
    ++it;
 
    // There can be up to seven more optional mode characters:
    // [1] A single '+' character
    // [2] One of 't' or 'b' (indicating text or binary, respectively)
    // [3] One of 'c' or 'n' (enable or disable auto-commit to disk on flush)
    // [4] One of 'S' or 'R' (optimize for sequential or random access)
    // [5] 'T' (indicating the file is short-lived)
    // [6] 'D' (indicating the file is temporary)
    // [7] 'N' (indicating the file should not be inherited by child processes)
    // [8] 'x' (indicating the file must be created and it is an error if it already exists)
    bool seen_commit_mode   = false;
    bool seen_plus          = false;
    bool seen_scan_mode     = false;
    bool seen_encoding_flag = false;
    for (bool continue_loop = true; continue_loop && *it != '\0'; it += (continue_loop ? 1 : 0))
    {
        switch (*it)
        {
        case '+': continue_loop = __acrt_stdio_parse_mode_plus(result, seen_plus);        break;
        case 'b': continue_loop = __acrt_stdio_parse_mode_b   (result);                   break;
        case 't': continue_loop = __acrt_stdio_parse_mode_t   (result);                   break;
        case 'c': continue_loop = __acrt_stdio_parse_mode_c   (result, seen_commit_mode); break;
        case 'n': continue_loop = __acrt_stdio_parse_mode_n   (result, seen_commit_mode); break;
        case 'S': continue_loop = __acrt_stdio_parse_mode_S   (result, seen_scan_mode  ); break;
        case 'R': continue_loop = __acrt_stdio_parse_mode_R   (result, seen_scan_mode  ); break;
        case 'T': continue_loop = __acrt_stdio_parse_mode_T   (result);                   break;
        case 'D': continue_loop = __acrt_stdio_parse_mode_D   (result);                   break;
        case 'N': continue_loop = __acrt_stdio_parse_mode_N   (result);                   break;
        case 'x': continue_loop = __acrt_stdio_parse_mode_x   (result);                   break;
 
        // If we encounter any spaces, skip them:
        case ' ':
            break;
 
        // If we encounter a comma, it begins the encoding specification; we
        // break out of the loop immediately and parse the encoding flag next:
        case ',':
            seen_encoding_flag = true;
            continue_loop = false;
            break;
 
        default:
            _VALIDATE_RETURN(("Invalid file open mode", 0), EINVAL, result);
        }
    }
 
    // Advance past the comma that terminated the loop:
    if (seen_encoding_flag)
        ++it;
 
    while (*it == ' ')
        ++it;
 
    // If we did not encounter the encoding introducer (a comma), make sure we
    // actually reached the end of the mode string.  We are done:
    if (!seen_encoding_flag)
    {
        _VALIDATE_RETURN(*it == '\0', EINVAL, result);
        result._success = true;
        return result;
    }
 
    // Otherwise, we saw the beginning of an encoding; parse it:
    static Character const ccs[]              = { 'c', 'c', 's' };
    static Character const utf8_encoding[]    = { 'U', 'T', 'F', '-', '8' };
    static Character const utf16_encoding[]   = { 'U', 'T', 'F', '-', '1', '6', 'L', 'E' };
    static Character const unicode_encoding[] = { 'U', 'N', 'I', 'C', 'O', 'D', 'E' };
 
    // Make sure it begins with "ccs" (all lowercase)...
    if (stdio_traits::tcsncmp(it, ccs, _countof(ccs)) != 0)
        _VALIDATE_RETURN(("Invalid file open mode", 0), EINVAL, result);
 
    it += _countof(ccs); // Advance past the "ccs"
 
    while (*it == ' ')
        ++it;
 
    if (*it != '=')
        _VALIDATE_RETURN(("Invalid file open mode", 0), EINVAL, result);
 
    ++it; // Advance past the "="
 
    while (*it == ' ')
        ++it;
 
    if (stdio_traits::tcsnicmp(it, utf8_encoding, _countof(utf8_encoding)) == 0)
    {
        it += _countof(utf8_encoding);
        result._lowio_mode |= _O_U8TEXT;
    }
    else if (stdio_traits::tcsnicmp(it, utf16_encoding, _countof(utf16_encoding)) == 0)
    {
        it += _countof(utf16_encoding);
        result._lowio_mode |= _O_U16TEXT;
    }
    else if (stdio_traits::tcsnicmp(it, unicode_encoding, _countof(unicode_encoding)) == 0)
    {
        it += _countof(unicode_encoding);
        result._lowio_mode |= _O_WTEXT;
    }
    else
    {
        _VALIDATE_RETURN(("Invalid file open mode", 0), EINVAL, result);
    }
 
    // Finally, skip any trailing spaces...
    while (*it == ' ')
        ++it;
 
    // ...and ensure there are no characters left:
    _VALIDATE_RETURN(*it == '\0', EINVAL, result);
 
    result._success = true;
    return result;
}

Referenced by common_fdopen(), and common_openfile().

__acrt_stdio_parse_mode_b()

bool __acrt_stdio_parse_mode_b ( __acrt_stdio_stream_mode &  result ) throw ( )

inline

Definition at line 552 of file corecrt_internal_stdio.h.

{
    if (result._lowio_mode & (_O_TEXT | _O_BINARY)) {
        return false;
    }
 
    result._lowio_mode |= _O_BINARY;
    return true;
}

Referenced by __acrt_stdio_parse_mode().

__acrt_stdio_parse_mode_c()

bool __acrt_stdio_parse_mode_c ( __acrt_stdio_stream_mode &  result, bool &  seen_commit_mode  ) throw ( )

inline

Definition at line 572 of file corecrt_internal_stdio.h.

{
    if (seen_commit_mode) {
        return false;
    }
 
    seen_commit_mode = true;
    result._stdio_mode |= _IOCOMMIT;
    return true;
}

Referenced by __acrt_stdio_parse_mode().

__acrt_stdio_parse_mode_D()

bool __acrt_stdio_parse_mode_D ( __acrt_stdio_stream_mode &  result ) throw ( )

inline

Definition at line 626 of file corecrt_internal_stdio.h.

{
    if (result._lowio_mode & _O_TEMPORARY) {
        return false;
    }
 
    result._lowio_mode |= _O_TEMPORARY;
    return true;
}

Referenced by __acrt_stdio_parse_mode().

__acrt_stdio_parse_mode_N()

bool __acrt_stdio_parse_mode_N ( __acrt_stdio_stream_mode &  result ) throw ( )

inline

Definition at line 636 of file corecrt_internal_stdio.h.

{
    result._lowio_mode |= _O_NOINHERIT;
    return true;
}

Referenced by __acrt_stdio_parse_mode().

__acrt_stdio_parse_mode_n()

bool __acrt_stdio_parse_mode_n ( __acrt_stdio_stream_mode &  result, bool &  seen_commit_mode  ) throw ( )

inline

Definition at line 583 of file corecrt_internal_stdio.h.

{
    if (seen_commit_mode) {
        return false;
    }
 
    seen_commit_mode = true;
    result._stdio_mode &= ~_IOCOMMIT;
    return true;
}

Referenced by __acrt_stdio_parse_mode().

__acrt_stdio_parse_mode_plus()

bool __acrt_stdio_parse_mode_plus ( __acrt_stdio_stream_mode &  result, bool &  seen_plus  ) throw ( )

inline

Definition at line 533 of file corecrt_internal_stdio.h.

{
    if (seen_plus) {
        return false;
    }
 
    seen_plus = true;
 
    if (result._lowio_mode & _O_RDWR) {
        return false;
    }
 
    result._lowio_mode |= _O_RDWR;
    result._lowio_mode &= ~(_O_RDONLY | _O_WRONLY);
    result._stdio_mode |= _IOUPDATE;
    result._stdio_mode &= ~(_IOREAD | _IOWRITE);
    return true;
}

Referenced by __acrt_stdio_parse_mode().

__acrt_stdio_parse_mode_R()

bool __acrt_stdio_parse_mode_R ( __acrt_stdio_stream_mode &  result, bool &  seen_scan_mode  ) throw ( )

inline

Definition at line 605 of file corecrt_internal_stdio.h.

{
    if (seen_scan_mode) {
        return false;
    }
 
    seen_scan_mode = true;
    result._lowio_mode |= _O_RANDOM;
    return true;
}

Referenced by __acrt_stdio_parse_mode().

__acrt_stdio_parse_mode_S()

bool __acrt_stdio_parse_mode_S ( __acrt_stdio_stream_mode &  result, bool &  seen_scan_mode  ) throw ( )

inline

Definition at line 594 of file corecrt_internal_stdio.h.

{
    if (seen_scan_mode) {
        return false;
    }
 
    seen_scan_mode = true;
    result._lowio_mode |= _O_SEQUENTIAL;
    return true;
}

Referenced by __acrt_stdio_parse_mode().

__acrt_stdio_parse_mode_t()

bool __acrt_stdio_parse_mode_t ( __acrt_stdio_stream_mode &  result ) throw ( )

inline

Definition at line 562 of file corecrt_internal_stdio.h.

{
    if (result._lowio_mode & (_O_TEXT | _O_BINARY)) {
        return false;
    }
 
    result._lowio_mode |= _O_TEXT;
    return true;
}

Referenced by __acrt_stdio_parse_mode().

__acrt_stdio_parse_mode_T()

bool __acrt_stdio_parse_mode_T ( __acrt_stdio_stream_mode &  result ) throw ( )

inline

Definition at line 616 of file corecrt_internal_stdio.h.

{
    if (result._lowio_mode & _O_SHORT_LIVED) {
        return false;
    }
 
    result._lowio_mode |= _O_SHORT_LIVED;
    return true;
}

Referenced by __acrt_stdio_parse_mode().

__acrt_stdio_parse_mode_x()

bool __acrt_stdio_parse_mode_x ( __acrt_stdio_stream_mode &  result ) throw ( )

inline

Definition at line 642 of file corecrt_internal_stdio.h.

{
    if (!(result._lowio_mode & _O_TRUNC)) {
        // 'x' only permitted with 'w'
        return false;
    }
 
    result._lowio_mode |= _O_EXCL;
    return true;
}

Referenced by __acrt_stdio_parse_mode().

__acrt_stdio_reset_buffer()

void __cdecl __acrt_stdio_reset_buffer ( __crt_stdio_stream const  stream ) throw ( )

inline

Definition at line 856 of file corecrt_internal_stdio.h.

{
    stream->_ptr = stream->_base;
    stream->_cnt = 0;
}

Referenced by __acrt_stdio_flush_nolock(), _fread_nolock_s(), _rewind_internal(), and common_fseek_nolock().

__crt_stdio_path_requires_backslash() [1/2]

bool __cdecl __crt_stdio_path_requires_backslash ( char const *const  first ) throw ( )

inline

Definition at line 822 of file corecrt_internal_stdio.h.

{
    char const* const last = first + strlen(first);
    if (first == last)
        return false;
 
    if (*(last - 1) == '\\')
    {
        return reinterpret_cast<unsigned char const*>(last - 1)
            != _mbsrchr(reinterpret_cast<unsigned char const*>(first), '\\');
    }
 
    if (*(last - 1) == '/')
        return false;
 
    return true;
}

Referenced by get_executable_path(), and throw().

__crt_stdio_path_requires_backslash() [2/2]

bool __cdecl __crt_stdio_path_requires_backslash ( wchar_t const *const  first ) throw ( )

inline

Definition at line 840 of file corecrt_internal_stdio.h.

{
    wchar_t const* const last = first + wcslen(first);
    if (first == last)
        return false;
 
    if (*(last - 1) == L'\\')
        return false;
 
    if (*(last - 1) == L'/')
        return false;
 
    return true;
}

__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0() [1/2]

__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0 ( _Success_(return !=0) char *  , __RETURN_POLICY_SAME  , _ACRTIMP  , gets  , _Pre_notnull_ _Post_z_   _Out_writes_z_((size_t) -1), char  , _Buffer    )

pure virtual

__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0() [2/2]

_Pre_notnull_ _Pre_notnull_ _Post_z_ _Buffer __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0	(	_Success_(return !=0) wchar_t *	,
		__RETURN_POLICY_SAME	,
		_ACRTIMP	,
		_getws	,
		_Pre_notnull_	_Post_z_,
		wchar_t	,
		_Buffer
	)

_At_()

_At_	(	_Buffer	,
		_Pre_notnull_	_In_reads_1
	)

_fputwc_nolock_internal()

_Check_return_opt_ wint_t __cdecl _fputwc_nolock_internal	(	_In_ wchar_t	_Character,
		_Inout_ FILE *	_Stream,
		_Inout_ __crt_cached_ptd_host &	_Ptd
	)

Referenced by _fputws_internal(), and _putws_internal().

_ftelli64_nolock_internal()

_Check_return_ __int64 __cdecl _ftelli64_nolock_internal	(	_Inout_ FILE *	_Stream,
		_Inout_ __crt_cached_ptd_host &	_Ptd
	)

Referenced by common_fseek_nolock().

_fwrite_nolock_internal()

_Check_return_opt_ size_t __cdecl _fwrite_nolock_internal	(	_In_reads_bytes_(_ElementSize *_ElementCount) void const *	_Buffer,
		_In_ size_t	_ElementSize,
		_In_ size_t	_ElementCount,
		_Inout_ FILE *	_Stream,
		_Inout_ __crt_cached_ptd_host &	_Ptd
	)

Referenced by _fputs_internal(), and _puts_internal().

_Out_writes_()

_Pre_notnull_ _Out_writes_

(

1

)

_Out_writes_to_()

_Pre_notnull_ _Pre_notnull_ _Post_z_ _Out_writes_to_	(	_Buffer	[0],
		_Buffer	[1]
	)

_putch_nolock_internal()

_Check_return_opt_ int __cdecl _putch_nolock_internal	(	_In_ int	_Ch,
		_Inout_ __crt_cached_ptd_host &	_Ptd
	)

_putwch_nolock_internal()

_Check_return_opt_ wint_t __cdecl _putwch_nolock_internal	(	_In_ wchar_t	_Ch,
		_Inout_ __crt_cached_ptd_host &	_Ptd
	)

_Success_()

_Success_

(

return !

= EOF

)

Definition at line 1028 of file fsctrl.c.

{
    PLIST_ENTRY Link;
 
    PVPB Vpb = Vcb->Vpb;
    PVPB OldVpb;
 
    BOOLEAN Remount = FALSE;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Check whether we are looking for a device only Mvcb.
    //
 
    for (Link = CdData.VcbQueue.Flink;
         Link != &CdData.VcbQueue;
         Link = Link->Flink) {
 
        *OldVcb = CONTAINING_RECORD( Link, VCB, VcbLinks );
 
        //
        //  Skip ourselves.
        //
 
        if (Vcb == *OldVcb) { continue; }
 
        //
        //  Look at the Vpb and state of the previous Vcb.
        //
 
        OldVpb = (*OldVcb)->Vpb;
 
        if ((OldVpb != Vpb) &&
            (OldVpb->RealDevice == Vpb->RealDevice) &&
            ((*OldVcb)->VcbCondition == VcbNotMounted)) {
 
            //
            //  If the current disk is a raw disk then it can match a previous music or
            //  raw disk.
            //
 
            if (FlagOn( Vcb->VcbState, VCB_STATE_AUDIO_DISK)) {
 
                if (FlagOn( (*OldVcb)->VcbState, VCB_STATE_AUDIO_DISK )) {
 
                    //
                    //  If we have both TOC then fail the remount if the lengths
                    //  are different or they don't match.
                    //
 
                    if ((Vcb->TocLength != (*OldVcb)->TocLength) ||
                        ((Vcb->TocLength != 0) &&
                         !RtlEqualMemory( Vcb->CdromToc,
                                          (*OldVcb)->CdromToc,
                                          Vcb->TocLength ))) {
 
                        continue;
                    }
 
                    Remount = TRUE;
                    break;
                }
 
            //
            //  The current disk is not a raw disk.  Go ahead and compare
            //  serial numbers, volume label and TOC.
            //
 
            }
            else if ((OldVpb->SerialNumber == Vpb->SerialNumber) &&
                     (Vcb->TocLength == (*OldVcb)->TocLength) &&
                     ((Vcb->TocLength == 0) || RtlEqualMemory( Vcb->CdromToc,
                                                               (*OldVcb)->CdromToc,
                                                               Vcb->TocLength )) &&
                     (Vpb->VolumeLabelLength == OldVpb->VolumeLabelLength) &&
                     (RtlEqualMemory( OldVpb->VolumeLabel,
                                        Vpb->VolumeLabel,
                                        Vpb->VolumeLabelLength ))) {
                //
                //  Remember the old Vcb.  Then set the return value to
                //  TRUE and break.
                //
 
                Remount = TRUE;
                break;
            }
        }
    }
 
    return Remount;
}

Variable Documentation

__piob

__crt_stdio_stream_data** __piob

Definition at line 316 of file corecrt_internal_stdio.h.

Referenced by __acrt_stdio_is_initialized(), _fcloseall(), _rmtmp(), _setmaxstdio(), common_flush_all(), find_or_allocate_unused_stream_nolock(), and initialize_stdio_handles_nolock().

_cgets

_cgets

Definition at line 340 of file corecrt_internal_stdio.h.

_DCRTIMP

_DCRTIMP

Definition at line 340 of file corecrt_internal_stdio.h.

_nstream

int _nstream

Definition at line 310 of file corecrt_internal_stdio.h.

Referenced by _fcloseall(), _getmaxstdio(), _rmtmp(), _setmaxstdio(), common_flush_all(), and find_or_allocate_unused_stream_nolock().

_Ptd

_Inout_ FILE _Inout_ __crt_cached_ptd_host& _Ptd

Definition at line 143 of file corecrt_internal_stdio.h.

_Stream

_Inout_ FILE* _Stream

Definition at line 142 of file corecrt_internal_stdio.h.

char

_Pre_notnull_ _Pre_notnull_ _Post_z_ char

Definition at line 344 of file corecrt_internal_stdio.h.