Tokenizer and analyzer package supporting precedence prioritized rules

/*********************************************************************
	Copyright (C) 2001 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/06/12
Version:	0.1.07
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

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

// 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
        };

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

    struct  __btree_elem
        {
        int             nPrecPrio;
        //cooxTreeElement *pxteLimit;
        };

// Typedefs
protected:
    typedef std::vector<__log_elem>     log_vec_type;
    typedef std::stack<int>             trans_stk_type;
    typedef std::stack<__btree_elem>    btree_stk_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);

// Operations
public:
    void            vBeginTrans();
    void            vCommitTrans();
    void            vRollbackTrans();

	void			vBeginRule(int nAtmType, int nIDValue, const cxAnalyzerExpression* pExpr);
    void            vLogToken(const cxaToken* patToken);
    void            vEndRule();

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

    void            vDumpLog();
    cxaParseTree	*paptBuildTreeInternal();
};

#endif // !defined(AFX_CXANALYZERTREE_H__9C412DB6_8E58_4F19_9EAB_48D2DA182F43__INCLUDED_)