rexinterface.h

关于使用正则进行词法分析的程序

#ifndef REX_INTERFACE_INCLUDED_
#define REX_INTERFACE_INCLUDED_

#include "RexAlgorithm.h"

struct REXI_DefErr{
        enum{eNoErr,eErrInName,eErrInRegExp} eErrCode;
        string  strErrMsg;
        int     nErrOffset;
};

class REXI_Base{
public:
    enum{eEos=-1,eIllegal=-2};
	REXI_Base();
    virtual ~REXI_Base()=0;

    inline REXI_Base(const REXI_Base& rexiBase);
    inline REXI_Base& operator=(const REXI_Base& rexiBase);

    inline void			SetSource       (const char* pszSource);
    inline const char*  GetSource       ()const;

    
    REXI_DefErr     AddRegDefinition    (string strName,string strRegExp,int nIdAnswer);
    void            GetRegDefinitions   (vector<string>& vecDefinitions);
    void            RemoveRegDefinition (string strName);


protected:      
    REXI_DefErr     SetRegexpImpl(string strRegExp,REXA_DFAState*& pStateToSet);
//source,source position and end of string character
	const char*     m_pszSource;
    const char*     m_pszSourceEnd;
    const char*     m_pszTokenBeg;
    const char*     m_pszTokenEnd;

//algorithmic objects
	REXA_Parser		    m_regexpParser;

	REXA_DFAState*      m_pStartState;

};

class REXI_Search : public REXI_Base
{ 
public:
    REXI_Search();
    REXI_Search(const REXI_Search& rexiSearch);
    REXI_Search& operator=(const REXI_Search& rexiSearch);

    REXI_DefErr
            AddRegDef   (string strName,string strRegExp);
    inline  REXI_DefErr  
            SetRegexp	(string strRegExp);

    bool    MatchHere   (const char*& rpcszSrc, int& nMatchLen,bool& bEos);
    bool    Find        (const char*& rpcszSrc, int& nMatchLen,bool& bEos);

    int     GetAnswer   ();
private:
    bool    MatchHereImpl();
    int     m_nIdAnswer;
};


class REXI_Scan : public REXI_Base
{
public:
/*constructor,destructor,assignement operator */
    REXI_Scan(char cLineBreak= '\n');
    ~REXI_Scan();
    REXI_Scan(const REXI_Scan& rexiScan);
    REXI_Scan& operator=(const REXI_Scan& rexiScan);

/*initialize scanner with symbol definitions */
    REXI_DefErr     SetToSkipRegExp     (string strRegExp= "[ \r\n\v\t]*");
    REXI_DefErr     AddSymbolDef        (string strRegExp,int nIdAnswer);
    void            RemoveAllSymbolDef  ();
    REXI_DefErr     AddHelperRegDef     (string strName,string strRegExp);

/* set,get source */
	inline  void    SetSource           (const char* pszSource);
    inline 
        const char* GetSource           ()const ;

/* Read next token, then return symbolId */
    int				Scan                ();

/* retrieve,set information after a call to 'Scan'*/
    inline  string  GetTokenString      ()const;
    inline  void    GetTokenBegEnd      (const char*& pcszTokenBeg,const char*& pcszTokenEnd);
    inline  void    SetTokenBegEnd      (const char* pcszTokenBeg,const char* pcszTokenEnd);
    inline  void    SkipChars           (int nOfChars=1);
    inline  int		GetLastSymbol       ()const;
    inline  int     GetNofLines         ()const;
protected:
    inline  int     Match(const REXA_DFAState* pState,bool bStopBeforeIllegal);
    string          MakeRegExpName(int nAnswer);
    //scanner related members
	REXA_DFAState*  m_pSkipStart;
    int             m_nLastSymbol;

    int             m_nNofLines;
    unsigned char   m_cLineBreakChar;

    typedef set<int> SetSymbolIds;
    SetSymbolIds    m_setSymbolDefs;
};

/* inline functions for REXI_Base */
inline REXI_Base::REXI_Base(const REXI_Base& rexiBase)
:m_pszSource(rexiBase.m_pszSource),
    m_pszTokenBeg(rexiBase.m_pszTokenBeg),m_pszTokenEnd(rexiBase.m_pszTokenEnd),
	m_regexpParser(rexiBase.m_regexpParser),m_pStartState(rexiBase.m_pStartState->Clone())
{
}
inline REXI_Base& REXI_Base::operator=(const REXI_Base& rexiBase)
{
    if( &rexiBase!= this){
        m_pStartState->DeleteAll();
        m_pszSource=    rexiBase.m_pszSource;
        m_pszTokenBeg=  rexiBase.m_pszTokenBeg;
        m_pszTokenEnd=  rexiBase.m_pszTokenEnd;
	    m_regexpParser= rexiBase.m_regexpParser;
        m_pStartState=  rexiBase.m_pStartState->Clone();
    }
    return *this;
}
inline const char*     REXI_Base::GetSource()const                  {return m_pszSource;}
inline void			   REXI_Base::SetSource(const char* pszSource)
{
    m_pszSource=    pszSource; 
    m_pszTokenBeg=  m_pszTokenEnd=  pszSource; 
    m_pszSourceEnd= pszSource+strlen(pszSource);
}

/* inline functions for REXI_Search */
inline int          REXI_Search::GetAnswer()                        {return m_nIdAnswer;}
inline REXI_DefErr  REXI_Search::SetRegexp(string strRegExp)
{
    return REXI_Base::SetRegexpImpl(strRegExp,m_pStartState);
}

/* inline functions for REXI_Scan */
inline  string      REXI_Scan::GetTokenString      ()const
{
    return string(m_pszTokenBeg,m_pszTokenEnd-m_pszTokenBeg);
}
inline  void        REXI_Scan::GetTokenBegEnd      (const char*& pcszTokenBeg,const char*& pcszTokenEnd)
{
    pcszTokenBeg= m_pszTokenBeg; 
    pcszTokenEnd= m_pszTokenEnd;
}
inline  void        REXI_Scan::SetTokenBegEnd      (const char* pcszTokenBeg,const char* pcszTokenEnd)
{
    m_pszTokenBeg= pcszTokenBeg;
    m_pszTokenEnd= pcszTokenEnd;
}
inline  void        REXI_Scan::SkipChars           (int nOfChars)
{
    while(m_pszTokenEnd!=m_pszSourceEnd && nOfChars>0){
        m_pszTokenEnd++;
        nOfChars--;
    }
}
inline  int         REXI_Scan::GetLastSymbol       ()const          {return m_nLastSymbol;}
inline  int         REXI_Scan::GetNofLines         ()const          {return m_nNofLines;}
inline  void        REXI_Scan::SetSource           (const char* pcszSource)
                                                                    {REXI_Base::SetSource(pcszSource);}
inline const char*  REXI_Scan::GetSource           ()const          {return m_pszSource;}
inline int          REXI_Scan::Match(const REXA_DFAState* pState,bool bStopBeforeIllegal)
{
    unsigned char c;
    if( m_pszTokenEnd==m_pszSourceEnd ){
        return eEos;
    }
    while(   !(pState= pState->aNext[c=*(unsigned char*)m_pszTokenEnd++])->m_bIsFinal){
        if(c==m_cLineBreakChar){
            m_nNofLines++;
        }
        if( m_pszTokenEnd>m_pszSourceEnd ){
            break;
        }
	}
    if( pState->m_nAnwserId!=eIllegal || bStopBeforeIllegal || m_pszTokenEnd>m_pszTokenBeg+1){
        m_pszTokenEnd--;
    }
    return pState->m_nAnwserId;
}
#endif