rexinterface.cpp

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

#include "stdafx.h"
#include "RexInterface.h"
#include <stdio.h>
#include <exception>

/* REXI_Base */
REXI_Base::REXI_Base()
:m_pszSource(""),m_pszTokenBeg(""),m_pszTokenEnd("")
,m_pStartState(REXA_DFAState::ms_pEosState)
{
}
REXI_Base::~REXI_Base()
{
    m_pStartState->DeleteAll();
}
REXI_DefErr   REXI_Base::AddRegDefinition    (string strName,string strRegExp,
                                            int nIdAnswer)
{
    REXI_DefErr defErr;
    defErr.eErrCode=REXI_DefErr::eNoErr;
    defErr.strErrMsg="";
    defErr.nErrOffset=0;
    try{
        m_regexpParser.AddRegDefinition(strName,strRegExp,nIdAnswer);
    }catch(REXA_Exception e){
        defErr.strErrMsg= e.m_strErrMsg;
        if( e.m_nErrPos>strName.size()+1){
            defErr.eErrCode= REXI_DefErr::eErrInRegExp;
            defErr.nErrOffset= e.m_nErrPos-(strName.size()+1);
        }else{
            defErr.eErrCode=REXI_DefErr::eErrInName;
            defErr.nErrOffset= e.m_nErrPos;
        }
    }
    return defErr;
}
void                REXI_Base::GetRegDefinitions   (vector<string>& vecDefinitions)
{
    m_regexpParser.GetRegDefinitions(vecDefinitions);
}
void                REXI_Base::RemoveRegDefinition (string strName)
{
    m_regexpParser.RemoveRegDefinition(strName);
}

REXI_DefErr   REXI_Base::SetRegexpImpl(string strRegExp,REXA_DFAState*& pStateToSet)
{
    REXI_DefErr defErr;
    defErr.eErrCode=REXI_DefErr::eNoErr;
    defErr.strErrMsg="";
    defErr.nErrOffset=0;
    try{
        REXA_DFAState* pStartState= m_regexpParser.ParseRegExp(strRegExp);
        pStateToSet->DeleteAll();
        pStateToSet= pStartState;
    }catch(REXA_Exception e){
        defErr.eErrCode=REXI_DefErr::eErrInRegExp;
        defErr.strErrMsg= e.m_strErrMsg;
        defErr.nErrOffset= e.m_nErrPos;
    }
    return defErr;
}


/* REXI_Search */
REXI_Search::REXI_Search()
:m_nIdAnswer(0)
{
}
REXI_Search::REXI_Search(const REXI_Search& rexiSearch)
:m_nIdAnswer(rexiSearch.m_nIdAnswer)
{
}
REXI_Search& REXI_Search::operator=(const REXI_Search& rexiSearch)
{
    if( &rexiSearch!=this ){
        REXI_Base::operator =(rexiSearch);
        m_nIdAnswer= rexiSearch.m_nIdAnswer;
    }
    return *this;
}

REXI_DefErr  REXI_Search::AddRegDef(string strName,string strRegExp)
{
     return REXI_Base::AddRegDefinition(strName,strRegExp,m_nIdAnswer++);
}
bool REXI_Search::MatchHereImpl()
{
    m_pszTokenBeg= m_pszTokenEnd;

    const REXA_DFAState* pState= m_pStartState;
    const char* pAccept=0;
	while(     m_pszTokenEnd!=m_pszSourceEnd 
            && !(pState= pState->aNext[*(unsigned char*)m_pszTokenEnd++])->m_bIsFinal){
        if(pState->m_bIsAccepting){
            pAccept= m_pszTokenEnd;
            m_nIdAnswer= pState->m_nAnwserId;//Nov-4
        }
	}
	m_pszTokenEnd--;
    if(!pState->m_bIsAccepting  ){
        if( pAccept ){
            m_pszTokenEnd= pAccept;
            return true;
        }
        return false;
    }else{
        m_nIdAnswer= pState->m_nAnwserId;//Nov-4
    }
    return true;
}
bool REXI_Search::MatchHere(const char*& rpcszSrc, int& nMatchLen,bool& bEos)
{
    SetSource(rpcszSrc);
    bool bFound= MatchHereImpl();
    nMatchLen= m_pszTokenEnd-m_pszTokenBeg;
    rpcszSrc= m_pszTokenEnd;
    bEos= (m_pszTokenEnd+1>=m_pszSourceEnd);
    rpcszSrc= m_pszTokenEnd;
    return bFound;
}

bool REXI_Search::Find(const char*& rpcszSrc, int& nMatchLen,bool& bEos)
{
    bool bFound;
    SetSource(rpcszSrc);
    for(;;){
        while(  m_pszTokenEnd!=m_pszSourceEnd  
            &&  m_pStartState->aNext[*(unsigned char*)m_pszTokenEnd]==REXA_DFAState::ms_pIllegalState ){
            m_pszTokenEnd++;
        }
        if( MatchHereImpl() ){
            bFound= true;
            break;
        }
        bEos= (m_pszTokenEnd+1>=m_pszSourceEnd);
        if( bEos ){
            break;
        }
        m_pszTokenEnd= m_pszTokenBeg+1;
    }
    bEos= (m_pszTokenEnd+1>=m_pszSourceEnd);
    nMatchLen= m_pszTokenEnd-m_pszTokenBeg;
    rpcszSrc= m_pszTokenEnd;
	return bFound;
}

/* REXI_Scan */
REXI_Scan::REXI_Scan(char cLineBreak)
:   m_cLineBreakChar(cLineBreak),m_nNofLines(0),
    m_pSkipStart(REXA_DFAState::ms_pEosState)
{
    SetRegexpImpl("[ \t\v\r\n]*",m_pSkipStart);
}
REXI_Scan::~REXI_Scan()
{
    m_pSkipStart->DeleteAll();
}
REXI_Scan::REXI_Scan(const REXI_Scan& rexiScan)
:REXI_Base(rexiScan),m_pSkipStart(rexiScan.m_pSkipStart->Clone()),
    m_nLastSymbol(rexiScan.m_nLastSymbol),m_setSymbolDefs(rexiScan.m_setSymbolDefs)
{
}
REXI_Scan& REXI_Scan::operator=(const REXI_Scan& rexiScan)
{
    if( &rexiScan!=this ){
        REXI_Base::operator =(rexiScan);
        m_pSkipStart->DeleteAll();
        m_pSkipStart= rexiScan.m_pSkipStart->Clone();
        m_nLastSymbol= rexiScan.m_nLastSymbol;
        m_setSymbolDefs= rexiScan.m_setSymbolDefs;
    }
    return *this;
}
string  REXI_Scan::MakeRegExpName(int nAnswer)
{
    char buf[32];
    sprintf(buf,"%d",nAnswer);
    return string("$_Exp")+buf;
}
REXI_DefErr     
        REXI_Scan::SetToSkipRegExp     (string strRegExp)
{
   return SetRegexpImpl(strRegExp,m_pSkipStart);
}
REXI_DefErr
        REXI_Scan::AddSymbolDef(string strRegExp,int nIdAnswer)
{
    REXI_DefErr err= AddRegDefinition(MakeRegExpName(nIdAnswer),strRegExp,nIdAnswer);
    if( err.eErrCode==REXI_DefErr::eNoErr ){
        m_setSymbolDefs.insert(nIdAnswer);
        m_pStartState->DeleteAll();
        m_pStartState= REXA_DFAState::ms_pEosState;
    }
    return err;
}

REXI_DefErr
        REXI_Scan::AddHelperRegDef     (string strName,string strRegExp)
{
    return AddRegDefinition(strName,strRegExp,REXA_DFAState::eNoAnswer);
}

void    REXI_Scan::RemoveAllSymbolDef  ()
{
    vector<string> vecDefinitions;

    m_setSymbolDefs.clear();
    GetRegDefinitions   (vecDefinitions);
    for(int i=0;i<vecDefinitions.size();i++){
        RemoveRegDefinition(vecDefinitions[i]);
    }
}

int     REXI_Scan::Scan()
{
    if( m_pStartState==REXA_DFAState::ms_pEosState){
        SetSymbolIds::const_iterator it;
        string strRegExp;
        for(it= m_setSymbolDefs.begin();it!=m_setSymbolDefs.end();++it){
            if( it!= m_setSymbolDefs.begin()){
                strRegExp+= "|";
            }
            strRegExp+= MakeRegExpName(*it);
        }
        SetRegexpImpl(strRegExp,m_pStartState);
    }
    if( m_pSkipStart ){
        Match(m_pSkipStart,true);
    }
    m_pszTokenBeg= m_pszTokenEnd;
    if( m_pStartState ){
        return Match(m_pStartState,false);
    }
    return REXA_DFAState::eEos;
}