[C++] [正则表达式] 一个不错的正则表达式引擎4C++

// RegEx.cpp : 定义控制台应用程序的入口点。
//
// 本文所使用的“正则表达式解析引擎”来自
// http://www.regexlab.com/deelx/
// 
#include "stdafx.h"
#include "Regex.h"

/**//// ===========================================================================
/// 合法的IP
/// A.B.C.D
/// A/B/C/D 为[0-255]间的整数
/// 本规则忽略数字前导0，即 00192 == 192
/// ---------------------------------------------------------------------------
int is_ip( const char* str )
...{
    static CRegexpT< char > regexp( "0*(1/d{0,2}|2([0-4]/d?|5[0-5]?|/d?)|[3-9]/d?|0)(.0*(1/d{0,2}|2([0-4]/d?|5[0-5]?|/d?)|[3-9]/d?|0)){3}" );
    MatchResult mrRet = regexp.MatchExact( str );

    return mrRet.IsMatched();
}

int is_email( const char* str )
...{
    static CRegexpT< char > regexp( "^/w+(/./w+)*@/w+(/./w+)+$" );
    MatchResult mrRet = regexp.MatchExact( str );

    return mrRet.IsMatched();
}

int _tmain(int argc, _TCHAR* argv[])
...{
    char* ip1 = "192.168.58.251";
    char* ip2 = "256.168.58.251";

    printf( "%s ==> %s " , ip1 , (is_ip(ip1)?"yes":"no") );
    printf( "%s ==> %s " , ip2 , (is_ip(ip2)?"yes":"no") );

    char* m1 = "hjbcn@126.com";
    char* m2 = "hjbcn#126.com";

    printf( "%s ==> %s " , m1 , (is_email(m1)?"yes":"no") );
    printf( "%s ==> %s " , m2 , (is_email(m2)?"yes":"no") );

    getchar();
    return 0;
}

 

 

// RegEx.h
//
// DEELX Regular Expression Engine (v1.2)
//
// Copyright 2006 (c) RegExLab.com
// All Rights Reserved.
//
// http://www.regexlab.com/deelx/
//
// Author: 史寿伟 (sswater shi)
// sswater@gmail.com
//
// $Revision: 1.1.2.27 $
//

#ifndef __DEELX_REGEXP__H__
#define __DEELX_REGEXP__H__

#include <memory.h>
#include <ctype.h>
#include <limits.h>
#include <string.h>
#include <stdio.h>

//
// Data Reference
//
template <class ELT> class CBufferRefT
...{
public:
    CBufferRefT(const ELT * pcsz, int length);
    CBufferRefT(const ELT * pcsz);

public:
    int nCompare      (const ELT * pcsz) const;
    int nCompareNoCase(const ELT * pcsz) const;
    int  Compare      (const ELT * pcsz) const;
    int  CompareNoCase(const ELT * pcsz) const;
    int  Compare      (const CBufferRefT <ELT> &) const;
    int  CompareNoCase(const CBufferRefT <ELT> &) const;

    ELT At          (int nIndex, ELT def = 0) const;
    ELT operator [] (int nIndex) const;

    const ELT * GetBuffer() const;
    int GetSize() const;

public:
    virtual ~CBufferRefT();

// Content
protected:
    const ELT * m_pRef;
    int         m_nSize;
};

//
// Implemenation
//
template <class ELT> CBufferRefT <ELT> :: CBufferRefT(const ELT * pcsz, int length)
...{
    m_pRef  = pcsz;
    m_nSize = length;
}

template <class ELT> CBufferRefT <ELT> :: CBufferRefT(const ELT * pcsz)
...{
    m_pRef  = pcsz;
    m_nSize = 0;

    if(pcsz != 0) while(m_pRef[m_nSize] != 0) m_nSize ++;
}

template <class ELT> int CBufferRefT <ELT> :: nCompare(const ELT * pcsz) const
...{
    for(int i=0; i<m_nSize; i++)
    ...{
        if(m_pRef[i] != pcsz[i])
            return m_pRef[i] - pcsz[i];
    }

    return 0;
}

template <class ELT> int CBufferRefT <ELT> :: nCompareNoCase(const ELT * pcsz) const
...{
    for(int i=0; i<m_nSize; i++)
    ...{
        if(m_pRef[i] != pcsz[i])
        ...{
            if(toupper((int)m_pRef[i]) != toupper((int)pcsz[i]))
                return m_pRef[i] - pcsz[i];
        }
    }

    return 0;
}

template <class ELT> inline int CBufferRefT <ELT> :: Compare(const ELT * pcsz) const
...{
    return nCompare(pcsz) ? 1 : (int)pcsz[m_nSize];
}

template <class ELT> inline int CBufferRefT <ELT> :: CompareNoCase(const ELT * pcsz) const
...{
    return nCompareNoCase(pcsz) ? 1 : (int)pcsz[m_nSize];
}

template <class ELT> inline int CBufferRefT <ELT> :: Compare(const CBufferRefT <ELT> & cref) const
...{
    return m_nSize == cref.m_nSize ? nCompare(cref.GetBuffer()) : 1;
}

template <class ELT> inline int CBufferRefT <ELT> :: CompareNoCase(const CBufferRefT <ELT> & cref) const
...{
    return m_nSize == cref.m_nSize ? nCompareNoCase(cref.GetBuffer()) : 1;
}

template <class ELT> inline ELT CBufferRefT <ELT> :: At(int nIndex, ELT def) const
...{
    return nIndex >= m_nSize ? def : m_pRef[nIndex];
}

template <class ELT> inline ELT CBufferRefT <ELT> :: operator [] (int nIndex) const
...{
    return nIndex >= m_nSize ? 0 : m_pRef[nIndex];
}

template <class ELT> const ELT * CBufferRefT <ELT> :: GetBuffer() const
...{
    static const ELT _def[] = ...{0}; return m_pRef ? m_pRef : _def;
}

template <class ELT> inline int CBufferRefT <ELT> :: GetSize() const
...{
    return m_nSize;
}

template <class ELT> CBufferRefT <ELT> :: ~CBufferRefT()
...{
}

//
// Data Buffer
//
template <class ELT> class CBufferT : public CBufferRefT <ELT>
...{
public:
    CBufferT(const ELT * pcsz, int length);
    CBufferT(const ELT * pcsz);
    CBufferT();

public:
    ELT & operator [] (int nIndex);
    const ELT & operator [] (int nIndex) const;
    void  Append(const ELT * pcsz, int length, int eol = 0);
    void  Append(ELT el, int eol = 0);

public:
    void  Push(ELT   el);
    int   Pop (ELT & el);
    int   Peek(ELT & el) const;

public:
    const ELT * GetBuffer() const;
    ELT * GetBuffer();
    ELT * Detach();
    void  Release();
    void  Prepare(int index, int fill = 0);
    void  Restore(int size);

public:
    virtual ~CBufferT();

// Content
protected:
    ELT * m_pBuffer;
    int   m_nMaxLength;
};

//
// Implemenation
//
template <class ELT> CBufferT <ELT> :: CBufferT(const ELT * pcsz, int length) : CBufferRefT <ELT> (0, length)
...{
    m_nMaxLength = CBufferRefT <ELT> :: m_nSize + 1;

    CBufferRefT <ELT> :: m_pRef = m_pBuffer = new ELT[m_nMaxLength];
    memcpy(m_pBuffer, pcsz, sizeof(ELT) * CBufferRefT <ELT> :: m_nSize);
    m_pBuffer[CBufferRefT <ELT> :: m_nSize] = 0;
}

template <class ELT> CBufferT <ELT> :: CBufferT(const ELT * pcsz) : CBufferRefT <ELT> (pcsz)
...{
    m_nMaxLength = CBufferRefT <ELT> :: m_nSize + 1;

    CBufferRefT <ELT> :: m_pRef = m_pBuffer = new ELT[m_nMaxLength];
    memcpy(m_pBuffer, pcsz, sizeof(ELT) * CBufferRefT <ELT> :: m_nSize);
    m_pBuffer[CBufferRefT <ELT> :: m_nSize] = 0;
}

template <class ELT> CBufferT <ELT> :: CBufferT() : CBufferRefT <ELT> (0, 0)
...{
    m_nMaxLength = 0;
    m_pBuffer    = 0;
}

template <class ELT> inline ELT & CBufferT <ELT> :: operator [] (int nIndex)
...{
    return m_pBuffer[nIndex];
}

template <class ELT> inline const ELT & CBufferT <ELT> :: operator [] (int nIndex) const
...{
    return m_pBuffer[nIndex];
}

template <class ELT> void CBufferT <ELT> :: Append(const ELT * pcsz, int length, int eol)
...{
    int nNewLength = m_nMaxLength;

    // Check length
    if(nNewLength < 8)
        nNewLength = 8;

    if(CBufferRefT <ELT> :: m_nSize + length + eol > nNewLength)
        nNewLength *= 2;

    if(CBufferRefT <ELT> :: m_nSize + length + eol > nNewLength)
    ...{
        nNewLength  = CBufferRefT <ELT> :: m_nSize + length + eol + 11;
        nNewLength -= nNewLength % 8;
    }

    // Realloc
    if(nNewLength > m_nMaxLength)
    ...{
        ELT * pNewBuffer = new ELT[nNewLength];

        if(m_pBuffer != 0)
        ...{
            memcpy(pNewBuffer, m_pBuffer, sizeof(ELT) * CBufferRefT <ELT> :: m_nSize);
            delete [] m_pBuffer;
        }

        CBufferRefT <ELT> :: m_pRef = m_pBuffer = pNewBuffer;
        m_nMaxLength = nNewLength;
    }

    // Append
    memcpy(m_pBuffer + CBufferRefT <ELT> :: m_nSize, pcsz, sizeof(ELT) * length);
    CBufferRefT <ELT> :: m_nSize += length;

    if(eol > 0) m_pBuffer[CBufferRefT <ELT> :: m_nSize] = 0;
}

template <class ELT> inline void CBufferT <ELT> :: Append(ELT el, int eol)
...{
    Append(&el, 1, eol);
}

template <class ELT> void CBufferT <ELT> :: Push(ELT el)
...{
    // Realloc
    if(CBufferRefT <ELT> :: m_nSize >= m_nMaxLength)
    ...{
        int nNewLength = m_nMaxLength * 2;
        if( nNewLength < 8 ) nNewLength = 8;

        ELT * pNewBuffer = new ELT[nNewLength];

        if(m_pBuffer != 0)
        ...{
            memcpy(pNewBuffer, m_pBuffer, sizeof(ELT) * CBufferRefT <ELT> :: m_nSize);
            delete [] m_pBuffer;
        }

        CBufferRefT <ELT> :: m_pRef = m_pBuffer = pNewBuffer;
        m_nMaxLength = nNewLength;
    }

    // Append
    m_pBuffer[CBufferRefT <ELT> :: m_nSize++] = el;
}

template <class ELT> inline int CBufferT <ELT> :: Pop(ELT & el)
...{
    if(CBufferRefT <ELT> :: m_nSize > 0)
    ...{
        el = m_pBuffer[--CBufferRefT <ELT> :: m_nSize];
        return 1;
    }
    else
    ...{
        return 0;
    }
}

template <class ELT> inline int CBufferT <ELT> :: Peek(ELT & el) const
...{
    if(CBufferRefT <ELT> :: m_nSize > 0)
    ...{
        el = m_pBuffer[CBufferRefT <ELT> :: m_nSize - 1];
        return 1;
    }
    else
    ...{
        return 0;
    }
}

template <class ELT> const ELT * CBufferT <ELT> :: GetBuffer() const
...{
    static const ELT _def[] = ...{0}; return m_pBuffer ? m_pBuffer : _def;
}

template <class ELT> ELT * CBufferT <ELT> :: GetBuffer()
...{
    static const ELT _def[] = ...{0}; return m_pBuffer ? m_pBuffer : (ELT *)_def;
}

template <class ELT> ELT * CBufferT <ELT> :: Detach()
...{
    ELT * pBuffer = m_pBuffer;

    CBufferRefT <ELT> :: m_pRef  = m_pBuffer    = 0;
    CBufferRefT <ELT> :: m_nSize = m_nMaxLength = 0;

    return pBuffer;
}

template <class ELT> void CBufferT <ELT> :: Release()
...{
    ELT * pBuffer = Detach();

    if(pBuffer != 0) delete [] pBuffer;
}

template <class ELT> void CBufferT <ELT> :: Prepare(int index, int fill)
...{
    int nNewSize = index + 1;

    // Realloc
    if(nNewSize > m_nMaxLength)
    ...{
        int nNewLength = m_nMaxLength;

        if( nNewLength < 8 )
            nNewLength = 8;

        if( nNewSize > nNewLength )
            nNewLength *= 2;

        if( nNewSize > nNewLength )
        ...{
            nNewLength  = nNewSize + 11;
            nNewLength -= nNewLength % 8;
        }

        ELT * pNewBuffer = new ELT[nNewLength];

        if(m_pBuffer != 0)
        ...{
            memcpy(pNewBuffer, m_pBuffer, sizeof(ELT) * CBufferRefT <ELT> :: m_nSize);
            delete [] m_pBuffer;
        }

        CBufferRefT <ELT> :: m_pRef = m_pBuffer = pNewBuffer;
        m_nMaxLength = nNewLength;
    }

    // size
    if( CBufferRefT <ELT> :: m_nSize < nNewSize )
    ...{
        memset(m_pBuffer + CBufferRefT <ELT> :: m_nSize, fill, sizeof(ELT) * (nNewSize - CBufferRefT <ELT> :: m_nSize));
        CBufferRefT <ELT> :: m_nSize = nNewSize;
    }
}

template <class ELT> inline void CBufferT <ELT> :: Restore(int size)
...{
    CBufferRefT <ELT> :: m_nSize = size;
}

template <class ELT> CBufferT <ELT> :: ~CBufferT()
...{
    if(m_pBuffer != 0) delete [] m_pBuffer;
}

//
// Context
//
class CContext
...{
public:
    CBufferT <int> m_stack;
    CBufferT <int> m_capturestack, m_captureindex;

public:
    int    m_nCurrentPos;
    int    m_nBeginPos;
    int    m_nLastBeginPos;
    int    m_nParenZindex;

    void * m_pMatchString;
    int    m_pMatchStringLength;
};

//
// Interface
//
class ElxInterface
...{
public:
    virtual int Match    (CContext * pContext) const = 0;
    virtual int MatchNext(CContext * pContext) const = 0;

public:
    virtual ~ElxInterface() ...{};
};

//
// Alternative
//
template <int x> class CAlternativeElxT : public ElxInterface
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CAlternativeElxT();

public:
    CBufferT <ElxInterface *> m_elxlist;
};

typedef CAlternativeElxT <0> CAlternativeElx;

//
// Assert
//
template <int x> class CAssertElxT : public ElxInterface
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CAssertElxT(ElxInterface * pelx, int byes = 1);

public:
    ElxInterface * m_pelx;
    int m_byes;
};

typedef CAssertElxT <0> CAssertElx;

//
// Back reference elx
//
template <class CHART> class CBackrefElxT : public ElxInterface
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CBackrefElxT(int nnumber, int brightleft, int bignorecase);

public:
    int m_nnumber;
    int m_brightleft;
    int m_bignorecase;

    CBufferT <CHART> m_szNamed;
};

//
// Implementation
//
template <class CHART> CBackrefElxT <CHART> :: CBackrefElxT(int nnumber, int brightleft, int bignorecase)
...{
    m_nnumber     = nnumber;
    m_brightleft  = brightleft;
    m_bignorecase = bignorecase;
}

template <class CHART> int CBackrefElxT <CHART> :: Match(CContext * pContext) const
...{
    // check number, for named
    if( m_nnumber < 0 || m_nnumber >= pContext->m_captureindex.GetSize() ) return 0;

    int index = pContext->m_captureindex[m_nnumber];
    if( index < 0 ) return 0;

    // check enclosed
    int pos1 = pContext->m_capturestack[index + 1];
    int pos2 = pContext->m_capturestack[index + 2];

    if( pos2 < 0 ) pos2 = pContext->m_nCurrentPos;

    // info
    int lpos = pos1 < pos2 ? pos1 : pos2;
    int rpos = pos1 < pos2 ? pos2 : pos1;
    int slen = rpos - lpos;

    const CHART * pcsz = (const CHART *)pContext->m_pMatchString;
    int npos = pContext->m_nCurrentPos;
    int tlen = pContext->m_pMatchStringLength;

    // compare
    int bsucc;
    CBufferRefT <CHART> refstr(pcsz + lpos, slen);

    if( m_brightleft )
    ...{
        if(npos < slen)
            return 0;

        if(m_bignorecase)
            bsucc = ! refstr.nCompareNoCase(pcsz + (npos - slen));
        else
            bsucc = ! refstr.nCompare      (pcsz + (npos - slen));

        if( bsucc )
        ...{
            pContext->m_stack.Push(npos);
            pContext->m_nCurrentPos -= slen;
        }
    }
    else
    ...{
        if(npos + slen > tlen)
            return 0;

        if(m_bignorecase)
            bsucc = ! refstr.nCompareNoCase(pcsz + npos);
        else
            bsucc = ! refstr.nCompare      (pcsz + npos);

        if( bsucc )
        ...{
            pContext->m_stack.Push(npos);
            pContext->m_nCurrentPos += slen;
        }
    }

    return bsucc;
}

template <class CHART> int CBackrefElxT <CHART> :: MatchNext(CContext * pContext) const
...{
    int npos = 0;

    pContext->m_stack.Pop(npos);
    pContext->m_nCurrentPos = npos;

    return 0;
}

// RCHART
#ifndef RCHART
    #define RCHART(ch) ((CHART)ch)
#endif

// BOUNDARY_TYPE
enum BOUNDARY_TYPE
...{
    BOUNDARY_FILE_BEGIN, // begin of whole text
    BOUNDARY_FILE_END  , // end of whole text
    BOUNDARY_LINE_BEGIN, // begin of line
    BOUNDARY_LINE_END  , // end of line
    BOUNDARY_WORD_BEGIN, // begin of word
    BOUNDARY_WORD_END  , // end of word
    BOUNDARY_WORD_EDGE ,
};

//
// Boundary Elx
//
template <class CHART> class CBoundaryElxT : public ElxInterface
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CBoundaryElxT(int ntype, int byes = 1);

protected:
    static int IsWordChar(CHART ch);

public:
    int m_ntype;
    int m_byes;
};

//
// Implementation
//
template <class CHART> CBoundaryElxT <CHART> :: CBoundaryElxT(int ntype, int byes)
...{
    m_ntype = ntype;
    m_byes  = byes;
}

template <class CHART> int CBoundaryElxT <CHART> :: Match(CContext * pContext) const
...{
    const CHART * pcsz  = (const CHART *)pContext->m_pMatchString;
    int npos = pContext->m_nCurrentPos;
    int tlen = pContext->m_pMatchStringLength;

    CHART chL = npos > 0    ? pcsz[npos - 1] : 0;
    CHART chR = npos < tlen ? pcsz[npos    ] : 0;

    int bsucc = 0;

    switch(m_ntype)
    ...{
    case BOUNDARY_FILE_BEGIN:
        bsucc = (npos <= 0);
        break;

    case BOUNDARY_FILE_END:
        bsucc = (npos >= tlen);
        break;

    case BOUNDARY_LINE_BEGIN:
        bsucc = (npos <= 0   ) || (chL == RCHART(' ')) || ((chL == RCHART(' ')) && (chR != RCHART(' ')));
        break;

    case BOUNDARY_LINE_END:
        bsucc = (npos >= tlen) || (chR == RCHART(' ')) || ((chR == RCHART(' ')) && (chL != RCHART(' ')));
        break;

    case BOUNDARY_WORD_BEGIN:
        bsucc = ! IsWordChar(chL) &&   IsWordChar(chR);
        break;

    case BOUNDARY_WORD_END:
        bsucc =   IsWordChar(chL) && ! IsWordChar(chR);
        break;

    case BOUNDARY_WORD_EDGE:
        bsucc =   IsWordChar(chL) ?  ! IsWordChar(chR) : IsWordChar(chR);
        break;
    }

    return bsucc;
}

template <class CHART> int CBoundaryElxT <CHART> :: MatchNext(CContext *) const
...{
    return 0;
}

template <class CHART> inline int CBoundaryElxT <CHART> :: IsWordChar(CHART ch)
...{
    return (ch >= RCHART('A') && ch <= RCHART('Z')) || (ch >= RCHART('a') && ch <= RCHART('z')) || (ch >= RCHART('0') && ch <= RCHART('9')) || (ch == RCHART('_'));
}

//
// Bracket
//
template <class CHART> class CBracketElxT : public ElxInterface  
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CBracketElxT(int nnumber, int bright);

public:
    int m_nnumber;
    int m_bright;

    CBufferT <CHART> m_szNamed;
};

template <class CHART> CBracketElxT <CHART> :: CBracketElxT(int nnumber, int bright)
...{
    m_nnumber = nnumber;
    m_bright  = bright;
}

template <class CHART> int CBracketElxT <CHART> :: Match(CContext * pContext) const
...{
    // check, for named
    if(m_nnumber < 0) return 0;

    if( ! m_bright )
    ...{
        pContext->m_captureindex.Prepare(m_nnumber, -1);
        int index = pContext->m_captureindex[m_nnumber];

        // check
        if(index > 0 && index < pContext->m_capturestack.GetSize() && pContext->m_capturestack[index+2] < 0)
        ...{
            pContext->m_capturestack[index+3] --;
            return 1;
        }

        // save
        pContext->m_captureindex[m_nnumber] = pContext->m_capturestack.GetSize();

        pContext->m_capturestack.Push(m_nnumber);
        pContext->m_capturestack.Push(pContext->m_nCurrentPos);
        pContext->m_capturestack.Push(-1);
        pContext->m_capturestack.Push( 0); // z-index
    }
    else
    ...{
        // check
        int index = pContext->m_captureindex[m_nnumber];

        if(pContext->m_capturestack[index + 3] < 0)
        ...{
            pContext->m_capturestack[index + 3] ++;
            return 1;
        }

        // save
        pContext->m_capturestack[index + 2] = pContext->m_nCurrentPos;
        pContext->m_capturestack[index + 3] = pContext->m_nParenZindex ++;
    }

    return 1;
}

template <class CHART> int CBracketElxT <CHART> :: MatchNext(CContext * pContext) const
...{
    int index = pContext->m_captureindex[m_nnumber];

    if( ! m_bright )
    ...{
        if(pContext->m_capturestack[index + 3] < 0)
        ...{
            pContext->m_capturestack[index + 3] ++;
            return 0;
        }

        pContext->m_capturestack.Restore(pContext->m_capturestack.GetSize() - 4);

        // to find
        index = pContext->m_capturestack.GetSize() - 4;
        while(index >= 0 && pContext->m_capturestack[index] != m_nnumber) index -= 4;

        // new index
        pContext->m_captureindex[m_nnumber] = index;
    }
    else
    ...{
        if(pContext->m_capturestack[index + 3] < 0)
        ...{
            pContext->m_capturestack[index + 3] --;
            return 0;
        }

        pContext->m_capturestack[index + 2] = -1;
        pContext->m_capturestack[index + 3] =  0;
    }

    return 0;
}

//
// Deletage
//
template <class CHART> class CDelegateElxT : public ElxInterface  
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CDelegateElxT(int ndata = 0);

public:
    ElxInterface * m_pelx;
    int m_ndata; // +0 : recursive to
                 // -3 : named recursive

    CBufferT <CHART> m_szNamed;
};

template <class CHART> CDelegateElxT <CHART> :: CDelegateElxT(int ndata)
...{
    m_pelx  = 0;
    m_ndata = ndata;
}

template <class CHART> int CDelegateElxT <CHART> :: Match(CContext * pContext) const
...{
    if(m_pelx != 0)
        return m_pelx->Match(pContext);
    else
        return 1;
}

template <class CHART> int CDelegateElxT <CHART> :: MatchNext(CContext * pContext) const
...{
    if(m_pelx != 0)
        return m_pelx->MatchNext(pContext);
    else
        return 0;
}

//
// Empty
//
template <int x> class CEmptyElxT : public ElxInterface
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CEmptyElxT();
};

typedef CEmptyElxT <0> CEmptyElx;

//
// Global
//
template <int x> class CGlobalElxT : public ElxInterface
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CGlobalElxT();
};

typedef CGlobalElxT <0> CGlobalElx;

//
// Repeat
//
template <int x> class CRepeatElxT : public ElxInterface
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CRepeatElxT(ElxInterface * pelx, int ntimes);

protected:
    int MatchFixed    (CContext * pContext) const;
    int MatchNextFixed(CContext * pContext) const;

public:
    ElxInterface * m_pelx;
    int m_nfixed;
};

typedef CRepeatElxT <0> CRepeatElx;

//
// Greedy
//
template <int x> class CGreedyElxT : public CRepeatElxT <x>
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CGreedyElxT(ElxInterface * pelx, int nmin = 0, int nmax = INT_MAX);

protected:
    int MatchVart    (CContext * pContext) const;
    int MatchNextVart(CContext * pContext) const;

public:
    int m_nvart;
};

typedef CGreedyElxT <0> CGreedyElx;

//
// Independent
//
template <int x> class CIndependentElxT : public ElxInterface
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CIndependentElxT(ElxInterface * pelx);

public:
    ElxInterface * m_pelx;
};

typedef CIndependentElxT <0> CIndependentElx;

//
// List
//
template <int x> class CListElxT : public ElxInterface
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CListElxT(int brightleft);

public:
    CBufferT <ElxInterface *> m_elxlist;
    int m_brightleft;
};

typedef CListElxT <0> CListElx;

//
// Posix Elx
//
template <class CHART> class CPosixElxT : public ElxInterface
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CPosixElxT(const char * posix, int brightleft);

protected:
    static int m_isblank(int c);

public:
    int (*m_posixfun)(int);
    int m_brightleft;
    int m_byes;
};

//
// Implementation
//
template <class CHART> CPosixElxT <CHART> :: CPosixElxT(const char * posix, int brightleft)
...{
    m_brightleft = brightleft;

    if(posix[1] == '^')
    ...{
        m_byes = 0;
        posix += 2;
    }
    else
    ...{
        m_byes = 1;
        posix += 1;
    }

    if     (!strncmp(posix, "alnum:", 6)) m_posixfun = ::isalnum ;
    else if(!strncmp(posix, "alpha:", 6)) m_posixfun = ::isalpha ;
    else if(!strncmp(posix, "ascii:", 6)) m_posixfun = ::isascii ;
    else if(!strncmp(posix, "cntrl:", 6)) m_posixfun = ::iscntrl ;
    else if(!strncmp(posix, "digit:", 6)) m_posixfun = ::isdigit ;
    else if(!strncmp(posix, "graph:", 6)) m_posixfun = ::isgraph ;
    else if(!strncmp(posix, "lower:", 6)) m_posixfun = ::islower ;
    else if(!strncmp(posix, "print:", 6)) m_posixfun = ::isprint ;
    else if(!strncmp(posix, "punct:", 6)) m_posixfun = ::ispunct ;
    else if(!strncmp(posix, "space:", 6)) m_posixfun = ::isspace ;
    else if(!strncmp(posix, "upper:", 6)) m_posixfun = ::isupper ;
    else if(!strncmp(posix, "xdigit:",7)) m_posixfun = ::isxdigit;
    else if(!strncmp(posix, "blank:", 6)) m_posixfun = m_isblank ;
    else                                  m_posixfun = 0         ;
}

template <class CHART> int CPosixElxT <CHART> :: m_isblank(int c)
...{
    return c == 0x20 || c == ' ';
}

template <class CHART> int CPosixElxT <CHART> :: Match(CContext * pContext) const
...{
    if(m_posixfun == 0) return 0;

    int tlen = pContext->m_pMatchStringLength;
    int npos = pContext->m_nCurrentPos;

    // check
    int at   = m_brightleft ? npos - 1 : npos;
    if( at < 0 || at >= tlen )
        return 0;

    CHART ch = ((const CHART *)pContext->m_pMatchString)[at];

    int bsucc = (*m_posixfun)(ch);

    if( ! m_byes )
        bsucc = ! bsucc;

    if( bsucc )
        pContext->m_nCurrentPos += m_brightleft ? -1 : 1;

    return bsucc;
}

template <class CHART> int CPosixElxT <CHART> :: MatchNext(CContext * pContext) const
...{
    pContext->m_nCurrentPos -= m_brightleft ? -1 : 1;
    return 0;
}

//
// Possessive
//
template <int x> class CPossessiveElxT : public CGreedyElxT <x>
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CPossessiveElxT(ElxInterface * pelx, int nmin = 0, int nmax = INT_MAX);
};

typedef CPossessiveElxT <0> CPossessiveElx;

//
// Range Elx
//
template <class CHART> class CRangeElxT : public ElxInterface
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CRangeElxT(int brightleft, int byes);

public:
    CBufferT <CHART> m_ranges;
    CBufferT <CHART> m_chars;
    CBufferT <ElxInterface *> m_embeds;

public:
    int m_brightleft;
    int m_byes;
};

//
// Implementation
//
template <class CHART> CRangeElxT <CHART> :: CRangeElxT(int brightleft, int byes)
...{
    m_brightleft = brightleft;
    m_byes       = byes;
}

template <class CHART> int CRangeElxT <CHART> :: Match(CContext * pContext) const
...{
    int tlen = pContext->m_pMatchStringLength;
    int npos = pContext->m_nCurrentPos;

    // check
    int at   = m_brightleft ? npos - 1 : npos;
    if( at < 0 || at >= tlen )
        return 0;

    CHART ch = ((const CHART *)pContext->m_pMatchString)[at];
    int bsucc = 0, i;

    // compare
    for(i=0; !bsucc && i<m_ranges.GetSize(); i+=2)
    ...{
        if(m_ranges[i] <= ch && ch <= m_ranges[i+1]) bsucc = 1;
    }

    for(i=0; !bsucc && i<m_chars.GetSize(); i++)
    ...{
        if(m_chars[i] == ch) bsucc = 1;
    }

    for(i=0; !bsucc && i<m_embeds.GetSize(); i++)
    ...{
        if(m_embeds[i]->Match(pContext))
        ...{
            pContext->m_nCurrentPos = npos;
            bsucc = 1;
        }
    }

    if( ! m_byes )
        bsucc = ! bsucc;

    if( bsucc )
        pContext->m_nCurrentPos += m_brightleft ? -1 : 1;

    return bsucc;
}

template <class CHART> int CRangeElxT <CHART> :: MatchNext(CContext * pContext) const
...{
    pContext->m_nCurrentPos -= m_brightleft ? -1 : 1;
    return 0;
}

//
// Reluctant
//
template <int x> class CReluctantElxT : public CRepeatElxT <x>
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CReluctantElxT(ElxInterface * pelx, int nmin = 0, int nmax = INT_MAX);

protected:
    int MatchVart    (CContext * pContext) const;
    int MatchNextVart(CContext * pContext) const;

public:
    int m_nvart;
};

typedef CReluctantElxT <0> CReluctantElx;

//
// String Elx
//
template <class CHART> class CStringElxT : public ElxInterface
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CStringElxT(const CHART * fixed, int nlength, int brightleft, int bignorecase);

public:
    CBufferT <CHART> m_szPattern;
    int m_brightleft;
    int m_bignorecase;
};

//
// Implementation
//
template <class CHART> CStringElxT <CHART> :: CStringElxT(const CHART * fixed, int nlength, int brightleft, int bignorecase) : m_szPattern(fixed, nlength)
...{
    m_brightleft  = brightleft;
    m_bignorecase = bignorecase;
}

template <class CHART> int CStringElxT <CHART> :: Match(CContext * pContext) const
...{
    const CHART * pcsz  = (const CHART *)pContext->m_pMatchString;
    int npos = pContext->m_nCurrentPos;
    int tlen = pContext->m_pMatchStringLength;
    int slen = m_szPattern.GetSize();

    int bsucc;

    if(m_brightleft)
    ...{
        if(npos < slen)
            return 0;

        if(m_bignorecase)
            bsucc = ! m_szPattern.nCompareNoCase(pcsz + (npos - slen));
        else
            bsucc = ! m_szPattern.nCompare      (pcsz + (npos - slen));

        if( bsucc )
            pContext->m_nCurrentPos -= slen;
    }
    else
    ...{
        if(npos + slen > tlen)
            return 0;

        if(m_bignorecase)
            bsucc = ! m_szPattern.nCompareNoCase(pcsz + npos);
        else
            bsucc = ! m_szPattern.nCompare      (pcsz + npos);

        if( bsucc )
            pContext->m_nCurrentPos += slen;
    }

    return bsucc;
}

template <class CHART> int CStringElxT <CHART> :: MatchNext(CContext * pContext) const
...{
    int slen = m_szPattern.GetSize();

    if(m_brightleft)
        pContext->m_nCurrentPos += slen;
    else
        pContext->m_nCurrentPos -= slen;

    return 0;
}

//
// CConditionElx
//
template <class CHART> class CConditionElxT : public ElxInterface
...{
public:
    int Match    (CContext * pContext) const;
    int MatchNext(CContext * pContext) const;

public:
    CConditionElxT();

public:
    // backref condition
    int m_nnumber;
    CBufferT <CHART> m_szNamed;

    // elx condition
    ElxInterface * m_pelxask;

    // selection
    ElxInterface * m_pelxyes, * m_pelxno;
};

template <class CHART> CConditionElxT <CHART> :: CConditionElxT()
...{
    m_nnumber = -1;
}

template <class CHART> int CConditionElxT <CHART> :: Match(CContext * pContext) const
...{
    // status
    int nbegin = pContext->m_nCurrentPos;
    int nsize  = pContext->m_stack.GetSize();
    int ncsize = pContext->m_capturestack.GetSize();

    // condition result
    int condition_yes = 0;

    // backref type
    if( m_nnumber >= 0 )
    ...{
        do
        ...{
            if(m_nnumber >= pContext->m_captureindex.GetSize()) break;

            int index = pContext->m_captureindex[m_nnumber];
            if( index < 0) break;

            // else valid
            condition_yes = 1;
        }
        while(0);
    }
    else
    ...{
        if( m_pelxask == 0 )
            condition_yes = 1;
        else
            condition_yes = m_pelxask->Match(pContext);

        pContext->m_stack.Restore(nsize);
        pContext->m_nCurrentPos = nbegin;
    }

    // elx result
    int bsucc;
    if( condition_yes )
        bsucc = m_pelxyes == 0 ? 1 : m_pelxyes->Match(pContext);
    else
        bsucc = m_pelxno  == 0 ? 1 : m_pelxno ->Match(pContext);

    if( bsucc )
    ...{
        pContext->m_stack.Push(ncsize);
        pContext->m_stack.Push(condition_yes);
    }
    else
    ...{
        pContext->m_capturestack.Restore(ncsize);
    }

    return bsucc;
}

template <class CHART> int CConditionElxT <CHART> :: MatchNext(CContext * pContext) const
...{
    // pop
    int ncsize, condition_yes;

    pContext->m_stack.Pop(condition_yes);
    pContext->m_stack.Pop(ncsize);

    // elx result
    int bsucc;
    if( condition_yes )
        bsucc = m_pelxyes == 0 ? 0 : m_pelxyes->MatchNext(pContext);
    else
        bsucc = m_pelxno  == 0 ? 0 : m_pelxno ->MatchNext(pContext);

    if( bsucc )
    ...{
        pContext->m_stack.Push(ncsize);
        pContext->m_stack.Push(condition_yes);
    }
    else
    ...{
        pContext->m_capturestack.Restore(ncsize);
    }

    return bsucc;
}

//
// MatchResult
//
template <int x> class MatchResultT
...{
public:
    int IsMatched() const;

public:
    int GetStart() const;
    int GetEnd  () const;

public:
    int MaxGroupNumber() const;
    int GetGroupStart(int nGroupNumber) const;
    int GetGroupEnd  (int nGroupNumber) const;

public:
    MatchResultT(CContext * pContext, int nMaxNumber = -1);
    MatchResultT <x> & operator = (const MatchResultT <x> &);
    inline operator int() const ...{ return IsMatched(); }

public:
    CBufferT <int> m_result;
};

typedef MatchResultT <0> MatchResult;

// Stocked Elx IDs
enum STOCKELX_ID_DEFINES
...{
    STOCKELX_EMPTY = 0,

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

    STOCKELX_DOT_ALL,
    STOCKELX_DOT_NOT_ALL,

    STOCKELX_WORD,
    STOCKELX_WORD_NOT,

    STOCKELX_SPACE,
    STOCKELX_SPACE_NOT,

    STOCKELX_DIGITAL,
    STOCKELX_DIGITAL_NOT,

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

    STOCKELX_DOT_ALL_RIGHTLEFT,
    STOCKELX_DOT_NOT_ALL_RIGHTLEFT,

    STOCKELX_WORD_RIGHTLEFT,
    STOCKELX_WORD_RIGHTLEFT_NOT,

    STOCKELX_SPACE_RIGHTLEFT,
    STOCKELX_SPACE_RIGHTLEFT_NOT,

    STOCKELX_DIGITAL_RIGHTLEFT,
    STOCKELX_DIGITAL_RIGHTLEFT_NOT,

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

    STOCKELX_COUNT
};

// REGEX_FLAGS
#ifndef _REGEX_FLAGS_DEFINED
    enum REGEX_FLAGS
    ...{
        NO_FLAG        = 0,
        SINGLELINE     = 0x01,
        MULTILINE      = 0x02,
        GLOBAL         = 0x04,
        IGNORECASE     = 0x08,
        RIGHTTOLEFT    = 0x10,
        EXTENDED       = 0x20,
    };
    #define _REGEX_FLAGS_DEFINED
#endif

//
// Builder T
//
template <class CHART> class CBuilderT
...{
public:
    typedef CDelegateElxT  <CHART> CDelegateElx;
    typedef CBracketElxT   <CHART> CBracketElx;
    typedef CBackrefElxT   <CHART> CBackrefElx;
    typedef CConditionElxT <CHART> CConditionElx;

// Methods
public:
    ElxInterface * Build(const CBufferRefT <CHART> & pattern, int flags);
    int GetNamedNumber(const CBufferRefT <CHART> & named) const;
    void Clear();

public:
     CBuilderT();
    ~CBuilderT();

// Public Attributes
public:
    ElxInterface * m_pTopElx;
    int            m_nFlags;
    int            m_nMaxNumber;
    int            m_nNextNamed;
    int            m_nGroupCount;

    CBufferT <ElxInterface  *> m_objlist;
    CBufferT <ElxInterface  *> m_grouplist;
    CBufferT <CDelegateElx  *> m_recursivelist;
    CBufferT <CListElx      *> m_namedlist;
    CBufferT <CBackrefElx   *> m_namedbackreflist;
    CBufferT <CConditionElx *> m_namedconditionlist;

// CHART_INFO
protected:
    struct CHART_INFO
    ...{
    public:
        CHART ch;
        int   type;
        int   pos;
        int   len;

    public:
        CHART_INFO(CHART c, int t, int p = 0, int l = 0) ...{ ch = c; type = t; pos = p; len = l;    }
        inline int operator == (const CHART_INFO & ci)   ...{ return ch == ci.ch && type == ci.type; }
        inline int operator != (const CHART_INFO & ci)   ...{ return ! operator == (ci);             }
    };

protected:
    static unsigned int Hex2Int(const CHART * pcsz, int length, int & used);
    static int ReadDec(char * & str, unsigned int & dec);
    void MoveNext();
    int  GetNext2();

    ElxInterface * BuildAlternative(int vaflags);
    ElxInterface * BuildList       (int & flags);
    ElxInterface * BuildRepeat     (int & flags);
    ElxInterface * BuildSimple     (int & flags);
    ElxInterface * BuildCharset    (int & flags);
    ElxInterface * BuildRecursive  (int & flags);
    ElxInterface * BuildBoundary   (int & flags);
    ElxInterface * BuildBackref    (int & flags);

    ElxInterface * GetStockElx     (int nStockId);
    ElxInterface * Keep(ElxInterface * pElx);

// Private Attributes
protected:
    CBufferRefT <CHART> m_pattern;
    CHART_INFO prev, curr, next, nex2;
    int m_nNextPos;
    int m_nCharsetDepth;
    int m_bQuoted;
    int (*m_quote_fun)(int);

    ElxInterface * m_pStockElxs[STOCKELX_COUNT];
};

//
// Implementation
//
template <class CHART> CBuilderT <CHART> :: CBuilderT() : m_pattern(0, 0), prev(0, 0), curr(0, 0), next(0, 0), nex2(0, 0)
...{
    Clear();
}

template <class CHART> CBuilderT <CHART> :: ~CBuilderT()
...{
    Clear();
}

template <class CHART> int CBuilderT <CHART> :: GetNamedNumber(const CBufferRefT <CHART> & named) const
...{
    for(int i=0; i<m_namedlist.GetSize(); i++)
    ...{
        if( ! ((CBracketElx *)m_namedlist[i]->m_elxlist[0])->m_szNamed.CompareNoCase(named) )
            return ((CBracketElx *)m_namedlist[i]->m_elxlist[0])->m_nnumber;
    }

    return -3;
}

template <class CHART> ElxInterface * CBuilderT <CHART> :: Build(const CBufferRefT <CHART> & pattern, int flags)
...{
    // init
    m_pattern       = pattern;
    m_nNextPos      = 0;
    m_nCharsetDepth = 0;
    m_nMaxNumber    = 0;
    m_nNextNamed    = 0;
    m_nFlags        = flags;
    m_bQuoted       = 0;
    m_quote_fun     = 0;

    m_grouplist         .Restore(0);
    m_recursivelist     .Restore(0);
    m_namedlist         .Restore(0);
    m_namedbackreflist  .Restore(0);
    m_namedconditionlist.Restore(0);

    int i;
    for(i=0; i<3; i++) MoveNext();

    // build
    m_pTopElx = BuildAlternative(flags);

    // group 0
    m_grouplist.Prepare(0);
    m_grouplist[0] = m_pTopElx;

    // append named to unnamed
    m_nGroupCount = m_grouplist.GetSize();

    m_grouplist.Prepare(m_nMaxNumber + m_namedlist.GetSize());

    for(i=0; i<m_namedlist.GetSize(); i++)
    ...{
        CBracketElx * pleft  = (CBracketElx *)m_namedlist[i]->m_elxlist[0];
        CBracketElx * pright = (CBracketElx *)m_namedlist[i]->m_elxlist[2];

        // append
        m_grouplist[m_nGroupCount ++] = m_namedlist[i];

        if( pleft->m_nnumber > 0 )
            continue;

        // same name
        int find_same_name = GetNamedNumber(pleft->m_szNamed);
        if( find_same_name >= 0 )
        ...{
            pleft ->m_nnumber = find_same_name;
            pright->m_nnumber = find_same_name;
        }
        else
        ...{
            m_nMaxNumber ++;

            pleft ->m_nnumber = m_nMaxNumber;
            pright->m_nnumber = m_nMaxNumber;
        }
    }

    for(i=1; i<m_nGroupCount; i++)
    ...{
        CBracketElx * pleft = (CBracketElx *)((CListElx*)m_grouplist[i])->m_elxlist[0];

        if( pleft->m_nnumber > m_nMaxNumber )
            m_nMaxNumber = pleft->m_nnumber;
    }

    // connect recursive
    for(i=0; i<m_recursivelist.GetSize(); i++)
    ...{
        if( m_recursivelist[i]->m_ndata == -3 )
            m_recursivelist[i]->m_ndata = GetNamedNumber(m_recursivelist[i]->m_szNamed);

        if( m_recursivelist[i]->m_ndata >= 0 && m_recursivelist[i]->m_ndata < m_grouplist.GetSize() )
            m_recursivelist[i]->m_pelx = m_grouplist[m_recursivelist[i]->m_ndata];
    }

    // named backref
    for(i=0; i<m_namedbackreflist.GetSize(); i++)
    ...{
        m_namedbackreflist[i]->m_nnumber = GetNamedNumber(m_namedbackreflist[i]->m_szNamed);
    }

    // named condition
    for(i=0; i<m_namedconditionlist.GetSize(); i++)
    ...{
        int nn = GetNamedNumber(m_namedconditionlist[i]->m_szNamed);
        if( nn >= 0 )
        ...{
            m_namedconditionlist[i]->m_nnumber = nn;
            m_namedconditionlist[i]->m_pelxask = 0;
        }
    }

    return m_pTopElx;
}

template <class CHART> void CBuilderT <CHART> :: Clear()
...{
    for(int i=0; i<m_objlist.GetSize(); i++)
    ...{
        delete m_objlist[i];
    }

    m_objlist.Restore(0);
    m_pTopElx = 0;

    memset(m_pStockElxs, 0, sizeof(m_pStockElxs));
}

//
// hex to int
//
template <class CHART> unsigned int CBuilderT <CHART> :: Hex2Int(const CHART * pcsz, int length, int & used)
...{
    unsigned int result = 0;
    int & i = used;

    for(i=0; i<length; i++)
    ...{
        if(pcsz[i] >= RCHART('0') && pcsz[i] <= RCHART('9'))
            result = (result << 4) + (pcsz[i] - RCHART('0'));
        else if(pcsz[i] >= RCHART('A') && pcsz[i] <= RCHART('F'))
            result = (result << 4) + (0x0A + (pcsz[i] - RCHART('A')));
        else if(pcsz[i] >= RCHART('a') && pcsz[i] <= RCHART('f'))
            result = (result << 4) + (0x0A + (pcsz[i] - RCHART('a')));
        else
            break;
    }

    return result;
}

template <class CHART> inline ElxInterface * CBuilderT <CHART> :: Keep(ElxInterface * pelx)
...{
    m_objlist.Push(pelx);
    return pelx;
}

template <class CHART> void CBuilderT <CHART> :: MoveNext()
...{
    // forwards
    prev = curr;
    curr = next;
    next = nex2;

    // get nex2
    while( ! GetNext2() ) ...{};
}

template <class CHART> int CBuilderT <CHART> :: GetNext2()
...{
    // check length
    if(m_nNextPos >= m_pattern.GetSize())
    ...{
        nex2 = CHART_INFO(0, 1, m_nNextPos, 0);
        return 1;
    }

    int   delta = 1;
    CHART ch    = m_pattern[m_nNextPos];

    // if quoted
    if(m_bQuoted)
    ...{
        if(ch == RCHART('/'))
        ...{
            if(m_pattern[m_nNextPos + 1] == RCHART('E'))
            ...{
                m_quote_fun = 0;
                m_bQuoted   = 0;
                m_nNextPos += 2;
                return 0;
            }
        }

        if(m_quote_fun != 0)
            nex2 = CHART_INFO((CHART)(*m_quote_fun)((int)ch), 0, m_nNextPos, delta);
        else
            nex2 = CHART_INFO(ch, 0, m_nNextPos, delta);

        m_nNextPos += delta;

        return 1;
    }

    // common
    switch(ch)
    ...{
    case RCHART('/'):
        ...{
            CHART ch1 = m_pattern[m_nNextPos+1];

            // backref
            if(ch1 >= RCHART('0') && ch1 <= RCHART('9'))
            ...{
                nex2 = CHART_INFO(ch, 1, m_nNextPos, delta);
                break;
            }

            // escape
            delta     = 2;

            switch(ch1)
            ...{
            case RCHART('A'):
            case RCHART('Z'):
            case RCHART('w'):
            case RCHART('W'):
            case RCHART('s'):
            case RCHART('S'):
            case RCHART('B'):
            case RCHART('d'):
            case RCHART('D'):
            case RCHART('k'):
            case RCHART('g'):
                nex2 = CHART_INFO(ch1, 1, m_nNextPos, delta);
                break;

            case RCHART('b'):
                if(m_nCharsetDepth > 0)
                    nex2 = CHART_INFO('', 0, m_nNextPos, delta);
                else
                    nex2 = CHART_INFO(ch1, 1, m_nNextPos, delta);
                break;

            /**//*
            case RCHART('<'):
            case RCHART('>'):
                if(m_nCharsetDepth > 0)
                    nex2 = CHART_INFO(ch1, 0, m_nNextPos, delta);
                else
                    nex2 = CHART_INFO(ch1, 1, m_nNextPos, delta);
                break;
            */

            case RCHART('x'):
                if(m_pattern[m_nNextPos+2] != '{')
                ...{
                    int red = 0;
                    unsigned int ch2 = Hex2Int(m_pattern.GetBuffer() + m_nNextPos + 2, 2, red);

                    delta += red;

                    if(red > 0)
                        nex2 = CHART_INFO(RCHART(ch2), 0, m_nNextPos, delta);
                    else
                        nex2 = CHART_INFO(ch1, 0, m_nNextPos, delta);

                break;
                }

            case RCHART('u'):
                if(m_pattern[m_nNextPos+2] != '{')
                ...{
                    int red = 0;
                    unsigned int ch2 = Hex2Int(m_pattern.GetBuffer() + m_nNextPos + 2, 4, red);

                    delta += red;

                    if(red > 0)
                        nex2 = CHART_INFO(RCHART(ch2), 0, m_nNextPos, delta);
                    else
                        nex2 = CHART_INFO(ch1, 0, m_nNextPos, delta);
                }
                else
                ...{
                    int red = 0;
                    unsigned int ch2 = Hex2Int(m_pattern.GetBuffer() + m_nNextPos + 3, sizeof(int) * 2, red);

                    delta += red;

                    while(m_nNextPos + delta < m_pattern.GetSize() && m_pattern.At(m_nNextPos + delta) != RCHART('}'))
                        delta ++;

                    delta ++; // skip '}'

                    nex2 = CHART_INFO(RCHART(ch2), 0, m_nNextPos, delta);
                }
                break;

            case RCHART('a'): nex2 = CHART_INFO(RCHART('a'), 0, m_nNextPos, delta); break;
            case RCHART('f'): nex2 = CHART_INFO(RCHART(' '), 0, m_nNextPos, delta); break;
            case RCHART('n'): nex2 = CHART_INFO(RCHART(' '), 0, m_nNextPos, delta); break;
            case RCHART('r'): nex2 = CHART_INFO(RCHART(' '), 0, m_nNextPos, delta); break;
            case RCHART('t'): nex2 = CHART_INFO(RCHART(' '), 0, m_nNextPos, delta); break;
            case RCHART('v'): nex2 = CHART_INFO(RCHART('v'), 0, m_nNextPos, delta); break;
            case RCHART('e'): nex2 = CHART_INFO(RCHART( 27 ), 0, m_nNextPos, delta); break;

            case RCHART('G'):  // skip 'G'
                if(m_nCharsetDepth > 0)
                ...{
                    m_nNextPos += 2;
                    return 0;
                }
                else
                ...{
                    nex2 = CHART_INFO(ch1, 1, m_nNextPos, delta);
                    break;
                }

            case RCHART('L'):
                if( ! m_quote_fun ) m_quote_fun = ::tolower;

            case RCHART('U'):
                if( ! m_quote_fun ) m_quote_fun = ::toupper;

            case RCHART('Q'):
                ...{
                    m_bQuoted   = 1;
                    m_nNextPos += 2;
                    return 0;
                }

            case RCHART('E'):
                ...{
                    m_quote_fun = 0;
                    m_bQuoted   = 0;
                    m_nNextPos += 2;
                    return 0;
                }

            case 0:
                if(m_nNextPos+1 >= m_pattern.GetSize())
                ...{
                    delta = 1;
                    nex2 = CHART_INFO(ch , 0, m_nNextPos, delta);
                }
                else
                    nex2 = CHART_INFO(ch1, 0, m_nNextPos, delta); // common '