stream.cpp File Reference

#include <corecrt_internal_stdio.h>

Include dependency graph for stream.cpp:

Go to the source code of this file.

Functions
static __crt_stdio_stream __cdecl	find_or_allocate_unused_stream_nolock () throw ()
__crt_stdio_stream __cdecl	__acrt_stdio_allocate_stream () throw ()
void __cdecl	__acrt_stdio_free_stream (__crt_stdio_stream stream) throw ()

Function Documentation

__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().

find_or_allocate_unused_stream_nolock()

static __crt_stdio_stream __cdecl find_or_allocate_unused_stream_nolock ( ) throw ( )

static

Definition at line 12 of file stream.cpp.

{
    __crt_stdio_stream_data** const first_stream = __piob + _IOB_ENTRIES;
    __crt_stdio_stream_data** const last_stream  = first_stream + _nstream - _IOB_ENTRIES;
 
    for (__crt_stdio_stream_data** it = first_stream; it != last_stream; ++it)
    {
        // First, check to see whether the stream is valid and free for use:
        {
            __crt_stdio_stream stream(*it);
            if (stream.valid())
            {
                if (stream.is_in_use())
                    continue;
 
                stream.lock();
                if (!stream.try_allocate())
                {
                    stream.unlock();
                    continue;
                }
 
                return stream;
            }
        }
 
        // Otherwise, there is no stream at this index yet, so we allocate one
        // and return it:
        {
            *it = _calloc_crt_t(__crt_stdio_stream_data, 1).detach();
            if (*it == nullptr)
                break;
 
            // Initialize the stream.  Everything requires zero-initialization
            // (which we get from calloc), except the file handle and the lock:
            (*it)->_file = -1;
            __acrt_InitializeCriticalSectionEx(&(*it)->_lock, _CORECRT_SPINCOUNT, 0);
 
            __crt_stdio_stream stream(*it);
 
            // Note:  This attempt will always succeed, because we hold the only
            // pointer to the stream object (since we just allocated it):
            stream.try_allocate();
            stream.lock();
 
            return stream;
        }
    }
 
    return __crt_stdio_stream();
}

Referenced by __acrt_stdio_allocate_stream().