---

streamsax2parser.cpp

Go to the documentation of this file.

//============================================================================= 
//
// XDFLengine library
//
//-----------------------------------------------------------------------------
//  STREAMSAX2PARSER.CPP
//----------------------------------------------------------------------------- 
//_____________________________________________________________________________
//
//  Copyright (C) 2003 Guillaume Baurand. All Rights Reserved.
//
//  This file is part of the XDFLengine project.
//
//  The XDFLengine is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
//  USA.
//
//  For more information, 
//      contact  : guillaume@baurand.net 
//      or visit : http://xdflengine.sourceforge.net
//
//============================================================================= 

#include    "streamsax2parser.hpp"

#define     STREAMINPUTSOURCE_SEGMENT       8192
#define     ERRCODE_LOC_STREAMINPUTSOURCE   9999
#define     STREAMINPUTSOURCE_TOKENSIZE     1024
#define     STREAMINPUTSOURCE_TOKENSIZE2    64

XERCES_CPP_NAMESPACE_USE;

BEGIN_XDFLENGINE_NS


//============================================================================= 
//  CLASS PROGRESSIVEINPUTSTREAM
//----------------------------------------------------------------------------- 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    //_____________________________________________________________________
    //  PROGRESSIVEINPUTSTREAM
    //--------------------------------------------------------------------- 
    ProgressiveInputStream::ProgressiveInputStream( StreamInputSource* p_pStreamInputSource)
    {
        m_uiVirtualPosition = 0;
        m_pStreamInputSource = p_pStreamInputSource;
    }

    //_____________________________________________________________________
    //  ~PROGRESSIVEINPUTSTREAM
    //--------------------------------------------------------------------- 
    ProgressiveInputStream::~ProgressiveInputStream()
    {
    }

    //_____________________________________________________________________
    //  CURPOS
    //--------------------------------------------------------------------- 
    unsigned int ProgressiveInputStream::curPos() const
    {
        return m_uiVirtualPosition;
    }

    //_____________________________________________________________________
    //  READBYTES
    //--------------------------------------------------------------------- 
    unsigned int ProgressiveInputStream::readBytes( XMLByte* const toFill, const unsigned int maxToRead)
    {
        unsigned int l_uiRead=0;

        l_uiRead = m_pStreamInputSource->readData( (char*)toFill, maxToRead);
        

        m_uiVirtualPosition += l_uiRead;
        return l_uiRead;
    }

//-----------------------------------------------------------------------------
//============================================================================= 




//============================================================================= 
//  CLASS STREAMINPUTSOURCE
//----------------------------------------------------------------------------- 

    //_____________________________________________________________________
    //  SETENCODING
    //--------------------------------------------------------------------- 
    void StreamInputSource::setEncoding(const char* m_pszEncoding)
    {
        m_pxchEncoding = STRX(m_pszEncoding);
    }

// CONSTRUCTOR AND DESCTRUCTOR

    //_____________________________________________________________________
    //  STREAMINPUTSOURCE
    //--------------------------------------------------------------------- 
    StreamInputSource::StreamInputSource()
    {
        m_uiBeginIndex=0;
        m_uiEndIndex=0;
        m_uiBufSize = STREAMINPUTSOURCE_TOKENSIZE;
        m_pszDataBuf = (char*) malloc( m_uiBufSize);
        m_fComplete=false;
        setEncoding( CHAR_ENCODING_DEFAULT);
    }

    //_____________________________________________________________________
    //  ~STREAMINPUTSOURCE
    //--------------------------------------------------------------------- 
    StreamInputSource::~StreamInputSource()
    {
        XMLString::release(&m_pxchEncoding);    
        free( m_pszDataBuf);
    }

// DATA BUFFER MANAGEMENT



    //_____________________________________________________________________
    //  WRITEDATA
    //--------------------------------------------------------------------- 
    void StreamInputSource::writeData( const char*  p_pszData, unsigned int p_uiDataLen)
    {
        unsigned int l_uiDisp;
        unsigned int l_uiNewBufSize;
        bool         l_fCirc;

        if(p_pszData && (p_uiDataLen>0))
        {

            // check buffer size
            l_fCirc = false;
            l_uiDisp = m_uiBufSize - available() -1;
            if( m_uiBeginIndex > m_uiEndIndex) l_fCirc=true;

            if( l_uiDisp < p_uiDataLen )
            {
                // realloc buffer
                l_uiNewBufSize=m_uiBufSize;
                while( l_uiNewBufSize-available()-1 < p_uiDataLen) l_uiNewBufSize = l_uiNewBufSize*2;
                m_pszDataBuf = (char*) realloc( m_pszDataBuf, l_uiNewBufSize);
                
                if(l_fCirc )
                {
                    // if circular, copy data at end of old block to the end of the new block.
                    memcpy( m_pszDataBuf + l_uiNewBufSize - m_uiBufSize + m_uiBeginIndex, m_pszDataBuf + m_uiBeginIndex, m_uiBufSize - m_uiBeginIndex);
                    m_uiBeginIndex = l_uiNewBufSize - m_uiBufSize + m_uiBeginIndex;
                }

                m_uiBufSize = l_uiNewBufSize;
            }

            if( (!l_fCirc) && ( m_uiBufSize - m_uiEndIndex < p_uiDataLen ) )
            {
                // copy first part at end of block ...
                memcpy(m_pszDataBuf + m_uiEndIndex, p_pszData, m_uiBufSize - m_uiEndIndex);
                // ... and the rest at the beginning
                memcpy(m_pszDataBuf , p_pszData + m_uiBufSize - m_uiEndIndex, p_uiDataLen - m_uiBufSize + m_uiEndIndex);
                m_uiEndIndex = p_uiDataLen - m_uiBufSize + m_uiEndIndex;
            }
            else
            {
                // enough space : copy at end of current data
                memcpy(m_pszDataBuf + m_uiEndIndex, p_pszData, p_uiDataLen);
                m_uiEndIndex+=p_uiDataLen;
            }


            //logout << "\n+" << p_uiDataLen << "=" << available() << " /" << m_uiBufSize << "\n";
        }
    }

    //_____________________________________________________________________
    //  READDATA
    //--------------------------------------------------------------------- 
    unsigned int StreamInputSource::readData( char* const p_pszToFill, const unsigned int p_uiMaxToRead)
    {
        bool l_fCirc;
        unsigned int l_uiDataSize;
        unsigned int l_uiDataRead;
        const char* l_pszNullPI="<?NULL?>";

        l_fCirc = false;
        if( m_uiBeginIndex > m_uiEndIndex) l_fCirc=true;

        l_uiDataSize = available();
        
        l_uiDataRead = p_uiMaxToRead;
        if(l_uiDataRead > l_uiDataSize - STREAMINPUTSOURCE_TOKENSIZE ) l_uiDataRead = l_uiDataSize - STREAMINPUTSOURCE_TOKENSIZE ;
        if(l_uiDataSize <= STREAMINPUTSOURCE_TOKENSIZE) l_uiDataRead=32;
        if(l_uiDataSize <= STREAMINPUTSOURCE_TOKENSIZE2) l_uiDataRead=1;


        if(l_uiDataSize == 0)
        {
            if(!m_fComplete)
            {
                memcpy( p_pszToFill, l_pszNullPI, strlen(l_pszNullPI));
                return strlen(l_pszNullPI);
            }
            else return 0;
        }

        
        if( (! l_fCirc) || ( l_fCirc && ( m_uiBufSize - m_uiBeginIndex >= l_uiDataRead ) ) )
        {
            // copy data from block to output buffer
            memcpy( p_pszToFill, m_pszDataBuf + m_uiBeginIndex, l_uiDataRead);          
            m_uiBeginIndex += l_uiDataRead;
            if( m_uiBeginIndex == m_uiBufSize) m_uiBeginIndex=0;
        }
        else
        {       
            // circular : copy end of the block to the begin ouput buffer ..
            memcpy( p_pszToFill, m_pszDataBuf + m_uiBeginIndex, m_uiBufSize - m_uiBeginIndex);
            //.. and the begin of the block to the end of the ouput buffer
            memcpy( p_pszToFill + m_uiBufSize - m_uiBeginIndex, m_pszDataBuf, l_uiDataRead - m_uiBufSize + m_uiBeginIndex);
            m_uiBeginIndex = (l_uiDataRead - m_uiBufSize + m_uiBeginIndex);
        }
        
        /*
        char* pick=(char*)malloc(l_uiDataRead+1);
        memcpy(pick, p_pszToFill, l_uiDataRead);
        pick[l_uiDataRead]='\0';
        logout << pick << ".";
        free(pick);
        */
        //logout << "\n-" << l_uiDataRead << "=" << available() << " /" << m_uiBufSize << "\n";

        return l_uiDataRead;
    }

    //_____________________________________________________________________
    //  FLUSHDATA
    //--------------------------------------------------------------------- 
    void StreamInputSource::flushData()
    {
        m_uiBeginIndex=0;
        m_uiEndIndex=0;
    }

    //_____________________________________________________________________
    //  AVAILABLE
    //--------------------------------------------------------------------- 
    unsigned int StreamInputSource::available()
    {
        if( m_uiEndIndex - m_uiBeginIndex == m_uiBufSize) return 0;
        if( m_uiBeginIndex <= m_uiEndIndex) return  m_uiEndIndex - m_uiBeginIndex;
        else return m_uiBufSize + m_uiEndIndex - m_uiBeginIndex;
    }


// INPUTSOURCE

    //_____________________________________________________________________
    //  GETENCODING
    //--------------------------------------------------------------------- 
    const XMLCh * StreamInputSource::getEncoding () const
    {
        return m_pxchEncoding;
    }
    
    
    
    //_____________________________________________________________________
    //  MAKESTREAM
    //--------------------------------------------------------------------- 
    BinInputStream* StreamInputSource::makeStream() const
    {
        return new ProgressiveInputStream( (StreamInputSource*) this);
    }

    //_____________________________________________________________________
    //  SETCOMPLETE
    //--------------------------------------------------------------------- 
    void StreamInputSource::setComplete()
    {
        m_fComplete=true;
    }

//-----------------------------------------------------------------------------
//============================================================================= 









//============================================================================= 
//  CLASS STREAMSAX2PARSER
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// CONSTRUCTOR AND DESCTRUCTOR

    //_____________________________________________________________________
    //  STREAMSAX2PARSER
    //---------------------------------------------------------------------
    StreamSAX2Parser::StreamSAX2Parser(ContentHandler* p_pContentHandler, ErrorHandler* p_pErrorHandler)
    {
        m_fParseStarted = false;

        m_pContentHandler = p_pContentHandler;
        m_pErrorHandler = p_pErrorHandler;

        // inits the SAX parser object.  
        m_pSAX2XMLReader = XMLReaderFactory::createXMLReader(); 
        m_pSAX2XMLReader->setFeature( XMLUni::fgXercesContinueAfterFatalError, true);
        m_pSAX2XMLReader->setFeature( XMLUni::fgXercesDynamic, true);
        m_pSAX2XMLReader->setFeature( XMLUni::fgXercesSchema, false);
        m_pSAX2XMLReader->setFeature( XMLUni::fgXercesSchemaFullChecking, false);
         
        m_pSAX2XMLReader->setFeature( XMLUni::fgSAX2CoreValidation, true);
        m_pSAX2XMLReader->setFeature( XMLUni::fgSAX2CoreNameSpaces, true);
        m_pSAX2XMLReader->setFeature( XMLUni::fgSAX2CoreNameSpacePrefixes, true);

        // Give handler to the parser
        m_pSAX2XMLReader->setContentHandler( p_pContentHandler);
        m_pSAX2XMLReader->setErrorHandler  ( p_pErrorHandler);
    }

    //_____________________________________________________________________
    //  STREAMSAX2PARSER
    //---------------------------------------------------------------------
    StreamSAX2Parser::~StreamSAX2Parser()
    {
        //m_pSAX2XMLReader->parseReset( m_ScanToken);
        delete( m_pSAX2XMLReader);
    }

// STREAM OPERATORS

    //_____________________________________________________________________
    //  WRITEDATA
    //--------------------------------------------------------------------- 
    void StreamSAX2Parser::writeData( const char*   p_pszData, unsigned int p_uiDataLen)
    {
        m_StreamInputSource.writeData( p_pszData, p_uiDataLen);
    }

    //_____________________________________________________________________
    //  COMMITSTREAM
    //---------------------------------------------------------------------
    bool StreamSAX2Parser::commitStream(bool l_fFinal)
    {
        bool l_fParseResp = false;
        bool l_fGotMore = true;

        //logout << "commit for "<< m_StreamInputSource.available() ;

        if(l_fFinal) m_StreamInputSource.setComplete();

        if( !m_fParseStarted)
        {
            l_fParseResp = m_pSAX2XMLReader->parseFirst( m_StreamInputSource, m_ScanToken);
            if( !l_fParseResp) return false;
            else m_fParseStarted = true;
        }

        while( l_fGotMore && ( l_fFinal || ( m_StreamInputSource.available() > STREAMINPUTSOURCE_TOKENSIZE )  ))
        {
            l_fGotMore = m_pSAX2XMLReader->parseNext( m_ScanToken);
            if(m_pSAX2XMLReader->getErrorCount() ) return false;
        }
        
        return true;
    }

//-----------------------------------------------------------------------------
//============================================================================= 


END_XDFLENGINE_NS

---