cplusanalyser.h

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

    
public:
    Statement_expr(CSyntaxObject* pUpLink,CSyntaxObject* pParent);
   ~Statement_expr();
        
    int  ObjectTypeId()  { return OBJ_EXPRESSION; }

    void Combine(ExprNode* pExpr);

    /////////////////////////////////
    bool Execute(ExecuteEnv& Env,long nCurLine=-1);

private:
    bool ValidityCheck(OTSTR& strError);
    
    friend class Program;
};

/////////////////////////////////////////////////////////////////
class Statement_jump: public CSyntaxObject
{
protected:
    ///////////////////////////////////////////////
    // syntax:  return [Expr];
    //          break;
    //          continue;
    ///////////////////////////////////////////////
    
    OTSTR      m_strJumpName;
    ExprNode*  m_pExprNode;
    
public:
    Statement_jump(CSyntaxObject* pUpLink,CSyntaxObject* pParent);
   ~Statement_jump();
    
    int  ObjectTypeId()  { return OBJ_JUMP; }
    
    void Combine(char* szJumpName,ExprNode* pExpr=NULL);
    
    /////////////////////////////////
    bool Execute(ExecuteEnv& Env,long nCurLine=-1);
    
private:
    bool ValidityCheck(OTSTR& strError);
    
    friend class Program;
};

/////////////////////////////////////////////////////////////////
class Statement_if: public CSyntaxObject
{
protected:
    ///////////////////////////////////////////////
    // syntax:  if (Exp) statement
    //          if (Exp) statement else statement
    ///////////////////////////////////////////////
    
    ExprNode*       m_pExprNode;
    CSyntaxObject*  m_pStatement1;     
    CSyntaxObject*  m_pStatement2;     
    
public:
    Statement_if(CSyntaxObject* pUpLink,CSyntaxObject* pParent);
   ~Statement_if();
    
    int  ObjectTypeId()  { return OBJ_IF; }
    
    void Combine(ExprNode* pExpr,CSyntaxObject* pStatement1,CSyntaxObject* pStatement2);
    
    /////////////////////////////////
    bool Execute(ExecuteEnv& Env,long nCurLine=-1);
    
private:
    bool ValidityCheck(OTSTR& strError);
    
    friend class Program;
};

/////////////////////////////////////////////////////////////////
class Statement_while: public CSyntaxObject
{
protected:
    ///////////////////////////////////////////////
    // syntax:  while (Exp) Program
    ///////////////////////////////////////////////
    
    ExprNode*       m_pExprNode;
    CSyntaxObject*  m_pStatement;     
    
public:
    Statement_while(CSyntaxObject* pUpLink,CSyntaxObject* pParent);
   ~Statement_while();
    
    int  ObjectTypeId()  { return OBJ_WHILE; }
    
    void Combine(ExprNode* pExpr,CSyntaxObject* pStatement);
    
    /////////////////////////////////
    bool Execute(ExecuteEnv& Env,long nCurLine=-1);
    
private:
    bool ValidityCheck(OTSTR& strError);
    
    friend class Program;
};

/////////////////////////////////////////////////////////////////
#define PROCEDURE_RETNAME        "Return"

#ifdef _DLL_PROJECT
class CLASS_EXPORT Procedure: public CSyntaxObject
#else
class Procedure: public CSyntaxObject
#endif
{
protected:
    ///////////////////////////////////////////////
    // syntax:  simple_type ProcName(...,...)
    //          {
    //             ......
    //          }
    ///////////////////////////////////////////////
    
public:
    Procedure(CSyntaxObject* pUpLink,CSyntaxObject* pParent);
   ~Procedure();

    int    ObjectTypeId()  { return OBJ_PROCEDURE; }

    OTSTR& GetProcName() { return m_strProcName; }
    
    long   GetVarParamsCount() { return m_VariableParamsDefList.GetVariableCount(); }
    int    GetProcReturnType() { return m_ReturnType.m_nType; }

    bool   setReturn(ExecuteEnv& Env,char* szData);       // 置返回值
    bool   setReturn(ExecuteEnv& Env,CVarient& retData);  // 置返回值
    
protected:
    Location            m_Location;
    bool                m_bExtern;
    OTSTR               m_strProcName;
    TypeSpecifier       m_ReturnType;               // 返回变量 size always=1
    StructDefinition    m_VariableParamsDefList;    // 参量定义
    bool                m_bHasDynamicArgList;

    Program*            m_pProgram;                 // Procedure body
    
    void   Combine(bool bExtern,char* szProcName,TypeSpecifier& ReturnType,StructDefinition* pVariableParamsList, bool bHasDynamicArgList);
    void   SetProcBody(Program* pProgram);
    void   SetLocation(Location& locat) { m_Location=locat; }   // setBody location

    bool   ValidityCheck(OTSTR& strError);
    
    bool   Execute(ExecuteEnv& Env,long nCurLine=-1);

    OTSTR  DumpHeader();
    static OTSTR DumpHeader(bool bExtern, char* szProcName,TypeSpecifier& ReturnType,StructDefinition* pVariableParamsList,bool bHasDynamicArgList);

private:
    friend class Program;
    friend class ExecuteEnv;
    
    bool GenerateProcParamsList(RunTimeStk* pRunTimeStk,char* szParams,TObArray<CVariableItem>& ReturnParamsList,TObArray<CVarient>& ProcedureArgList);

};


////////////////////////////////////////////////////////////////
class DeclareMapItemGrp: public TName, public TObject
{
public:
    enum { MAP_ITEM=0, MAP_IMPLICITITEM=1 };

protected:
    ///////////////////////////////////////////////
    // syntax:  varname [nTag] type
    //          varname [nTag] structname
    //          varname [nTag] TypeOf structname 
    ///////////////////////////////////////////////

    int  m_MapType;
    TObArray<VariableDefinition> m_ItemMap;

public:
    DeclareMapItemGrp(CSyntaxObject* pParent);
   ~DeclareMapItemGrp();
    
    int  ObjectTypeId() { return CSyntaxObject::OBJ_DECLARESTRUC; }

    void setMapType(int type) { m_MapType=type; }
    int  getMapType() { return m_MapType; }
    
    int  GetCount();
    void RemoveAll(bool bDeleteObject=true);

    void Add(VariableDefinition* pItem, long  nTag, StructDefinition*  pTypeOfStructDefinition=NULL);

    bool GetAt(int nIndex, long* pTag, VariableDefinition** pItem, StructDefinition** pTypeOfStructDefinition=NULL);
    bool Find(long nTag, VariableDefinition** pItem=NULL, StructDefinition** pTypeOfStructDefinition=NULL); 
    VariableDefinition* GetVariableDefinition(WORD nIdentifierId); 
    
protected:
    CSyntaxObject* m_pParent;
};

//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
#define TYPEOF           "TypeOF"        // FOR struct's varItem
#define DUMPOF           "DumpOF"        // FOR struct's varItem  only for number
#define PROC_TRANSLATE   "Translate"     // FOR struct's varItem  ( 如果有typeOf, translate不允许)
#define CHOICEMAP        "ChoiceMap"     // FOR struct's varItem(choice)
#define PROC_DUMP        "Dump"          // FOR struct or vaItem,  pri > var's dump
#define PROC_INTEGRATE   "Integrate"     // FOR struct
#define INTEGRATEOF      "="             // FOR struct

#define AttributeNum     8

class AttributeDefinition: public Program
{
public:
    enum { TYPEOF_ID=0, DUMPOR_ID=1, DUMPEQL_ID=2, PROC_TRANSLATE_ID=3, PROC_INTEGRATE_ID=4, PROC_DUMP_ID=5, 
           INTEGRATEOF_ID=6, CHOICEMAP_ID=7 };
    
public:
    AttributeDefinition(TObject* pOwner,CSyntaxObject* pUpLink,CSyntaxObject* pParent);
   ~AttributeDefinition();

    static bool Initial();

    DWORD GetAttrData(int AttrId);
    bool  SetAttrData(int AttrId, DWORD Data);
    char* GetAttrName(int AttrId);
        
    bool  proc_CustomAttrib(CPlusLex& Lex, CErrHandler& ErrHandler);  
    bool  Check_varIdent(StructDefinition* pCurStructDefinition, Location Locat, char* varString, CErrHandler& ErrHandler);

    bool  CompleteIt(OTSTR& strError);   // Check Relate Procedure
        
    void  DumpCustomAttrib(FILE* fp, char* sItemHeaderFormat, char* sItemFormat, OTSTR& strHeader,OTSTR& strNextHeader, bool bCompactMode);
    
protected:
    TObject*  m_pOwner;
    DWORD     m_AttrDataList[AttributeNum];
    
    static GramRules m_AttribRule[1];

    /////////////////////////////////////////////////
    TObject* GetDefinitionOwner() { return m_pOwner; }  
    
private:
    friend class TVariableDefinition;
};

//////////////////////////////////////////////////////
class TVariableDefinition: public VariableDefinition
{
public:
    TVariableDefinition();
    TVariableDefinition(StructDefinition* pParent,WORD nIdentifierId);
    virtual ~TVariableDefinition();
    
    StructDefinition* GetTypeOf();
};

class TStructDefinition: public StructDefinition
{
public:
    TStructDefinition();
    TStructDefinition(WORD nIdentifierId);
    virtual ~TStructDefinition();
    
protected:
    bool GetIntegratedType(int* type=NULL);
    
    bool CompleteIt(OTSTR& strError);   // Check Attribute 
    
    friend class Program;
};


#endif