TnbGrammarAnalyzer.h

[詳解]

#pragma once
#include "TnbStr.h"
 
 
 
//T-TestCaseコードカバレッジDisable
#pragma comment(user,"T-Coverage Disable")
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP = TCHAR, typename ITE = const TYP*>
class CGrammarAnalyzerT
{
public:
 
    struct IFormat
    {
        virtual ~IFormat(void){}
 
        virtual bool IsBlankChar(TYP c) const
        {
            return (c == ' ' || c == '\t');
        }
 
        virtual bool IsTokenPeriodChar(TYP c) const
        {
            switch ( c )
            {
            case 0:             case '=':           case ' ':           case '\t':  
            case ',':           case 0x0D:          case 0x0A:          case '/':   
            case '*':           case '(':           case ')':           case ']':   
            case '[':           case ':':           case '{':           case '}':   
            case '!':           case '+':           case '-':           case '<':   
            case '>':           case ';':           case '\"':          case '.':
            case 0x1A:
                return true;
            }
            return false;
        }
        
        virtual bool IsEndChar(TYP c) const
        {
            return c == 0;
        }
 
        virtual TYP CheckBlockStartChar(TYP c) const
        {
            TYP r = 0;
            switch ( c )
            {
            case '(':   r = ')';    break;
            case '[':   r = ']';    break;
            case '{':   r = '}';    break;
            }
            return r;
        }
 
        virtual bool IsBlockCloseChar(TYP c) const
        {
            switch ( c )
            {
            case ')':   break;
            case ']':   break;
            case '}':   break;
            default:
                return false;
            }
            return true;
        }
 
        virtual bool IsStringMarkChar(TYP c) const
        {
            return (c == '\"' || c == '\"');
        }
 
        virtual int CheckStringSpecialWord(CStrT<TYP>& _str, ITE ite) const
        {
            if ( *ite != '\\' )
            {
                return 0;
            }
            _str.Empty();
            ite++;
            switch ( *ite )
            {
            case '\\':
            case '\042':
                _str = "\\";
                _str += *ite;
                break;
            case 'n':
                _str = "\n";
                break;
            case 'r':
                _str = "\r";
                break;
            default:
                return 0;
            }
            return 2;
        }
 
        virtual int CheckComment(CStrT<TYP>& _str, ITE ite) const
        {
            if ( *ite != '/' )
            {
                return 0;
            }
            ite++;
            if ( *ite == '/' )
            {
                return -1;
            }
            if ( *ite == '*' )
            {
                _str = "*/";
                return 2;
            }
            return 0;
        }
    };
 
    enum EPartsKind
    {
        TOKEN,              
        CHARACTOR,          
        STRING,             
        PERIOD_CHAR,        
        OPEN_CHAR,          
        CLOSE_CHAR,         
        FINAL,              
        ERROR_STRING,       
        ERROR_DEPTH,        
    };
 
    class CParts
    {
    public:
 
        CParts(void) : m_kind(FINAL), m_str(), m_line(0), m_raw(0)
        {
        }
 
        CParts(EPartsKind kind, const CStrT<TYP>& s, INT_PTR l, INT_PTR r) 
            : m_kind(kind), m_str(s), m_line(l), m_raw(r)
        {
        }
 
        CParts(EPartsKind kind, TYP c, INT_PTR l, INT_PTR r)
            : m_kind(kind), m_str(), m_line(l), m_raw(r)
        {
            TYP at[2] = {c, 0};
            m_str = at;
        }
 
        CParts(const CParts& other) 
            : m_kind(other.m_kind), m_str(other.m_str), m_line(other.m_line), m_raw(other.m_raw)
        {
        }
 
        CParts& operator=(const CParts& other)
        {
            m_kind = other.m_kind;
            m_str = other.m_str;
            m_line = other.m_line;
            m_raw = other.m_raw;
            return *this;
        }
 
        EPartsKind GetKind(void) const
        {
            return m_kind;
        }
 
        bool IsEqualString(LPCSTR lpsz) const
        {
            return m_str.IsEqual(lpsz);
        }
 
        const TYP* GetString(void) const
        {
            return m_str;
        }
 
        TYP GetAt(INDEX index = 0) const
        {
            return (m_str.GetLength() > index) ? m_str[index] : static_cast<TYP>(0);
        }
 
        INT_PTR GetLine(void) const
        {
            return m_line;
        }
 
        INT_PTR GetRaw(void) const
        {
            return m_raw;
        }
 
        CStr ToString(void) const
        {
            CStr str;
            switch ( m_kind )
            {
            case TOKEN:         str = _T("トークン");           break;
            case CHARACTOR:     str = _T("文字");             break;
            case STRING:        str = _T("文字列");                break;
            case PERIOD_CHAR:   str = _T("トークン区切り文字");  break;
            case OPEN_CHAR:     str = _T("ブロック開始文字");   break;
            case CLOSE_CHAR:    str = _T("ブロック終端文字");   break;
            case FINAL:         str = _T("終わり");                break;
            default:            str = _T("エラー");                break;
            }
            return CStr::Fmt(_T("%s : [%s] (%d,%d)"), str, CStr(m_str), m_line, m_raw);
        }
 
    private:
        EPartsKind  m_kind;     
        CStrT<TYP>  m_str;      
        INT_PTR     m_line;     
        INT_PTR     m_raw;      
    };
 
    CGrammarAnalyzerT(ITE is = ITE(), ITE ie = ITE(), INT_PTR line = 1) 
        : m_param(is, ie, line), m_pFormat(&m_defaultFormat)
    {
    }
 
    CGrammarAnalyzerT(const CGrammarAnalyzerT& other) 
        : m_param(other.m_param), m_pFormat(other.m_pFormat), m_strName(other.m_strName)
    {
        if ( other.m_pFormat == &other.m_defaultFormat )
        {
            m_pFormat = &m_defaultFormat;
        }
    }
 
    CGrammarAnalyzerT& operator=(const CGrammarAnalyzerT& other)
    {
        m_param = other.m_param;
        m_pFormat = other.m_pFormat;
        m_strName = other.m_strName;
        if ( other.m_pFormat == &other.m_defaultFormat )
        {
            m_pFormat = &m_defaultFormat;
        }
        return *this;
    }
 
    void SetFormat(const IFormat* P)
    {
        m_pFormat = (P == NULL) ? &m_defaultFormat : P;
    }
 
    void SetName(LPCTSTR name)
    {
        m_strName = name;
    }
 
    CStr GetName(void) const
    {
        return m_strName;
    }
 
    UINT_PTR GetLine(void) const
    {
        return m_param.line;
    }
 
    UINT_PTR GetRaw(void) const
    {
        return m_param.raw;
    }
 
    UINT_PTR GetPos(void) const
    {
        return m_param.pos;
    }
 
    ITE GetPointer(void)
    {
        m_SkipBlankChar();
        return ite();
    }
 
    INT_PTR GetDepth(void) const
    {
        return m_param.strDepth.GetLength();
    }
 
    TYP GetBlockChar(void) const
    {
        int l = m_param.strDepth.GetLength();
        return (l > 0) ? m_param.strDepth.GetAt(l - 1) : 0;
    }
 
    CParts GetNextParts(bool boIsToken = true)
    {
        CParts p;
        m_SkipBlankChar();
        if ( ! m_IsEnd() )
        {
            TYP c = *ite();
            UINT_PTR line = GetLine();
            UINT_PTR raw = GetRaw();
            if ( m_pFormat->CheckBlockStartChar(c) != 0 )
            {
                // ブロック開始文字
                p = CParts(OPEN_CHAR, c, line, raw);
                inc();
                m_param.strDepth += c;
            }
            else if ( m_pFormat->IsBlockCloseChar(c) )
            {
                //ブロック終端文字
                if ( m_param.strDepth.IsEmpty() )
                {
                    p = CParts(ERROR_DEPTH, c, line, raw);
                }
                else
                {
                    p = CParts(CLOSE_CHAR, c, line, raw);
                    inc();
                    m_param.strDepth.DeleteLast();
                }
            }
            else if ( m_pFormat->IsStringMarkChar(c) )
            {
                // 文字列
                CStrT<TYP> str;
                if ( m_GetString(str) < 0 )
                {
                    //error
                    p = CParts(ERROR_STRING, str, line, raw);
                }
                else 
                {
                    p = CParts(STRING, str, line, raw);
                }
            }
            else if ( m_pFormat->IsTokenPeriodChar(c) )
            {
                // トークン区切り文字
                p = CParts(PERIOD_CHAR, c, line, raw);
                inc();
            }
            else if ( boIsToken )
            {
                // トークン
                CStrT<TYP> str;
                m_GetToken(str);
                p = CParts(TOKEN, str, line, raw);
            }
            else
            {
                CStrT<TYP> str;
                str += c;
                if ( STRLIB::GetCharSize(c) == 2 )
                {
                    inc();
                    str += *ite();
                }
                inc();
                p = CParts(CHARACTOR, str, line, raw);
            }
        }
        return p;
    }
 
    bool SkipoutBlock(void)
    {
        if ( m_param.strDepth.IsEmpty() )
        {
            return false;
        }
        INT_PTR l = m_param.strDepth.GetLength();
        TYP lc = m_pFormat->CheckBlockStartChar(m_param.strDepth.GetAt(l - 1));
        if ( m_SkipToNextChar(lc) < 0 )
        {
            return false;
        }
        inc();  //終端の次へ
        m_param.strDepth.DeleteLast();
        return true;
    }
 
    CParts PeekNextParts(bool boIsToken = true)
    {
        TParam pm = m_param;
        CParts r = GetNextParts(boIsToken);
        m_param = pm;
        return r;
    }
 
    INT_PTR StepPointer(INT_PTR step)
    {
        INT_PTR top = m_param.pos;      // 現在のポジション
        while ( (m_param.pos - top) < step )
        {
            GetNextParts();
        }
        return m_param.pos - top;
    }
 
private:
 
    struct TParam
    {
        ITE         iteNow;     
        ITE         iteEnd;     
        INT_PTR     pos;        
        INT_PTR     line;       
        INT_PTR     raw;        
        CStrT<TYP>  strDepth;   
        // コンストラクタ
        TParam(ITE is = ITE(), ITE ie = ITE(), INT_PTR l = 1) : iteNow(is), iteEnd(ie), pos(0), line(l), raw(0), strDepth()
        {
        }
        // コピーコンストラクタ
        TParam(const TParam& other)
            : iteNow(other.iteNow), iteEnd(other.iteEnd), pos(other.pos)
            , line(other.line), raw(other.raw), strDepth(other.strDepth)
        {
        }
        // コピーオペレータ
        TParam& operator=(const TParam& other)
        {
            iteNow = other.iteNow;
            iteEnd = other.iteEnd;
            pos = other.pos;
            line = other.line;
            raw = other.raw;
            strDepth = other.strDepth;
            return *this;
        }
    };
 
    TParam          m_param;                
    IFormat         m_defaultFormat;        
    const IFormat*  m_pFormat;              
    CStr            m_strName;              
 
    ITE ite(void){ return m_param.iteNow; }
    void inc(void) { m_param.iteNow++; m_param.pos++; m_param.raw++;} 
    void inc(INT_PTR i) { m_param.iteNow += i; m_param.pos += i; m_param.raw += i; } 
 
    class CStepCnt
    {
        UINT_PTR m_bak;
    public:
        CStepCnt(const TParam& t) : m_bak(t.pos) {}
        UINT_PTR rst(const TParam& t){ return t.pos - m_bak; }
    };
 
    bool m_IsEnd(void)
    {
        if ( ite() != m_param.iteEnd && ! m_pFormat->IsEndChar(*ite()) )
        {
            return false;
        }
        return true;
    }
 
    INT_PTR m_SkipCr(void)
    {
        CStepCnt cnt(m_param);
        ASSERTLIB( ! m_IsEnd() );
        TYP c = *ite();
        if ( c == 0x0D )
        {
            m_param.line++;
            inc();
            if ( *ite() == 0x0A )
            {
                inc();
            }
            m_param.raw = 0;
        }
        else if ( c == 0x0A )
        {
            m_param.line++;
            inc();
            m_param.raw = 0;
        }
        return cnt.rst(m_param);
    }
 
    bool m_IsEqual(const CStrT<TYP>& str)
    {
        ITE p = ite();
        loop ( i, str.GetLength() )
        {
            if ( str[i] != *p )
            {
                return false;
            }
            p++;
        }
        return true;
    }
 
    void m_SkipBlankCharSub(INT_PTR r, const CStrT<TYP>& str)
    {
        ASSERTLIB( r != 0 );
        if ( r > 0 )
        {
            inc(r);
        }
        while ( true )
        {
            if ( r > 0 && m_IsEqual(str) )
            {
                // str と同じ
                inc(str.GetLength());
                break;
            }
            if ( m_SkipCr() > 0 )
            {
                if ( r < 0 )
                {
                    break;
                }
            }
            else if ( m_IsEnd() )
            {
                break;
            }
            else
            {
                TYP c = *ite();
                inc(STRLIB::GetCharSize(c));
            }
        }
    }
 
    INT_PTR m_SkipBlankChar(void)
    {
        CStepCnt cnt(m_param);
        CStrT<TYP> str;
        while ( true )
        {
            if ( m_IsEnd() )
            {
                break;
            }
            INT_PTR r = m_pFormat->CheckComment(str, ite());
            if ( r != 0 )
            {
                m_SkipBlankCharSub(r, str);
            }
            else if ( m_SkipCr() > 0 )
            {
                ;
            }
            else if ( m_pFormat->IsBlankChar(*ite()) )
            {
                inc();
            }
            else
            {
                break;
            }
        }
        return cnt.rst(m_param);
    }
 
    INT_PTR m_GetToken(CStrT<TYP>& _token)
    {
        CStepCnt cnt(m_param);
        ASSERTLIB( ! m_IsEnd() );
        _token.Empty();
        while ( true )
        {
            TYP c = *ite();
            if ( STRLIB::GetCharSize(c) == 2 )
            {
                _token += c;
                inc();
                _token += *ite();
            }
            else
            {
                if ( m_pFormat->IsTokenPeriodChar(c) )
                {
                    if ( cnt.rst(m_param) == 0 )
                    {
                        _token += c;
                        inc();
                    }
                    break;
                }
                _token += c;
            }
            inc();
        }
//      TRACE1("GrammarAnalyzer FoundToken = [%s]\n", CStr(_token));
        ASSERT( cnt.rst(m_param) != 0 );
        return cnt.rst(m_param);
    }
 
    INT_PTR m_SkipToken(void)
    {
        CStrT<TYP> s;
        return m_GetToken(s);
    }
 
    INT_PTR m_SkipBlock(void)
    {
        CStepCnt cnt(m_param);
        if ( m_pFormat->IsStringMarkChar(*ite()) )
        {
            m_SkipString();
        }
        else
        {
            TYP c = m_pFormat->CheckBlockStartChar(*ite());
            if ( c != 0 )
            {
                inc();
                m_SkipToNextChar(c);
                if ( *ite() == c )
                {
                    inc();
                }
            }
        }
        return cnt.rst(m_param);
    }
 
    INT_PTR m_SkipToNextChar(TYP cCloseChar)
    {
        CStepCnt cnt(m_param);
        TParam pp = m_param;
        while ( true )
        {
            m_SkipBlankChar();
            if ( m_IsEnd() )
            {
                TRACE0("`('が綴じてません\n");
                m_param = pp;
                return -1;
            }
            TYP c = *ite();
            if ( STRLIB::GetCharSize(c) == 2 )
            {
                inc(2);
            }
            else if ( c == cCloseChar )
            {
                break;
            } 
            else if ( m_SkipBlock() > 0 )
            {
                ;
            }
            else
            {
                m_SkipToken();
            }
        }
        return cnt.rst(m_param);
    }
 
    INT_PTR m_GetString(CStrT<TYP>& _str)
    {
        CStepCnt cnt(m_param);
        ASSERTLIB( ! m_IsEnd() );
        bool r = true;
        _str.Empty();
        TYP c = *ite();
        if ( ! m_pFormat->IsStringMarkChar(c) )
        {
            return 0;
        }
        inc();
        TYP endChar = c;
        while ( true )
        {
            if ( m_IsEnd() )
            {
                break;
            }
            c = *ite();
            inc();
            if ( c == endChar )
            {
                break;
            }
            _str += c;
            if ( STRLIB::GetCharSize(c) == 2 )
            {
                _str += *ite();
                inc();
            }
            CStrT<TYP> s;
            INT_PTR l = m_pFormat->CheckStringSpecialWord(s, ite());
            if ( l < 0 )
            {
                r = false;
                inc();
            }
            else if ( l > 0 )
            {
                _str += s;
                inc(l);
            }
        }
        return r ? cnt.rst(m_param) : -1;
    }
 
    INT_PTR m_SkipString(void)
    {
        CStrT<TYP> s;
        return m_GetString(s);
    }
 
    friend class CGrammarAnalyzerTest;
};
 
 
 
typedef CGrammarAnalyzerT<> CGrammarAnalyzer;
 
 
 
}; // TNB
 
 
 
//T-TestCaseコードカバレッジEnable
#pragma comment(user,"T-Coverage Enable")