Tokenizer and analyzer package supporting precedence prioritized rules

/*********************************************************************
	Copyright (C) 2001/2 by

		Alexander Berthold, alexander-berthold@web.de.
		Hoegestr. 54
		79108 Freiburg i. Breisgau
		Germany

    -- This file is part of cxTokenizer --

    "cxTokenizer" is free software; you can redistribute it and/or 
	modify it under the terms of the GNU Lesser General Public 
	License as published by the Free Software Foundation; either 
	version 2 of the License, or any later version.

    "cxTokenizer" 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 Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
	License along with "cxTokenizer"; if not, write to the Free 
	Software  Foundation, Inc., 59 Temple Place, Suite 330, 
	Boston, MA  02111-1307  USA

    ---------------------------------------------------------------
      If you find any bugs or if you make other corrections/
	  enhancements, i'd appreciate if you'd let me know about 
	  that. My email is
  
       alexander-berthold@web.de
  
      If you share this code, do not remove this text.
    ---------------------------------------------------------------

Class:      cxTokenizerTextInputStream
Author:     Alexander Berthold
Copyright:  Alexander Berthold
Date:       2001/12/19
Version:	0.2.01
Purpose:    Sample input stream class for the parser.
            Takes a LPCTSTR as constructor argument and creates
            a cxTokenizerInputStream compatible stream out of it.


Version history:

	-	2001/05/19
		Renamed class from 'cpLexxerTextInputStream' to 
		'cxTokenizerTextInputStream'.

	-	2001/06/02
		Current source labeled version 0.1.14

	-	2001/06/03
		Changed base class from cxTokenizerInputStream to
		cxTokenizerInputStreamDefaultImpl and made the necessary
		modifications in the code.
		See cxTokenizerInputStreamDefaultImpl.

	-	2001/12/19
		Current source labeled version 0.2.01
				
*********************************************************************/

// cxTokenizerTextInputStream.h: interface for the cxTokenizerTextInputStream class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_CXTOKENIZERTEXTINPUTSTREAM_H__CB2EA5EA_2239_4926_B7BF_6CC6972A3E14__INCLUDED_)
#define AFX_CXTOKENIZERTEXTINPUTSTREAM_H__CB2EA5EA_2239_4926_B7BF_6CC6972A3E14__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

template<class TBase>
class cxTokenizerTextInputStream : public TBase
{
// Construction/Destruction
public:
	cxTokenizerTextInputStream(const TCHAR* lpszInputData, bool fShouldDelete = false)
		{
		m_strInputData	=lpszInputData;
		m_strPutBackData=_T("");
		m_nInputPos		=0;
		m_nPutBackPos	=0;
		m_fShouldDelete	=fShouldDelete;
		}

	virtual ~cxTokenizerTextInputStream()
		{
		}

// Attributes
protected:
	std::tstring	m_strInputData;
	int				m_nInputPos;
	std::tstring	m_strPutBackData;
	int				m_nPutBackPos;
	bool			m_fShouldDelete;

// Protected operations
protected:
	virtual bool	fReadBlock(long lStartPos, long lLength, std::tstring& strResult, TCHAR tcTermChar) const
		{
		ASSERT(lLength>=0);
		ASSERT(lStartPos>=0);
		long		lPos, lCnt = 0;
		long		lInputLength = m_strInputData.length();
		strResult	=_T("");
		ASSERT(lStartPos<=lInputLength);

		if( lStartPos == lInputLength)
			return true;

		for(lPos = lStartPos; lCnt<lLength && lPos<lInputLength; lPos++, lCnt++)
			{
			TCHAR	tcTemp = m_strInputData[lPos];

			if(tcTemp==tcTermChar)
				break;
			
			strResult	+=tcTemp;
			}

		return true;
		};

// Operations
public:
	virtual	bool	fCheckValid() const
		{
		return true;
		}

	virtual TCHAR	tcPeekNextCharacter() const
		{
		int		nPutBackLength = m_strPutBackData.length();
		TCHAR	tcReturn = _T('\0');
		bool	fEof = fIsEofReached();

		if(fEof)
			return 0;

		if(m_nPutBackPos < nPutBackLength)
			tcReturn	=m_strPutBackData[m_nPutBackPos];
		else
			tcReturn	=m_strInputData[m_nInputPos];

		return tcReturn;
		}

	virtual TCHAR	tcGetNextCharacter()
		{
		int		nPutBackLength = m_strPutBackData.length();
		TCHAR	tcReturn = _T('\0');
		bool	fEof = fIsEofReached();

		ASSERT(!fEof);
		if(fEof)
			throw cxTokenizerException(ERR_READ_PAST_EOF);

		if(m_nPutBackPos < nPutBackLength)
			{
			tcReturn	=m_strPutBackData[m_nPutBackPos++];
			if(m_nPutBackPos == nPutBackLength)
				{
				m_nPutBackPos	=0;
				m_strPutBackData=_T("");
				}
			}
		else
			{
			tcReturn	=m_strInputData[m_nInputPos++];
			}

		return tcGetNextCharacterDefaultImpl(tcReturn);
		}

	virtual bool	fPutBack(LPCTSTR lpszText)
		{
		m_strPutBackData.insert(0,lpszText);
		return fPutBackDefaultImpl(lpszText);
		}

	virtual bool	fPutBack(TCHAR tcChar)
		{
		// Compatibility with STLport 4.0 ->
		TCHAR		szTemp[2] = { 0,0 };
		szTemp[0]	=tcChar;
		m_strPutBackData.insert(0,szTemp);
		return fPutBackDefaultImpl(tcChar);
		}

	virtual bool	fIsEofReached() const
		{
		int		nInputLength = m_strInputData.length();
		int		nPutBackLength = m_strPutBackData.length();

		if(	(m_nPutBackPos == nPutBackLength) &&
			(m_nInputPos == nInputLength))
			return true;

		return false;
		}

	virtual bool	fShouldDelete() const
		{
		return m_fShouldDelete;
		}
};

#endif // !defined(AFX_CXTOKENIZERTEXTINPUTSTREAM_H__CB2EA5EA_2239_4926_B7BF_6CC6972A3E14__INCLUDED_)