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 cxAnalyzer --

    "cxAnalyzer" 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.

    "cxAnalyzer" 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 "cxAnalyzer"; 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:      cxAnalyzerTree
Author:     Alexander Berthold
Copyright:  Alexander Berthold
Date:       2001/12/19
Version:	0.2.01
Purpose:    Helper class for building the parse tree.
			Is used by cxAnalyzerMain.
			- Logs rules / tokens (m_vecLogElems / m_stkTrans)
			- Builds a parse tree out of the log (paptBuildTreeInternal)

Version history:

	-	2001/05/19
		Released the version 0.1.05

	-	2001/05/30
		Fixed small problems with STLport-4.0

	-	2001/06/12
		Current source labeled version 0.1.07

	-	2001/13/12
		Added cpGetCheckpoint/vExtractLogData/vInsertLogData. 
		Were required by intruducing caching.

	-	2001/17/12
		Added fFindPrevTokens*. Is currently not used, but can be
		convenient while resolving unknown tokens to explore the
		context.

	-	2001/12/19
		Labeled 0.2.01

*********************************************************************/

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

#if !defined(AFX_CXANALYZERTREE_H__9C412DB6_8E58_4F19_9EAB_48D2DA182F43__INCLUDED_)
#define AFX_CXANALYZERTREE_H__9C412DB6_8E58_4F19_9EAB_48D2DA182F43__INCLUDED_

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

class cxAnalyzerExpression;
class cxaParseTree;

class cxAnalyzerTree  
{
// Construction/Destruction
public:
	cxAnalyzerTree();
	virtual ~cxAnalyzerTree();

// Subclasses
protected:
    enum    {
        le_begin_rule,
        le_token,
        le_end_rule,
		le_nop
        };

    struct  __log_elem
        {
        int         nType;
		int			nAtmType;
		int			nIDValue;
        const void  *pLogData;
        const void  *pExtraData;
        };

// Public subclasses
public:
	struct	token_item
		{
		int			nAtmType, nIDValue;
		const cxaToken *patToken;
		const void	*pvData;
		};

// Typedefs
protected:
    typedef std::stack<int>             trans_stk_type;
public:
    typedef std::vector<__log_elem>     log_vec_type;
	typedef int							chkpoint_type;

// Attributes
protected:
    int             m_nBeginTransCnt;
    trans_stk_type  m_stkTrans;
    log_vec_type    m_vecLogElems;

// Protected operations
protected:
    void            vLog(int nType, int nAtmType, int nIDValue, const void *pLogData, const void *pExtraData);

// Operations
public:
	// Return a 'checkpoint' containing the position of the next log element.
	chkpoint_type	cpGetCheckpoint() const;
	// Extract the log data since 'cpStartPos' up to 'cpEndPos' and store it into 'dest'
	void			vExtractLogData(chkpoint_type cpStartPos, log_vec_type& dest, chkpoint_type cpEndPos = -1) const;
	// Insert Log data at the tail of the current log
	void			vInsertLogData(const log_vec_type& src);

	// Begin log transaction
	void            vBeginTrans();
	// Commit log transaction
    void            vCommitTrans();
	// Rollback log transaction
    void            vRollbackTrans();

	// Log begin of a rule
	void			vBeginRule(int nAtmType, int nIDValue, const cxAnalyzerExpression* pExpr);
	// Log a token
    void            vLogToken(int nAtmType, int nIDValue, void *pvData, const cxaToken* patToken);
	// Log the end of a rule
    void            vEndRule();
	// Clean up the log
	void			vCleanUp(const cxAnalyzerMain* pamParser);

	// Explore previously recognized tokens
	bool			fFindPrevTokensByAtm(long lCount, int nAtmType, token_item* pPrevItems) const;
	bool			fFindPrevTokensByID(long lCount, int nIDValue, token_item* pPrevItems) const;
	bool			fFindPrevTokens(long lCount, token_item* pPrevItems) const;

	// Reset status
    void            vReset()
        {
        ASSERT(m_stkTrans.empty());
        m_nBeginTransCnt    =0;
        m_vecLogElems.clear();
        }

    void            vDumpLog();
    cxaParseTree	*paptBuildTreeInternal(const cxAnalyzerMain* pamParser);
};

#endif // !defined(AFX_CXANALYZERTREE_H__9C412DB6_8E58_4F19_9EAB_48D2DA182F43__INCLUDED_)