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:      cxAnalyzerMain
Author:     Alexander Berthold
Copyright:  Alexander Berthold
Date:       2001/06/12
Version:	0.1.07
Purpose:    Main class of this package. 
			- Stores the analyzer rules describing the grammar 
			  (m_mapAtmAEList).
			- Stores implicit mappings (m_mapAtmImplicit)
			- Provides the functionality to analyze a sequence
			  of tokens for a given rule (fCheckRule).


Version history:

	-	2001/05/19
		Released the version 0.1.05

	-	2001/06/01
		Optimized fCheckRule. If used for checking for a rule
		which is finite, it was still tried to test if the rule
		continues.

	-	2001/06/02
		Added cxaStatusCookie. Intended for providing error
		information.

	-	2001/06/02
		Source labeled version 0.1.06

	-	2001/06/12
		Fixed some bugs with cxaStatusCookie. Improved accuracy
		of returned information.
		Version number is now 0.1.07

ToDo:
	-	Further optimize fCheckRule:
		Currently it is only being differentiated between finite
		and non-finite rules. Can be improved by differentiating
		between left-only non-finite rules and right-only non-finite
		rules.

	-	Generally optimize the code. There is 50%-70% more speed by
		optimizing easily possible.

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

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

#if !defined(AFX_CXANALYZERMAIN_H__CCC86421_3E3E_4694_A24A_2CDC157E268B__INCLUDED_)
#define AFX_CXANALYZERMAIN_H__CCC86421_3E3E_4694_A24A_2CDC157E268B__INCLUDED_

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

class cxAnalyzerTree;

class cxaStatusCookie
{
// Construction/Destruction
public:
	cxaStatusCookie()
		{
		nMaxLength	=0;
		nCurLength	=0;
		nBrkCause	=0;
		patToken	=NULL;
		lPosition	=0;
		};

// Attributes
public:
	enum	{
		brkcause_ok=0,
		brkcause_eots,
		brkcause_wrongtoken,
		brkcause_subrulefailed,
		brkcause_notokens,
		brkcause_unexpected
		};

	int		nMaxLength;			/* Internally used */
	int		nCurLength;			/* Internally used */

	int		nBrkCause;			/* parsing error cause */
	const cxaToken* patToken;	/* token where the error happened */
	long	lPosition;			/* Position in the input stream where the error happened */

// Operations
public:
	void	vSetBrkCause(int nBrkCause_, const cxaToken* patToken_)
		{
		if(nCurLength>=nMaxLength)
			{
			nBrkCause=nBrkCause_;
			nMaxLength=nCurLength;
			patToken=patToken_;
			lPosition=(patToken_!=NULL)?patToken_->nGetTokenOrderID():-1;
			}
		}
};

class cxAnalyzerMain
{
// Construction/Destruction
public:
	cxAnalyzerMain(cxAnalyzerTypeMap *patmTypeMap);
	virtual ~cxAnalyzerMain();

	struct	atm_imp {
		atm_imp(int _nAtmType, int _nIDValue)
			{
			nAtmType	=_nAtmType;
			nIDValue	=_nIDValue;
			}
		int		nAtmType;
		int		nIDValue;
		};

// Typedefs
public:
	typedef std::list<cxAnalyzerExpression*>
						ae_list_type;
	typedef std::vector<cxAnalyzerExpression*>
						ae_vec_type;
	typedef	std::map<int,ae_list_type*>
						atmae_map_type;
	typedef std::multimap<int,atm_imp>
						atmimp_map_type;

// Attributes
protected:
	// Already initialized?
	bool				m_fInitialized;
	// The TypeMap this expression belongs to
	cxAnalyzerTypeMap	*m_patmTypeMap;
	// Implicit mappings
	atmimp_map_type	m_mapAtmImplicit;
	// Map from nPttmID's to cxAnalyzerExpression
	atmae_map_type		m_mapAtmAEList;
	// Vector of cxAnalyzerExpression*'s to delete
	ae_vec_type			m_vecAEToDelete;

// Protected operations
protected:
	void				vRegisterAE(cxAnalyzerExpression* paeExpr);

// Operations
public:

	/*** Debugging support ***/
	bool				fCheckValid() const { return true; };
	void				vDump() const		{ ASSERT(FALSE); };


	/*** Initialization ***/
	bool				fLoadFromStream(std::basic_istream<TCHAR>& input);


	/*** Analyzer operations ***/
	// Test if 'nAtmTypeTestFor' belongs implictly to the
	// expression of type 'nAtmTypeSource'
	bool				fIsImplicitRule(int nAtmTypeTestFor, 
										int nAtmTypeSource,
										int *pnIDValue) const;

	// Check if the given position in the token stream matches
	// the expression 'nAtmTypeTestFor', and determine (if it matches)
	// the next token after the expression.
	bool				fCheckRule(	int nAtmTypeTestFor,
									const cxaTokenStream* patsContext,
									int nAtmTypeFirstIs, /*= PTTM_ID_INVALID */
                                    const cxaToken* patFirstToken /* = NULL */,
									cxaStatusCookie* pascCondition,
									cxaTokenStream::const_iterator start,
									cxaTokenStream::const_iterator *pend,
									cxAnalyzerTree* patTree = NULL) const;

	friend class cxAnalyzer;
};

#endif // !defined(AFX_CXANALYZERMAIN_H__CCC86421_3E3E_4694_A24A_2CDC157E268B__INCLUDED_)