TnbTmlResult.h

[詳解]

#pragma once
#include "TnbStr.h"
#include "TnbStaticMap.h"
#include "TnbGrammarAnalyzer.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
typedef CGrammarAnalyzerT<char> CTmlGrammar;
 
 
 
class CTml
{
public:
 
    enum EScene
    {
        Scene_Non,          
        Scene_Val,          
        Scene_Array,        
        Scene_Func,         
        Scene_If,           
        Scene_Else,         
        Scene_Switch,       
        Scene_Case,         
        Scene_Default,      
        Scene_While,        
        Scene_Break,        
        Scene_Return,       
        Scene_Include,      
        Scene_End,          
    };
 
    enum EOperation
    {
        Operation_Non,              
        Operation_Text,             
        Operation_Text_Esc,         
        Operation_Text_EscHex,      
    //  Operation_Text_EscInsert,   ///< 文字列 ￥i() 処理中
        Operation_Calc,             
        Operation_CheckFunc,        
        Operation_CheckStatement,   
        Operation_FindingFunc,      
        Operation_FileAccess,       
    };
 
    enum EResult
    {
        Result_Success = 1,                 
        Result_Nop = 0,                     
        Result_UnknownError = -10000,       
        Result_InvalidEscSeq,               
        Result_InvalidHexNotation,          
        Result_NotFoundParentheses,         
        Result_NotCloseParentheses,         
        Result_InvalidParenthesesPosition,  
        Result_UnfinishedExpression,        
        Result_ZeroDivide,                  
        Result_UnknownKeyword,              
        Result_InvalidWordPosition,         
        Result_NotName,                     
        Result_AlreadyExistName,            
        Result_UnnecessaryParam,            
        Result_ManyParam,                   
        Result_NotenoughParam,              
        Result_OutOfRange,                  
        Result_InvalidMacroContentsLevel,   
        Result_OpenFailure,                 
        Result_ReadFailure,                 
        Result_SendFailure,                 
        Result_InvalidState,                
        Result_NotFoundFunction,            
        Result_UserInterruption,            
        Result_ProgramableInterruption,     
    };
};
 
 
 
class CTmlResult : public CTml
{
public:
    
    CTmlResult(void) : m_eResult(Result_Success), m_eScene(Scene_Non), m_eOperation(Operation_Non), m_iFileLine(0)
    {
    }
 
    CTmlResult(const CTmlResult& other) 
        : m_eResult(other.m_eResult), m_eScene(other.m_eScene), m_eOperation(other.m_eOperation), m_iFileLine(other.m_iFileLine)
        , m_strFuncName(other.m_strFuncName), m_strToken(other.m_strToken), m_strFileName(other.m_strFileName)
    {
    }
 
    CTmlResult(EOperation eOperation, EResult eResult)
        : m_eResult(eResult), m_eScene(Scene_Non), m_eOperation(eOperation), m_iFileLine(0)
    {
    }
 
    CTmlResult(EScene eScene, EOperation eOperation, EResult eResult)
        : m_eResult(eResult), m_eScene(eScene), m_eOperation(eOperation), m_iFileLine(0)
    {
    }
 
    CTmlResult(EResult i) : m_eResult(i), m_eScene(Scene_Non), m_eOperation(Operation_Non), m_iFileLine(0)
    {
    }
 
    CTmlResult& operator=(const CTmlResult& other) 
    {
        m_eResult = other.m_eResult;
        m_eScene = other.m_eScene;
        m_eOperation = other.m_eOperation;
        m_iFileLine = other.m_iFileLine;
        m_strFuncName = other.m_strFuncName;
        m_strToken = other.m_strToken;
        m_strFileName = other.m_strFileName;
        return *this;
    }
 
    CTmlResult& operator=(EResult i)
    {
        *this = CTmlResult();
        m_eResult = i;
        return *this;
    }
 
    void SetNop(void)
    {
        *this = CTmlResult();
        m_eResult = Result_Nop;
    }
 
    void SetSuccess(void)
    {
        *this = CTmlResult();
        m_eResult = Result_Success;
    }
 
    bool IsSuccess(void) const
    {
        return m_eResult == Result_Success;
    }
 
    bool IsError(void) const
    {
        return m_eResult < 0;
    }
 
    bool IsNop(void) const
    {
        return m_eResult == Result_Nop;
    }
 
    void SetScene(EScene eScene)
    {
        m_eScene = eScene;
    }
    
    void SetOperation(EOperation eOperation)
    {
        m_eOperation = eOperation;
    }
 
    void SetFuncName(LPCSTR lpszFunc)
    {
        m_strFuncName = lpszFunc;
    }
 
    void SetErrorString(LPCSTR lpszString)
    {
        m_strToken = lpszString;
    }
 
    CTmlResult& SetLine(LPCSTR lpszFileName, INT_PTR iFileLine)
    {
        m_iFileLine     = iFileLine;
        m_strFileName   = lpszFileName;
        return *this;
    }
    
    CTmlResult& SetLine(const CTmlGrammar& gram)
    {
        m_iFileLine     = gram.GetLine();
        m_strFileName   = gram.GetName();
        return *this;
    }
 
    EResult GetResult(void) const
    {
        return m_eResult;
    }
 
    EScene GetScene(void) const
    {
        return m_eScene;
    }
 
    EOperation GetOperation(void) const
    {
        return m_eOperation;
    }
 
    LPCSTR GetFuncName(void) const
    {
        return m_strFuncName;
    }
 
    LPCSTR GetErrorString(void) const
    {
        return m_strToken;
    }
 
    INT_PTR GetFileLine(void) const 
    {
        return m_iFileLine;
    }
 
    LPCSTR GetFileName(void) const
    {
        return m_strFileName;
    }
 
    CAscii ToString(void)
    {
        if ( ! IsError() )
        {
            return "";
        }
        //
        CAscii strFile;
        if ( ! m_strFileName.IsEmpty() )
        {
            strFile.Format("%s(%d):", m_strFileName, m_iFileLine);
        }
        //
        CAscii strFunc = GetFuncName();
        if ( ! strFunc.IsEmpty() )
        {
            strFunc = strFunc.Sandwich(" FuncName=[", "]");
        }
        //
        CAscii strScene = SceneToString(m_eScene);
        if ( ! strScene.IsEmpty() )
        {
            strScene = strScene.Sandwich(" Scene=[", "]");
        }
        //
        CAscii strOperation = OperationToString(m_eOperation);
        if ( ! strOperation.IsEmpty() )
        {
            strOperation = strOperation.Sandwich(" Operation=[", "]");
        }
        //
        CAscii strResult = ResultToString(m_eResult);
        if ( ! strResult.IsEmpty() )
        {
            strResult = strResult.Sandwich(" Result=[", "]");
        }
        //
        CAscii strError = GetErrorString();
        if ( ! strError.IsEmpty() )
        {
            strError = strError.Sandwich(" / [", "]");
        }
        //
        return strFile + strFunc + strScene + strOperation + strResult + strError;
    }
 
    static CTmlResult CheckParamNum(INT_PTR iParamNum, INT_PTR iExpectNum)
    {
        CTmlResult r;
        if ( iExpectNum == 0 && iParamNum > 0 )
        {
            //引数は不必要です。
            r = CTmlResult(Operation_CheckFunc, Result_UnnecessaryParam);
        }
        else if ( iParamNum < iExpectNum )
        {
            //引数が足りません。
            r = CTmlResult(Operation_CheckFunc, Result_NotenoughParam);
        }
        else if ( iParamNum > iExpectNum )
        {
            //引数が多すぎます。
            r = CTmlResult(Operation_CheckFunc, Result_ManyParam);
        }
        return r;
    }
 
    static LPCSTR SceneToString(EScene eScene)
    {
        const static CStaticMapT<EScene, LPCSTR> t[] =
        {
            Scene_Non,          "",
            Scene_Val,          "val文処理中",
            Scene_Array,        "array文処理中",
            Scene_Func,         "func文処理中",
            Scene_If,           "if文処理中",
            Scene_Else,         "else文処理中",
            Scene_Switch,       "switch文処理中",
            Scene_Case,         "case文処理中",
            Scene_Default,      "default文処理中",
            Scene_While,        "while文処理中",
            Scene_Break,        "break文処理中",
            Scene_Return,       "return文処理中",
            Scene_Include,      "include文処理中",
            Scene_End,          "end文処理中",
        };
        return CStaticMapT<EScene, LPCSTR>::Find(eScene, t);
    }
 
    static LPCSTR OperationToString(EOperation eOperation)
    {
        const static CStaticMapT<EOperation, LPCSTR> t[] =
        {
            Operation_Non,              "",
            Operation_Text,             "文字列処理中",
            Operation_Text_Esc,         "文字列 \\? 処理中",
            Operation_Text_EscHex,      "文字列 \\x 処理中",
//          Operation_Text_EscInsert,   "文字列 \\i() 処理中",
            Operation_Calc,             "計算処理中",
            Operation_CheckFunc,        "関数チェック中",
            Operation_CheckStatement,   "ステートメントチェック中",
            Operation_FindingFunc,      "関数検索中",
            Operation_FileAccess,       "Fileアクセス中",
        };
        return CStaticMapT<EOperation, LPCSTR>::Find(eOperation, t);
    }
    
    static LPCSTR ResultToString(INT_PTR result)
    {
        const static CStaticMapT<INT_PTR, LPCSTR> t[] =
        {
            Result_Success,                     "",
            Result_UnknownError,                "その他のエラー",
            Result_InvalidEscSeq,               "エスケープシーケンスが異常",
            Result_InvalidHexNotation,          "HEX表記が異常",
            Result_NotFoundParentheses,         "括弧が必要なところにない",
            Result_NotCloseParentheses,         "括弧が閉じていない",
            Result_InvalidParenthesesPosition,  "括弧の位置がおかしい",
            Result_UnfinishedExpression,        "計算式が途中で終わっている",
            Result_ZeroDivide,                  "０で割ろうとしてます",
            Result_UnknownKeyword,              "知らないキーワード",
            Result_InvalidWordPosition,         "単語位置が異常です（そこには存在しないはず）",
            Result_NotName,                     "名前がありません",
            Result_AlreadyExistName,            "既にある名前です",
            Result_UnnecessaryParam,            "引数は不必要です",
            Result_ManyParam,                   "引数が多すぎます",
            Result_NotenoughParam,              "引数が足りません",
            Result_OutOfRange,                  "範囲外です",
            Result_InvalidMacroContentsLevel,   "マクロコンテンツレベルが異常",
            Result_OpenFailure,                 "Open失敗",
            Result_ReadFailure,                 "Read失敗",
            Result_SendFailure,                 "Send失敗",
            Result_InvalidState,                "状態エラー（今、実行できません）",
            Result_NotFoundFunction,            "必要な関数がありません",
            Result_UserInterruption,            "中断",
            Result_ProgramableInterruption,     "終了",
        };
        return CStaticMapT<INT_PTR, LPCSTR>::Find(result, t);
    }
 
private:
    EResult     m_eResult;      
    EScene      m_eScene;       
    EOperation  m_eOperation;   
    CAscii      m_strFuncName;  
    CAscii      m_strToken;     
    CAscii      m_strFileName;  
    INT_PTR     m_iFileLine;    
};
 
 
 
}; // TNB