Windows编程

开发平台：
Visual C++

INPSTRM.CXX：源码内容
							//+---------------------------------------------------------------------------
//
//  Copyright (C) 1992 - 1997 Microsoft Corporation.
//
//  File:       inpstrm.cxx
//
//  Contents:   Memory mapped input stream
//
//  Classes:    CMemoryMappedSerialStream
//
//----------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include <htmlfilt.hxx>
#include <codepage.hxx>
//+-------------------------------------------------------------------------
//
//  Method:     CMemoryMappedInputStream::CMemoryMappedInputStream
//
//  Synopsis:   Constructor
//
//--------------------------------------------------------------------------
CMemoryMappedInputStream::CMemoryMappedInputStream()
    : _bytesReadFromMMBuffer(0),
      _charsReadFromTranslatedBuffer(0),
      _cwcTranslatedBuffer(0),
      _ulCodePage(LocaleToCodepage(GetSystemDefaultLCID())),
      _fUnGotChar(FALSE),
      _wch(0)
{
}
//+-------------------------------------------------------------------------
//
//  Method:     CMemoryMappedInputStream::~CMemoryMappedInputStream
//
//  Synopsis:   Destructor
//
//--------------------------------------------------------------------------
CMemoryMappedInputStream::~CMemoryMappedInputStream()
{
    if ( _mmStream.Ok() && _mmStreamBuf.Get() != 0 )
        _mmStream.Unmap( _mmStreamBuf );
}
//+-------------------------------------------------------------------------
//
//  Method:     CMemoryMappedInputStream::Init
//
//  Synopsis:   Initialize the memory mapped stream
//
//  Arguments:  [pwszFileName] -- File to be mapped
//
//--------------------------------------------------------------------------
void CMemoryMappedInputStream::Init( WCHAR *pwszFileName )
{
    Win4Assert( pwszFileName );
    _bytesReadFromMMBuffer = 0;
    if ( _mmStream.Ok() )
    {
        _mmStreamBuf.Rewind();
        _mmStream.Close();
    }
    _mmStream.Open( pwszFileName,
                    GENERIC_READ,
                    FILE_SHARE_READ,
                    OPEN_EXISTING );
    if ( _mmStream.Ok() )
    {
        _mmStreamBuf.Init( &_mmStream );
        if ( !_mmStream.isEmpty() )
            _mmStreamBuf.Map( HTML_FILTER_CHUNK_SIZE );
    }
    else
    {
        htmlDebugOut(( DEB_ERROR, "Throwing FILTER_E_ACCESS in CMemoryMappedInputStream::Initn" ));
        throw( CException( FILTER_E_ACCESS ) );
    }
}
//+-------------------------------------------------------------------------
//
//  Method:     CMemoryMappedInputStream::GetChar
//
//  Synopsis:   Read the next consecutive character from the input file
//
//--------------------------------------------------------------------------
WCHAR CMemoryMappedInputStream::GetChar()
{
    if ( !_mmStream.Ok() || !_mmStreamBuf.Get() )
        throw( CException( FILTER_E_ACCESS ) );
    if ( _fUnGotChar )
    {
        _fUnGotChar = FALSE;
        return _wch;
    }
    if ( _charsReadFromTranslatedBuffer == _cwcTranslatedBuffer )
    {
        if ( _bytesReadFromMMBuffer == _mmStreamBuf.Size() )
        {
            if ( _mmStreamBuf.Eof() )
                return WEOF;
    
            //
            // Try to map in next chunk of file
            //
            _mmStreamBuf.Map( HTML_FILTER_CHUNK_SIZE );
            _bytesReadFromMMBuffer = 0;
    
            Win4Assert( _mmStreamBuf.Size() > _bytesReadFromMMBuffer );
        }
        ULONG cChUnread = _mmStreamBuf.Size() - _bytesReadFromMMBuffer;
        //
        // Since, the wide chars are precomposed, assume 1:1 translation mapping
        //
        ULONG cChIn = TRANSLATED_CHAR_BUFFER_LENGTH;
        if ( cChIn > cChUnread )
        {
            //
            // Not enough chars in input
            //
            cChIn = cChUnread;
        }
        ULONG cwcActual = 0;
        do
        {
            cwcActual = MultiByteToWideChar( _ulCodePage,
                                             MB_PRECOMPOSED,
                                             (char *) _mmStreamBuf.Get() + _bytesReadFromMMBuffer,
                                             cChIn,
                                             _awcTranslatedBuffer,
                                             TRANSLATED_CHAR_BUFFER_LENGTH );
            if ( cwcActual == 0 )
            {
                if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER && cChIn >= 2 )
                    cChIn /= 2;
                else
                {
                    Win4Assert( !"CMemoryMappedInputStream::GetChar, cannot translate single char" );
                    throw( CException( GetLastError() ) );
                }
            }
        } while( cwcActual == 0 );
        Win4Assert( _bytesReadFromMMBuffer + cChIn <= _mmStreamBuf.Size() );
        Win4Assert( cwcActual <= TRANSLATED_CHAR_BUFFER_LENGTH );
        _bytesReadFromMMBuffer += cChIn;
        _charsReadFromTranslatedBuffer = 0;
        _cwcTranslatedBuffer = cwcActual;
    }
    return _awcTranslatedBuffer[_charsReadFromTranslatedBuffer++];
}
//+-------------------------------------------------------------------------
//
//  Method:     CMemoryMappedInputStream::UnGetChar
//
//  Synopsis:   Pushes(logically) a character back into the input stream
//
//  Arguments:  [wch] -- Char to be pushed back
//
//--------------------------------------------------------------------------
void CMemoryMappedInputStream::UnGetChar( WCHAR wch )
{
    //
    // We can unget only one char at a time
    //
    Win4Assert( !_fUnGotChar );
    _fUnGotChar = TRUE;
    _wch = wch;
}
//+-------------------------------------------------------------------------
//
//  Method:     CMemoryMappedInputStream::Eof
//
//  Synopsis:   Is this the end of input file ?
//
//--------------------------------------------------------------------------
BOOL CMemoryMappedInputStream::Eof()
{
    if ( !_mmStream.Ok() )
        throw( CException( FILTER_E_ACCESS ) );
    if ( _fUnGotChar )
        return FALSE;
    if ( _charsReadFromTranslatedBuffer < _cwcTranslatedBuffer )
        return FALSE;
    if ( _bytesReadFromMMBuffer == _mmStreamBuf.Size() )
        return _mmStreamBuf.Eof();
    else
        return FALSE;
}

						