cplusanalyser.h

一个很好的协议,数据包解码工具,可以分析7号(ISUP,MTP,...), TCP/UDP等各种协议,特别的是还能支持自定义的二进制数据报,可以通过插件无限扩充协议库.

#if !defined(_CPLUSANALYSER_H)
#define _CPLUSANALYSER_H

#include "../Include/RunTimeEnv.h"
#include "../Include/GramParser.h"


////////////////////////////////////////////////////
class Program;
class Procedure;
class Statement_while;

#ifdef _DLL_PROJECT
class CLASS_EXPORT CSyntaxObject: public TObject
#else
class CSyntaxObject: public TObject
#endif
{
public:
    enum {  OBJ_NULL        =-1, 
            OBJ_DEFINE      = 1 , OBJ_ENUM =2, 
            OBJ_STRUCTDEF   = 3,  
            OBJ_VARIABLEDEF = 4,
            OBJ_DECLARESTRUC= 5,

            /////////////////////////////
            // SyntaxObject
            OBJ_PROGRAM     = 6,      // pParent =NULL, MAIN_PROGRAM 相互之间跨文件
                                      // pParent!=NULL, SUB_PROGRAM, MAIN_PROGRAM can include many SUB PROGRAM 
            OBJ_PROCEDURE   = 9,
            OBJ_EXPRESSION  = 10,
            OBJ_WHILE       = 11, 
            OBJ_IF          = 12,  
            OBJ_JUMP        = 13,

            OBJ_TYPEDEF     = 20,
    };
    
public:
    CSyntaxObject(CSyntaxObject* pUpLink,CSyntaxObject* pParent);
    virtual ~CSyntaxObject();

    static bool Initial();          // 程序开始时调用一次
    static void Destroy();          // 程序结束时调用一次
    
    void SetParent(CSyntaxObject* pParent);
    CSyntaxObject* GetParent()  { return m_pParent; }

    Program*   GetAdjacentProgram(bool bIncludeThis); // 往上最近的Program, 可包含自身
    Program*   GetMainProgram();                      // 单个文件入口
    Program*   GetRootProgram();                      // 总入口
    Procedure* GetParentProcedure();
    Statement_while* GetAdjacentWhile();

    void setLocatBegin(Location& locat);
    void setLocatEnd(Location& locat);

    Location& getLocation() { return m_location; }
    long      getLen()      { return m_len; }
    
    ///////////////////////////////////////////////////
    virtual bool ValidityCheck(OTSTR& strError) { return true; }    // Variable,struct的名字在生成时候已经做检查, 这里主要对语句中exp,program做检查
    
    virtual bool Execute(ExecuteEnv& Env,long nCurLine=-1) = 0;

protected:
    CSyntaxObject* m_pParent;            
    CSyntaxObject* m_pUpLink;            
    static WORD    m_IdentifyCounter;
    
    static GramRules m_GramRule[10];

    /////////////////////////////////////////////////
    virtual TObject* GetDefinitionOwner() { return NULL; } 

    TObject* GetAdjacentDefinitionOwner(bool bIncludeThis); // 往上最近的VariableDefinition, StructDefinition
    
private:
    Location       m_location;
    long           m_len;
};

///////////////////////////////////////////////
class NewTypeDef: public TObject   
{
    ///////////////////////////////////////////////
    // syntax:  typedef  definedType  newType;          
    ///////////////////////////////////////////////
    
public:
    OTSTR    m_strNewTypeName;
    TObject* m_pOldTypeDefinition;
        
public:
    NewTypeDef()
    {
        m_pOldTypeDefinition=NULL;
    }
    virtual ~NewTypeDef() 
    {
    }

    int ObjectTypeId()  { return CSyntaxObject::OBJ_TYPEDEF; }
};

#ifdef _DLL_PROJECT
class CLASS_EXPORT TypeSpecifier: public TObject
#else
class TypeSpecifier: public TObject
#endif
{
public:
    VariableItemAttr::type_ m_nType;

    VariableItemAttr::type_ m_nExType;
    OTSTR                   m_strTypeName;

    StructDefinition*       m_pStructDefinitionObject; // For STRUCT type

public:
    TypeSpecifier()  { m_pStructDefinitionObject=NULL; }
    TypeSpecifier(TypeSpecifier& pType) { *this=pType; }
   ~TypeSpecifier()  {}

    void operator=(const TypeSpecifier& right)
    {
        this->m_nType  =right.m_nType;
        this->m_nExType=right.m_nExType;
        this->m_strTypeName=right.m_strTypeName;
        this->m_pStructDefinitionObject=right.m_pStructDefinitionObject;
    }
};

///////////////////////////////////////////////////////////////////
/*
 TObject 
   |  |
   |  |-> LexToken
   |      ExprNode
   |      TypeSpecifier
   |      CEnumItem
   |      CEnumItemList
   |      VariableDefinition   
   |      StructDefinition 
   |      DeclareMapItemGrp
   |
   |----> CSyntaxObject
            Program
            Procedure
            Statement_jmp
            Statement_expr
            Statement_while
*/

///////////////////////////////////////////////////////////////////
class CProcedure;
class DeclareMapItemGrp;
class AttributeDefinition;

class Program: public CSyntaxObject
{
protected:
    ///////////////////////////////////////////////
    EnumItemList                 m_DefineList;       // data_content is Number|string
    
    TObArray<TObject>            m_ItemList;         // Elements Sequence (sub program and statement) -> for execute
                                                     //                    other define enum 
                                                     //                    mainprogram(included)
                                                     // Ptr + locatline
    TObArray<TObject>            m_ItemObjectList;   // 对象实体   // Include, Procedure, struct

    TObArray<StructDefinition>   m_PreDefinedStructList;
    TObArray<Procedure>          m_PreDefinedProcedureList;

public:
    Program(CSyntaxObject* pUpLink,CSyntaxObject* pParent,bool bAttachedProgram=false);
    virtual ~Program();

    virtual Program* NewProgram(CSyntaxObject* pUpLink,CSyntaxObject* pParent,bool bAttachedProgram=false);
    virtual VariableDefinition*  NewVariableDefinition(StructDefinition* pParent,WORD nIdentifierId);
    virtual AttributeDefinition* NewAttributeDefiniton(TObject* pOwner,CSyntaxObject* pUpLink,CSyntaxObject* pParent);
    virtual StructDefinition*    NewStructDefiniton(WORD nIdentifierId);
    virtual void DeleteStructDefiniton(StructDefinition* pStructDefinition);

    /////////////////////////////////////////////////////
    int  ObjectTypeId()  { return OBJ_PROGRAM; }
    bool isMainProgram() { return (m_pParent==NULL)? true:false; }
    
    bool Analysis(CPlusLex& Lex, bool bValidityCheck, OTSTR& strErr);
    
    bool Execute(ExecuteEnv& Env,long nCurLine=-1);
    
    bool Dump(char* filename, bool bHasHeader=true, bool bCompactMode=false);

    ////////////////////////////////////////////////
    CEnumItem*          Get_ConstItem(char* szName, bool bOnlyInCurrentProgram=false, long nLineLimit=-1);
                                      //    szName: EnumName::ItemName  ( search in EnumItemList )
                                      //            ItemName            ( search in DefineList   )
    VariableDefinition* Get_VariableDefinition(char* varname, bool bOnlyInCurrentProgram=false, long nLineLimit=-1);   // 取得距离最近的Var
    StructDefinition*   Get_StructDefinition(char* name, bool bOnlyInCurrentProgram=false, long nLineLimit=-1);        
    DeclareMapItemGrp*  Get_DeclareMapItemGrp(char* name, bool bOnlyInCurrentProgram=false, long nLineLimit=-1);     
    Procedure*          Get_Procedure(char* name, bool bOnlyInCurrentProgram=false, long nLineLimit=-1);     
    CEnumItem*          Get_DefineItem  (char* szItemName, bool bOnlyInCurrentProgram=false, long nLineLimit=-1);
    EnumItemList*       Get_EnumItemList(char* szEnumName, bool bOnlyInCurrentProgram=false, long nLineLimit=-1);

    long                Get_DefinitionNum(long ObjectTypeId);        

    TObject*            Get_DefinitionObject(WORD nIdentifierId, bool bOnlyInCurrentProgram=false); 

    void                Add_SyntaxObject(TObject* pObject, long nLine, bool bTrueObject);
    void                Rmv_SyntaxObject(TObject* pObject, bool bDeleteObject);
    
    //////////////////////////////////////////////////////////
    static DWORD GetConstValueProc(void* pParent, unsigned int params_num, DWORD params[]); //Syntax: A  or  A::B

    static DWORD Func_Program       (void* pParent, unsigned int params_num, DWORD params[]);
    static DWORD Func_Statement     (void* pParent, unsigned int params_num, DWORD params[]);
    static DWORD Func_Type_specifier(void* pParent, unsigned int params_num, DWORD params[]);
    static DWORD Func_Expression    (void* pParent, unsigned int params_num, DWORD params[]);
    static DWORD Func_InitializerExp(void* pParent, unsigned int params_num, DWORD params[]);
    static DWORD Func_StatementExp  (void* pParent, unsigned int params_num, DWORD params[]);
        
protected:
    OTSTR  m_strRemarkBegin;
    OTSTR  m_strRemarkEnd;
    
    bool   m_bAttachedProgram;
    
    OTSTR m_strAbsoluteFilename;
    OTSTR m_strDisplayFilename;
    OTSTR m_strFileName;            // 纯文件名
    void  setDisplayFileName(char* filename) { m_strDisplayFilename=filename;  }
    void  setIncludeFileName(char* AbsoluteFilename,char* filename) { m_strAbsoluteFilename=AbsoluteFilename; m_strFileName=filename;  }
    
    virtual bool Analysis(CPlusLex& Lex, CErrHandler& ErrHandler);
    
    bool  proc_Include(CPlusLex& Lex, CErrHandler& ErrHandler);
    bool  Proc_TypeDef(CPlusLex& Lex, CErrHandler& ErrHandler);
    bool  Proc_Enum   (CPlusLex& Lex, CErrHandler& ErrHandler);
    bool  Proc_Define (CPlusLex& Lex, CErrHandler& ErrHandler);
    bool  proc_Struct (CPlusLex& Lex, CErrHandler& ErrHandler);
    bool  proc_VarDefinition (CPlusLex& Lex, CErrHandler& ErrHandler,bool bisExtern); // try
    bool  proc_ProcDefinition(CPlusLex& Lex, CErrHandler& ErrHandler,bool bisExtern); // try
    bool  proc_Statement (CPlusLex& Lex, CErrHandler& ErrHandler);                    // try
    bool  proc_DeclareMap(CPlusLex& Lex, CErrHandler& ErrHandler);    
    
    virtual bool proc_CustomAttrib(CPlusLex& Lex, CErrHandler& ErrHandler);  

    DWORD DoFunction(cCallback::tFunction pFunction,CPlusLex& Lex, CErrHandler& ErrHandler);
        
    ////////////////////////////////////////////////
    Program*     Get_IncludedProgram(char* szfilename);
    bool         isNetWorkTranMode_L_TO_H();

    ////////////////////////////////////////////////
    // Used for Definition
    bool is_Identifier_Used(char* name, bool bOnlyInCurrentProgram, bool bAlsoCheckProcName=true);  
    StructDefinition* Get_PreDefined_Struct(char* name,bool bRemoveOut);  
    Procedure* Get_PreDefined_Procedure(char* name,bool bRemoveOut);  
    
    /////////////////////////////////////
    bool ValidityCheck(OTSTR& strError);
    bool ValidityCheck_StructLoop(StructDefinition* pStructDefinition);

    bool Check_Expression(Location Locat, char* szExpression, WORD nTokenExStyle,  CErrHandler& ErrHandler);  // nLineLocat=nLineLimit
    bool Check_Expression(ExprNode* pExprNode, CErrHandler& ErrHandler);
    virtual bool Check_varIdent(StructDefinition* pCurStructDefinition, Location Locat, char* varString, CErrHandler& ErrHandler);   // A.B[..].C[.f().].D
    
    bool isTrueObject(TObject* pObject,long nLine);

    /////////////////////////////////////////
    void Clear();
    
    void Dump(FILE* fp, OTSTR strHeader, bool bCompactMode);
    void DumpStatement(FILE* fp, CSyntaxObject* pObject, long nLine, long MaxLineIdLen,
                       char* sItemHeaderFormat, char* sItemFormat, OTSTR& strHeader,OTSTR& strNextHeader, bool bCompactMode);
    void DumpStatement(FILE* fp, CSyntaxObject* pObject, long nLine, long MaxLineIdLen, OTSTR strHeader,  bool bCompactMode);

    virtual void DumpCustomAttrib(FILE* fp, char* sItemHeaderFormat, char* sItemFormat, OTSTR& strHeader,OTSTR& strNextHeader, bool bCompactMode) {}
    
    long GetMaxLineIdLen();

    bool m_bLoopMark;
    
private:
    friend class ExecuteEnv;
    friend class RunTimeStk;
    friend class GramParser;
    friend class Procedure;
    friend class Statement_expr;
    friend class Statement_jump;
    friend class Statement_if;
    friend class Statement_while;
};

/////////////////////////////////////////////////////////////////
class Statement_expr: public CSyntaxObject
{
protected:
    ///////////////////////////////////////////////
    // syntax:  exp;
    //          ;
    ///////////////////////////////////////////////

    ExprNode*  m_pExprNode;