expr.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2025 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef _EXPR_H
#define _EXPR_H
 
#include <ieee.h>
#include <idp.hpp>

 
//------------------------------------------------------------------------
 
// Forward declarations
class idc_value_t;
class idc_class_t;
class idc_object_t;

#define IDC_LANG_EXT             "idc"

 
idaman THREAD_SAFE error_t ida_export idcv_long(idc_value_t *v);
 

 
idaman THREAD_SAFE error_t ida_export idcv_int64(idc_value_t *v);
 

 
idaman THREAD_SAFE error_t ida_export idcv_num(idc_value_t *v);
 

 
idaman THREAD_SAFE error_t ida_export idcv_string(idc_value_t *v);
 

 
idaman THREAD_SAFE error_t ida_export idcv_float(idc_value_t *v);
 

 
idaman THREAD_SAFE error_t ida_export idcv_object(
        idc_value_t *v,
        const idc_class_t *icls=nullptr);
 

 
idaman THREAD_SAFE error_t ida_export move_idcv(
        idc_value_t *dst,
        idc_value_t *src);
 

 
idaman THREAD_SAFE error_t ida_export copy_idcv(
        idc_value_t *dst,
        const idc_value_t &src);
 

 
idaman THREAD_SAFE error_t ida_export deep_copy_idcv(
        idc_value_t *dst,
        const idc_value_t &src);
 

 
idaman THREAD_SAFE void ida_export free_idcv(idc_value_t *v);
 

 
idaman THREAD_SAFE void ida_export swap_idcvs(
        idc_value_t *v1,
        idc_value_t *v2);
 

 
idaman THREAD_SAFE error_t ida_export get_idcv_class_name(
        qstring *out,
        const idc_value_t *obj);
 

 
idaman THREAD_SAFE error_t ida_export get_idcv_attr(
        idc_value_t *res,
        const idc_value_t *obj,
        const char *attr,
        bool may_use_getattr=false);
 

 
idaman THREAD_SAFE error_t ida_export set_idcv_attr(
        idc_value_t *obj,
        const char *attr,
        const idc_value_t &value,
        bool may_use_setattr=false);
 

 
idaman THREAD_SAFE error_t ida_export del_idcv_attr(
        idc_value_t *obj,
        const char *attr);
 

idaman THREAD_SAFE const char *ida_export first_idcv_attr(const idc_value_t *obj);
idaman THREAD_SAFE const char *ida_export last_idcv_attr(const idc_value_t *obj);
idaman THREAD_SAFE const char *ida_export next_idcv_attr(const idc_value_t *obj, const char *attr);
idaman THREAD_SAFE const char *ida_export prev_idcv_attr(const idc_value_t *obj, const char *attr);
 

 
idaman bool ida_export print_idcv(
        qstring *out,
        const idc_value_t &v,
        const char *name=nullptr,
        int indent=0);
 

 
idaman THREAD_SAFE error_t ida_export get_idcv_slice(
        idc_value_t *res,
        const idc_value_t *v,
        uval_t i1,
        uval_t i2,
        int flags=0);

#define VARSLICE_SINGLE 0x0001  

 
idaman THREAD_SAFE error_t ida_export set_idcv_slice(
        idc_value_t *v,
        uval_t i1,
        uval_t i2,
        const idc_value_t &in,
        int flags=0);
 
 
//-------------------------------------------------------------------------
// IDC class related functions

 
idaman THREAD_SAFE idc_class_t *ida_export add_idc_class(
        const char *name,
        const idc_class_t *super=nullptr);
 

 
idaman THREAD_SAFE idc_class_t *ida_export find_idc_class(const char *name);
 

 
idaman THREAD_SAFE bool ida_export set_idc_method(idc_class_t *icls, const char *fullfuncname);
 

idaman THREAD_SAFE const char *ida_export set_idc_getattr(idc_class_t *icls, const char *fullfuncname);
idaman THREAD_SAFE const char *ida_export set_idc_setattr(idc_class_t *icls, const char *fullfuncname);

 
idaman THREAD_SAFE const char *ida_export set_idc_dtor(idc_class_t *icls, const char *fullfuncname);
 

 
idaman THREAD_SAFE idc_value_t *ida_export deref_idcv(idc_value_t *v, int vref_flags);

#define VREF_LOOP 0x0000        
#define VREF_ONCE 0x0001        
#define VREF_COPY 0x0002        
 

 
idaman THREAD_SAFE bool ida_export create_idcv_ref(idc_value_t *ref, const idc_value_t *v);
 

 
idaman THREAD_SAFE idc_value_t *ida_export add_idc_gvar(const char *name);
 

 
idaman THREAD_SAFE idc_value_t *ida_export find_idc_gvar(const char *name);
 
 
//-------------------------------------------------------------------------
class idc_value_t
{
public:
#define  VT_LONG        2       
#define  VT_FLOAT       3       
#define  VT_WILD        4       
#define  VT_OBJ         5       
#define  VT_FUNC        6       
#define  VT_STR         7       
#define  VT_PVOID       8       
#define  VT_INT64       9       
#define  VT_REF        10       
  char vtype = VT_LONG;         
 
#ifndef SWIG
  // this union must be the last member (see memset below)
  union
  {
#endif // SWIG
    sval_t num;                 
    fpvalue_t e;                
    idc_object_t *obj;
    int funcidx;                
    void *pvoid;                
    int64 i64;                  
    uchar reserve[sizeof(qstring)]; 
#ifndef SWIG
  };
#endif // SWIG

  idc_value_t(sval_t n=0)
  {
    memset(reserve, 0, sizeof(idc_value_t) - qoffsetof(idc_value_t, reserve));
    num = n;
  }

  idc_value_t(const idc_value_t &r)
  {
    memset(reserve, 0, sizeof(idc_value_t) - qoffsetof(idc_value_t, reserve));
    copy_idcv(this, r);
  }

  idc_value_t(const char *_str) : vtype(VT_STR) { new(&qstr()) qstring(_str); }
  idc_value_t(const qstring &_str) : vtype(VT_STR) { new(&qstr()) qstring(_str); }
  ~idc_value_t(void) { clear(); }
  void clear(void) { free_idcv(this); } // put num 0
  idc_value_t &operator = (const idc_value_t &r)
  {
    copy_idcv(this, r);
    return *this;
  }
        qstring &qstr(void)       { return *(qstring *)&num; }       
  const qstring &qstr(void) const { return *(qstring *)&num; }       
  const char *c_str(void) const   { return qstr().c_str(); }         
  const uchar *u_str(void) const  { return (const uchar *)c_str(); } 
  void swap(idc_value_t &v) { swap_idcvs(this, &v); }                   
  bool is_zero(void) const { return vtype == VT_LONG && num == 0; }  
  bool is_integral(void)   { return vtype == VT_LONG || vtype == VT_INT64; } 
  bool is_convertible(void) const { return (vtype >= 1 && vtype <= VT_FLOAT) || vtype == VT_STR || vtype == VT_INT64; }

  void _create_empty_string(void) { vtype = VT_STR; new (&qstr()) qstring; }
  void _set_string(const qstring &_str)
  {
    vtype = VT_STR;
    new (&qstr()) qstring(_str);
  }
  void _set_string(const char *_str, size_t len)
  {
    vtype = VT_STR;
    new (&qstr()) qstring(_str, len);
  }
  void _set_string(const char *_str)
  {
    size_t len = _str == nullptr ? 0 : strlen(_str);
    _set_string(_str, len);
  }
  void _set_long(sval_t v) { vtype = VT_LONG; num = v; }
  void _set_pvoid(void *p) { vtype = VT_PVOID; pvoid = p; }
  void _set_int64(int64 v) { vtype = VT_INT64; i64 = v; }
  void _set_float(const fpvalue_t &f) { vtype = VT_FLOAT; e = f; }

  void create_empty_string(void) { clear(); _create_empty_string(); }
  void set_string(const char *_str, size_t len) { clear(); _set_string(_str, len); }
  void set_string(const char *_str) { clear(); _set_string(_str); }
  void set_string(const qstring &_str) { clear(); _set_string(_str); }
  void set_long(sval_t v) { clear(); _set_long(v); }
  void set_pvoid(void *p) { clear(); vtype = VT_PVOID; pvoid = p; }
  void set_int64(int64 v) { clear(); vtype = VT_INT64; i64 = v; }
  void set_float(const fpvalue_t &f) { clear(); vtype = VT_FLOAT; e = f; }
};

struct idc_global_t
{
  qstring name;
  idc_value_t value;
  idc_global_t(void) {}
  idc_global_t(const char *n) : name(n) {}
};
typedef qvector<idc_global_t> idc_vars_t; 

 
typedef error_t idaapi idc_func_t(idc_value_t *argv, idc_value_t *r);
 
#define eExecThrow 90           

struct ext_idcfunc_t
{
  const char *name;             
  idc_func_t *fptr;             
  const char *args;             
  const idc_value_t *defvals;   
  int ndefvals;                 
  int flags;                    
#define EXTFUN_BASE  0x0001     
#define EXTFUN_NORET 0x0002     
#define EXTFUN_SAFE  0x0004     
};

struct idcfuncs_t
{
  size_t qnty;                  
  ext_idcfunc_t *funcs;         


  error_t (idaapi *startup)(void);

  error_t (idaapi *shutdown)(void);

  void (idaapi *init_idc)(void);

  void (idaapi *term_idc)(void);

  bool (idaapi *is_database_open)(void);

  size_t (idaapi *ea2str)(char *buf, size_t bufsize, ea_t ea);

  bool (idaapi *undeclared_variable_ok)(const char *name);



  int get_unkvar;

  int set_unkvar;

  int exec_resolved_func;

  int calc_sizeof;

  int get_field_ea;

};
 
// Our idc_value_t and idc_global_t classes are freely movable with memcpy()
DECLARE_TYPE_AS_MOVABLE(idc_value_t);
DECLARE_TYPE_AS_MOVABLE(idc_global_t);
 
//------------------------------------------------------------------------
 
idaman THREAD_SAFE bool ida_export add_idc_func(const ext_idcfunc_t &func);
 

idaman THREAD_SAFE bool ida_export del_idc_func(const char *name);
 
 
// Find an idc function that starts with the given prefix.
// \param out    buffer for the output name
// \param prefix prefix to search for
// \param n      how many matches to skip
// Returns: success
idaman THREAD_SAFE bool ida_export find_idc_func(
        qstring *out,
        const char *prefix,
        int n=0);
 

enum syntax_highlight_style
{
  HF_DEFAULT = 0,
  HF_KEYWORD1 = 1,
  HF_KEYWORD2 = 2,
  HF_KEYWORD3 = 3,
  HF_STRING = 4,
  HF_COMMENT = 5,
  HF_PREPROC = 6,
  HF_NUMBER = 7,
  HF_USER1 = 8,
  HF_USER2 = 9,
  HF_USER3 = 10,
  HF_USER4 = 11,
 
  HF_MAX,
};
#define HF_FIRST HF_KEYWORD1
 
struct highlighter_cbs_t
{
  virtual ~highlighter_cbs_t() {}
  virtual void idaapi set_style(int32 /*start*/, int32 /*len*/, syntax_highlight_style /*style*/) {}
  virtual int32 idaapi prev_block_state() { return 0; }
  virtual int32 idaapi cur_block_state() { return 0; }
  virtual void idaapi set_block_state(int32 /*state*/) {}
};

struct syntax_highlighter_t
{
  typedef void idaapi block_highlighter_t(
        void *context,
        highlighter_cbs_t *highlighter_cbs,
        const qstring &text);
  syntax_highlighter_t(block_highlighter_t *bh=nullptr) : highlight_block(bh) {}
  virtual ~syntax_highlighter_t() {}
  block_highlighter_t *highlight_block;
};
 
 
//------------------------------------------------------------------------
struct extlang_t
{
  size_t size;                  
  uint32 flags;                 
#define EXTLANG_IDC 0x01
#define EXTLANG_NS_AWARE 0x02   
  int32 refcnt;                 
  const char *name;             
  const char *fileext;          
  syntax_highlighter_t *highlighter; // Language syntax highlighter

  bool (idaapi *compile_expr)(
        const char *name,
        ea_t current_ea,
        const char *expr,
        qstring *errbuf);

  bool (idaapi *compile_file)(const char *file, const char *requested_namespace, qstring *errbuf);

  bool (idaapi *call_func)(
        idc_value_t *result,
        const char *name,
        const idc_value_t args[],
        size_t nargs,
        qstring *errbuf);

  bool (idaapi *eval_expr)(
        idc_value_t *rv,
        ea_t current_ea,
        const char *expr,
        qstring *errbuf);

  bool (idaapi *eval_snippet)(
        const char *str,
        qstring *errbuf);

  bool (idaapi *create_object)(
        idc_value_t *result,
        const char *name,
        const idc_value_t args[],
        size_t nargs,
        qstring *errbuf);

  bool (idaapi *get_attr)(
        idc_value_t *result,
        const idc_value_t *obj,
        const char *attr);

  bool (idaapi *set_attr)(
        idc_value_t *obj,
        const char *attr,
        const idc_value_t &value);

  bool (idaapi *call_method)(
        idc_value_t *result,
        const idc_value_t *obj,
        const char *name,
        const idc_value_t args[],
        size_t nargs,
        qstring *errbuf);

  bool (idaapi *load_procmod)(
        idc_value_t *procobj,
        const char *path,
        qstring *errbuf);

  bool (idaapi *unload_procmod)(
        const char *path,
        qstring *errbuf);
 
  bool is_idc(void) const { return (flags & EXTLANG_IDC) != 0; }
  bool is_namespace_aware(void) const { return (flags & EXTLANG_NS_AWARE) != 0; }
  void release(void) {}
};
 
typedef qvector<extlang_t *> extlangs_t; 
typedef qrefcnt_t<extlang_t> extlang_object_t;

 
idaman void *ida_export get_current_extlang(void); // do not use
 
inline const extlang_object_t get_extlang(void)    // use this function
{
  return extlang_object_t((extlang_t *)get_current_extlang());
}
 

 
idaman ssize_t ida_export install_extlang(extlang_t *el);
 

 
idaman bool ida_export remove_extlang(extlang_t *el);
 

 
idaman bool ida_export select_extlang(extlang_t *el);
 
 
struct extlang_visitor_t
{
  virtual ssize_t idaapi visit_extlang(extlang_t *extlang) = 0;
};

// \param ev     visitor object
// \param select temporarily select extlang for the duration of the visit
// \return 0 or the first non-zero value returned by visit_extlang()
 
idaman ssize_t ida_export for_all_extlangs(extlang_visitor_t &ev, bool select=false);
 
 
// Helper function to search for extlang
enum find_extlang_kind_t
{
  FIND_EXTLANG_BY_EXT,
  FIND_EXTLANG_BY_NAME,
  FIND_EXTLANG_BY_IDX,
};
 
// do not use
idaman void *ida_export find_extlang(const void *str, find_extlang_kind_t kind);
 

 
inline extlang_object_t find_extlang_by_ext(const char *ext)
{
  return extlang_object_t((extlang_t *)find_extlang(ext, FIND_EXTLANG_BY_EXT));
}

 
inline extlang_object_t find_extlang_by_name(const char *name)
{
  return extlang_object_t((extlang_t *)find_extlang(name, FIND_EXTLANG_BY_NAME));
}

 
inline extlang_object_t find_extlang_by_index(size_t idx)
{
  return extlang_object_t((extlang_t *)find_extlang(&idx, FIND_EXTLANG_BY_IDX));
}
 
 
 
//------------------------------------------------------------------------
 
idaman THREAD_SAFE bool ida_export set_header_path(const char *path, bool add);
 

 
idaman THREAD_SAFE char *ida_export get_idc_filename(
        char *buf,
        size_t bufsize,
        const char *file);
 

 
idaman THREAD_SAFE bool ida_export exec_system_script(
        const char *file,
        bool complain_if_no_file=true);
 

 
idaman bool ida_export eval_expr_long(
        sval_t *res,
        ea_t where,
        const char *line,
        qstring *errbuf=nullptr);

 
inline bool idaapi eval_expr_long(
        uval_t *res,
        ea_t where,
        const char *line,
        qstring *errbuf=nullptr)
{
  return eval_expr_long((sval_t *)res, where, line, errbuf);
}
 

 
idaman bool ida_export eval_expr(
        idc_value_t *rv,
        ea_t where,
        const char *line,
        qstring *errbuf=nullptr);
 

 
idaman bool ida_export eval_idc_expr(
        idc_value_t *rv,
        ea_t where,
        const char *buf,
        qstring *errbuf=nullptr);
 


#define CPL_DEL_MACROS 0x0001  
#define CPL_USE_LABELS 0x0002  
#define CPL_ONLY_SAFE  0x0004  
 
idaman THREAD_SAFE bool ida_export compile_idc_file(
        const char *file,
        qstring *errbuf=nullptr,
        int cpl_flags = CPL_DEL_MACROS|CPL_USE_LABELS);
 

 
struct idc_resolver_t
{
  virtual uval_t idaapi resolve_name(const char *name) = 0;
};
 
idaman THREAD_SAFE bool ida_export compile_idc_text(
        const char *line,
        qstring *errbuf=nullptr,
        idc_resolver_t *resolver=nullptr,
        bool only_safe_funcs=false);
 

 
idaman bool ida_export compile_idc_snippet(
        const char *func,
        const char *text,
        qstring *errbuf=nullptr,
        idc_resolver_t *resolver=nullptr,
        bool only_safe_funcs=false);
 
 
// Execution of IDC code can generate exceptions. Exception objects
// will have the following attributes:
//      file - the source file name
//      line - the line number that was executing when the exception occurred
//      func - the function name
//      pc   - bytecode program counter
// For runtime errors, the following additional attributes exist:
//      qerrno - runtime error code
//      description - text description of the runtime error

 
idaman bool ida_export call_idc_func(
        idc_value_t *result,
        const char *fname,
        const idc_value_t args[],
        size_t argsnum,
        qstring *errbuf=nullptr,
        idc_resolver_t *resolver=nullptr);
 

 
THREAD_SAFE inline bool exec_idc_script(
        idc_value_t *result,
        const char *path,
        const char *func,
        const idc_value_t args[],
        size_t argsnum,
        qstring *errbuf=nullptr)
{
  if ( !compile_idc_file(path, errbuf) )
    return false;
  return call_idc_func(result, func, args, argsnum, errbuf);
}
 

 
 
idaman bool ida_export eval_idc_snippet(
        idc_value_t *result,
        const char *line,
        qstring *errbuf=nullptr,
        idc_resolver_t *resolver=nullptr);
 
 
//------------------------------------------------------------------------
 
idaman void ida_export setup_lowcnd_regfuncs(idc_func_t *getreg, idc_func_t *setreg);
 
//------------------------------------------------------------------------
inline THREAD_SAFE bool get_idptype_and_data(int *vtype, const void **vdata, const idc_value_t &v)
{
  switch ( v.vtype )
  {
    case VT_STR:   *vtype = IDPOPT_STR, *vdata = v.c_str(); break;
    case VT_LONG:  *vtype = IDPOPT_NUM; *vdata = &v.num; break;
    case VT_WILD:  *vtype = IDPOPT_BIT; *vdata = &v.num; break;
    case VT_INT64: *vtype = IDPOPT_I64; *vdata = &v.i64; break;
    case VT_PVOID: *vtype = IDPOPT_CST; *vdata = v.pvoid; break;
    default: return false;
  }
  return true;
}

 
idaman error_t ida_export throw_idc_exception(idc_value_t *r, const char *desc);
 
 
#endif /* _EXPR_H */