bytes.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2026 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef BYTES_HPP
#define BYTES_HPP
 
#include <nalt.hpp>
#include <lines.hpp>
#include <range.hpp>
 
class insn_t;

 
//--------------------------------------------------------------------------
 
idaman error_t ida_export enable_flags(ea_t start_ea, ea_t end_ea, storage_type_t stt);
 

 
idaman error_t ida_export disable_flags(ea_t start_ea, ea_t end_ea);
 

 
idaman error_t ida_export change_storage_type(ea_t start_ea, ea_t end_ea, storage_type_t stt);
 

 
idaman ea_t ida_export next_addr(ea_t ea);
 

 
idaman ea_t ida_export prev_addr(ea_t ea);
 

 
idaman ea_t ida_export next_chunk(ea_t ea);
 

 
idaman ea_t ida_export prev_chunk(ea_t ea);
 

 
idaman ea_t ida_export chunk_start(ea_t ea);
 

 
idaman asize_t ida_export chunk_size(ea_t ea);
 

 
idaman ea_t ida_export find_free_chunk(ea_t start, asize_t size, asize_t alignment);
 

typedef bool idaapi testf_t(flags64_t flags, void *ud);
 

 
idaman ea_t ida_export next_that(
        ea_t ea,
        ea_t maxea,
        testf_t *testf,
        void *ud=nullptr);
 

 
inline ea_t idaapi next_unknown(ea_t ea, ea_t maxea)
{
  return next_that(ea, maxea, nullptr);
}
 

 
idaman ea_t ida_export prev_that(
        ea_t ea,
        ea_t minea,
        testf_t *testf,
        void *ud=nullptr);
 

 
inline ea_t idaapi prev_unknown(ea_t ea, ea_t minea)
{
  return prev_that(ea, minea, nullptr);
}
 

 
idaman ea_t ida_export prev_head(ea_t ea, ea_t minea);
 

 
idaman ea_t ida_export next_head(ea_t ea, ea_t maxea);
 

 
idaman ea_t ida_export prev_not_tail(ea_t ea);
 

 
idaman ea_t ida_export next_not_tail(ea_t ea);
 

 
idaman ea_t ida_export prev_visea(ea_t ea);
 

 
idaman ea_t ida_export next_visea(ea_t ea);
 
 
 

 
inline ea_t idaapi get_item_head(ea_t ea);
 

 
idaman ea_t ida_export get_item_end(ea_t ea);
 

 
idaman ea_t ida_export calc_max_item_end(ea_t ea, int how=15);
#define ITEM_END_FIXUP  0x0001          
#define ITEM_END_INITED 0x0002          
#define ITEM_END_NAME   0x0004          
#define ITEM_END_XREF   0x0008          
#define ITEM_END_CANCEL 0x0010          
 

 
inline asize_t get_item_size(ea_t ea) { return get_item_end(ea) - ea; }
 
 
 

 
idaman bool ida_export is_mapped(ea_t ea);
 

 
idaman flags64_t ida_export get_flags_ex(ea_t ea, int how);
 
#define GFE_VALUE 0x0001      
#define GFE_IDB_VALUE 0x0002  
#define GFE_32BIT 0x0004      

inline flags64_t idaapi get_flags32(ea_t ea) { return get_flags_ex(ea, GFE_32BIT); }

inline flags64_t idaapi get_flags(ea_t ea) { return get_flags_ex(ea, 0); }

inline flags64_t idaapi get_full_flags(ea_t ea) { return get_flags_ex(ea, GFE_VALUE); }
 

 
idaman flags64_t ida_export get_item_flag(ea_t from, int n, ea_t ea, bool appzero);
 
 
//--------------------------------------------------------------------------
idaman bool ida_export get_item_refinfo(refinfo_t *ri, ea_t ea, int n);
 
//--------------------------------------------------------------------------
#define MS_VAL  0x000000FF             
#define FF_IVL  0x00000100             

 
inline THREAD_SAFE constexpr bool idaapi has_value(flags64_t F)  { return (F & FF_IVL) != 0; }
 

 
idaman void ida_export del_value(ea_t ea);
 

 
idaman bool ida_export is_loaded(ea_t ea);
 

 
idaman int ida_export nbits(ea_t ea);
 

 
inline int bytesize(ea_t ea)
          { return (nbits(ea)+7)/8; }
 

 
idaman uchar ida_export get_byte(ea_t ea);
 

 
idaman uchar ida_export get_db_byte(ea_t ea);
 

 
idaman ushort ida_export get_word(ea_t ea);
 

 
idaman uint32 ida_export get_dword(ea_t ea);
 

 
idaman uint64 ida_export get_qword(ea_t ea);
 

 
idaman uint64 ida_export get_wide_byte(ea_t ea);
 

 
idaman uint64 ida_export get_wide_word(ea_t ea);
 

 
idaman uint64 ida_export get_wide_dword(ea_t ea);
 

 
struct octet_generator_t
{
  uint64 value = 0;
  ea_t ea;
  int avail_bits = 0;
  bool high_byte_first = inf_is_wide_high_byte_first();
  octet_generator_t(ea_t _ea) : ea(_ea) {}
  void invert_byte_order() { high_byte_first = !high_byte_first; }
#ifndef SWIG
  DECLARE_COMPARISONS(octet_generator_t)
  {
    COMPARE_FIELDS(ea);
    if ( avail_bits < r.avail_bits )
      return 1; // less bits available means that we have advanced more
    if ( avail_bits > r.avail_bits )
      return -1; // more bits available means that we have advanced less
    return 0;
  }
#endif
};
 
idaman bool ida_export get_octet(uchar *out, octet_generator_t *ogen);
 
 

 
idaman uint32 ida_export get_16bit(ea_t ea);
 

 
idaman uint32 ida_export get_32bit(ea_t ea);
 

 
idaman uint64 ida_export get_64bit(ea_t ea);
 

 
idaman bool ida_export get_data_value(uval_t *v, ea_t ea, asize_t size);
 

 
idaman int ida_export visit_patched_bytes(
        ea_t ea1,
        ea_t ea2,
        int (idaapi *cb)(ea_t ea, qoff64_t fpos, uint64 o, uint64 v, void *ud),
        void *ud = nullptr);
 

 
idaman uint64 ida_export get_original_byte(ea_t ea);
 

 
idaman uint64 ida_export get_original_word(ea_t ea);
 

 
idaman uint64 ida_export get_original_dword(ea_t ea);
 

 
idaman uint64 ida_export get_original_qword(ea_t ea);
 

 
idaman bool ida_export put_byte(ea_t ea, uint64 x);
 

 
idaman void ida_export put_word(ea_t ea, uint64 x);
 

 
idaman void ida_export put_dword(ea_t ea, uint64 x);
 

 
idaman void ida_export put_qword(ea_t ea, uint64 x);
 

 
idaman bool ida_export patch_byte(ea_t ea, uint64 x);
 

 
idaman bool ida_export patch_word(ea_t ea, uint64 x);
 

 
idaman bool ida_export patch_dword(ea_t ea, uint64 x);
 

 
idaman bool ida_export patch_qword(ea_t ea, uint64 x);
 

 
idaman bool ida_export revert_byte(ea_t ea);
 

 
idaman void ida_export add_byte(ea_t ea, uint32 value);
 

 
idaman void ida_export add_word(ea_t ea, uint64 value);
 

 
idaman void ida_export add_dword(ea_t ea, uint64 value);
 

 
idaman void ida_export add_qword(ea_t ea, uint64 value);
 

 
idaman bool ida_export get_zero_ranges(rangeset_t *zranges, const range_t *range);
 

 
idaman ssize_t ida_export get_bytes(
        void *buf,
        ssize_t size,
        ea_t ea,
        int gmb_flags=0,
        void *mask=nullptr);

#define GMB_READALL 0x01       
#define GMB_WAITBOX 0x02       
 

 
idaman void ida_export put_bytes(ea_t ea, const void *buf, size_t size);
 

 
idaman void ida_export patch_bytes(ea_t ea, const void *buf, size_t size);
 
//-------------------------------------------------------------------------

#define MS_CLS  0x00000600             
#define FF_CODE 0x00000600             
#define FF_DATA 0x00000400             
#define FF_TAIL 0x00000200             
#define FF_UNK  0x00000000             


 
inline THREAD_SAFE constexpr bool idaapi is_code(flags64_t F)  { return (F & MS_CLS) == FF_CODE; }
inline                       bool idaapi is_code_ea(ea_t ea)   { return is_code(get_flags32(ea)); }
inline THREAD_SAFE constexpr bool idaapi f_is_code(flags64_t F, void *) { return is_code(F); }         
 

 
inline THREAD_SAFE constexpr bool idaapi is_data(flags64_t F)  { return (F & MS_CLS) == FF_DATA; }
inline                       bool idaapi is_data_ea(ea_t ea)   { return is_data(get_flags32(ea)); }
inline THREAD_SAFE constexpr bool idaapi f_is_data(flags64_t F, void *) { return is_data(F); }         
 

 
inline THREAD_SAFE constexpr bool idaapi is_tail(flags64_t F)  { return (F & MS_CLS) == FF_TAIL; }
inline                       bool idaapi is_tail_ea(ea_t ea)   { return is_tail(get_flags32(ea)); }
inline THREAD_SAFE constexpr bool idaapi f_is_tail(flags64_t F, void *) { return is_tail(F); }         
inline THREAD_SAFE constexpr bool idaapi is_not_tail(flags64_t F) { return !is_tail(F); }              
inline THREAD_SAFE constexpr bool idaapi f_is_not_tail(flags64_t F, void *) { return is_not_tail(F); } 
 

 
inline THREAD_SAFE constexpr bool idaapi is_unknown(flags64_t F) { return (F & MS_CLS) == FF_UNK; }
inline                       bool idaapi is_unknown_ea(ea_t ea)  { return is_unknown(get_flags32(ea)); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_head(flags64_t F)  { return (F & FF_DATA) != 0; }
inline                       bool idaapi is_head_ea(ea_t ea)   { return is_head(get_flags32(ea)); }
inline THREAD_SAFE constexpr bool idaapi f_is_head(flags64_t F, void *) { return is_head(F); }         


typedef bool idaapi may_destroy_cb_t(ea_t);

 
idaman bool ida_export del_items(
        ea_t ea,
        int flags=0,
        asize_t nbytes=1,
        may_destroy_cb_t *may_destroy=nullptr);

#define DELIT_SIMPLE    0x0000  
#define DELIT_EXPAND    0x0001  
#define DELIT_DELNAMES  0x0002  
#define DELIT_NOTRUNC   0x0004  
#define DELIT_NOUNAME   0x0008  
#define DELIT_NOCMT     0x0010  
#define DELIT_KEEPFUNC  0x0020  
 
 
//-------------------------------------------------------------------------
// Manual instructions (they are used to completely override an automatically
// generated instruction by a user specified string).

 
idaman bool ida_export is_manual_insn(ea_t ea);        // Is the instruction overridden?
 

 
idaman ssize_t ida_export get_manual_insn(qstring *buf, ea_t ea);
 

 
idaman void ida_export set_manual_insn(ea_t ea, const char *manual_insn); // Set user-specified string
 
 
//-------------------------------------------------------------------------
#define MS_COMM  0x000FF800            
#define FF_COMM  0x00000800            
#define FF_REF   0x00001000            
#define FF_LINE  0x00002000            
#define FF_NAME  0x00004000            
#define FF_LABL  0x00008000            
#define FF_FLOW  0x00010000            
#define FF_SIGN  0x00020000            
#define FF_BNOT  0x00040000            
#define FF_UNUSED 0x00080000           


 
inline THREAD_SAFE constexpr bool idaapi is_flow(flags64_t F)     { return (F & FF_FLOW) != 0; }
inline                       bool idaapi is_flow_ea(ea_t ea)      { return is_flow(get_flags32(ea)); }
 

 
inline THREAD_SAFE constexpr bool idaapi has_extra_cmts(flags64_t F)   { return (F & FF_LINE) != 0; }
inline THREAD_SAFE constexpr bool idaapi f_has_extra_cmts(flags64_t f, void *) { return has_extra_cmts(f); }

 
inline THREAD_SAFE constexpr bool idaapi has_cmt(flags64_t F)    { return (F & FF_COMM) != 0; }
inline THREAD_SAFE constexpr bool idaapi f_has_cmt(flags64_t f, void *) { return has_cmt(f); }

 
inline THREAD_SAFE constexpr bool idaapi has_xref(flags64_t F)     { return (F & FF_REF)  != 0; }
inline THREAD_SAFE constexpr bool idaapi f_has_xref(flags64_t f, void *) { return has_xref(f); }       
 

 
inline THREAD_SAFE constexpr bool idaapi has_name(flags64_t F)   { return (F & FF_NAME) != 0; }
inline THREAD_SAFE constexpr bool idaapi f_has_name(flags64_t f, void *) { return has_name(f); }       
 
 
 
#define FF_ANYNAME      (FF_LABL|FF_NAME) 

 
inline THREAD_SAFE constexpr bool idaapi has_dummy_name(flags64_t F) { return (F & FF_ANYNAME) == FF_LABL; }
inline THREAD_SAFE constexpr bool idaapi f_has_dummy_name(flags64_t f, void *) { return has_dummy_name(f); } 
 

 
inline THREAD_SAFE constexpr bool idaapi has_auto_name(flags64_t F) { return (F & FF_ANYNAME) == FF_ANYNAME; }
 

 
inline THREAD_SAFE constexpr bool idaapi has_any_name(flags64_t F) { return (F & FF_ANYNAME) != 0; }
 

 
inline THREAD_SAFE constexpr bool idaapi has_user_name(flags64_t F) { return (F & FF_ANYNAME) == FF_NAME; }
inline THREAD_SAFE constexpr bool idaapi f_has_user_name(flags64_t F, void *) { return has_user_name(F); } 
 
// signness deals with the form of operands of the current instruction/data.
// inverted sign means the following:
//    if the bit is clear       |then when the bit is set
//    and the output is         |the output should be:
//    ------------              |----------
//    unsigned                  |signed
//    signed                    |unsigned
//

 
idaman bool ida_export is_invsign(ea_t ea, flags64_t F, int n);
 

 
idaman bool ida_export toggle_sign(ea_t ea, int n);
 

 
idaman bool ida_export is_bnot(ea_t ea, flags64_t F, int n);
idaman bool ida_export toggle_bnot(ea_t ea, int n);  
 

 
idaman bool ida_export is_lzero(ea_t ea, int n);

 
idaman bool ida_export set_lzero(ea_t ea, int n);

 
idaman bool ida_export clr_lzero(ea_t ea, int n);

 
inline bool idaapi toggle_lzero(ea_t ea, int n)
{
  return (is_lzero(ea, n) ? clr_lzero : set_lzero)(ea, n);
}
 

 

 
idaman bool ida_export leading_zero_important(ea_t ea, int n);
 
//-------------------------------------------------------------------------
 
#define MS_N_TYPE 0xFLLU 
#define FF_N_VOID 0x0    
#define FF_N_NUMH 0x1    
#define FF_N_NUMD 0x2    
#define FF_N_CHAR 0x3    
#define FF_N_SEG  0x4    
#define FF_N_OFF  0x5    
#define FF_N_NUMB 0x6    
#define FF_N_NUMO 0x7    
#define FF_N_ENUM 0x8    
#define FF_N_FOP  0x9    
#define FF_N_STRO 0xA    
#define FF_N_STK  0xB    
#define FF_N_FLT  0xC    
#define FF_N_CUST 0xD    

 
inline constexpr int get_operand_type_shift(uint32 n)
{
  return 20 + (4 * (n + (n > 1)));
}

 
inline constexpr flags64_t get_operand_flag(uint8 typebits, int n)
{
  return n >= 0 && n < UA_MAXOP ? flags64_t(typebits) << get_operand_type_shift(n) : 0;
}

 
inline constexpr uint8 get_optype_flags(flags64_t F, int n)
{
  return n >= 0 && n < UA_MAXOP
       ? uint8((F >> get_operand_type_shift(n)) & MS_N_TYPE)
       : 0;
}

 
inline constexpr void set_operand_flag(flags64_t &F, uint8 typebits, int n)
{
  if ( n >= 0 && n < UA_MAXOP )
  {
    F &= ~get_operand_flag(MS_N_TYPE, n);
    F |= get_operand_flag(typebits, n);
  }
}

 
inline constexpr bool is_flag_for_operand(flags64_t F, uint8 typebits, int n)
{
  return n < UA_MAXOP && (F & get_operand_flag(MS_N_TYPE, n)) == get_operand_flag(typebits, n);
}


 
inline THREAD_SAFE constexpr bool idaapi is_defarg0(flags64_t F) { return !is_flag_for_operand(F, FF_N_VOID, 0); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_defarg1(flags64_t F) { return !is_flag_for_operand(F, FF_N_VOID, 1); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_off0(flags64_t F)    { return is_flag_for_operand(F, FF_N_OFF, 0); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_off1(flags64_t F)    { return is_flag_for_operand(F, FF_N_OFF, 1); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_char0(flags64_t F)   { return is_flag_for_operand(F, FF_N_CHAR, 0); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_char1(flags64_t F)   { return is_flag_for_operand(F, FF_N_CHAR, 1); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_seg0(flags64_t F)    { return is_flag_for_operand(F, FF_N_SEG, 0); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_seg1(flags64_t F)    { return is_flag_for_operand(F, FF_N_SEG, 1); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_enum0(flags64_t F)   { return is_flag_for_operand(F, FF_N_ENUM, 0); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_enum1(flags64_t F)   { return is_flag_for_operand(F, FF_N_ENUM, 1); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_stroff0(flags64_t F) { return is_flag_for_operand(F, FF_N_STRO, 0); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_stroff1(flags64_t F) { return is_flag_for_operand(F, FF_N_STRO, 1); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_stkvar0(flags64_t F) { return is_flag_for_operand(F, FF_N_STK, 0);  }
 

 
inline THREAD_SAFE constexpr bool idaapi is_stkvar1(flags64_t F) { return is_flag_for_operand(F, FF_N_STK, 1); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_float0(flags64_t F) { return is_flag_for_operand(F, FF_N_FLT, 0); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_float1(flags64_t F) { return is_flag_for_operand(F, FF_N_FLT, 1); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_custfmt0(flags64_t F) { return is_flag_for_operand(F, FF_N_CUST, 0); }
 

 
inline THREAD_SAFE constexpr bool idaapi is_custfmt1(flags64_t F) { return is_flag_for_operand(F, FF_N_CUST, 1); }
 

 
idaman bool ida_export is_numop0(flags64_t F);
 

 
idaman bool ida_export is_numop1(flags64_t F);
 

 
inline THREAD_SAFE constexpr flags64_t get_optype_flags0(flags64_t F) { return F & (MS_N_TYPE << get_operand_type_shift(0)); }
 

 
inline THREAD_SAFE constexpr flags64_t get_optype_flags1(flags64_t F) { return F & (MS_N_TYPE << get_operand_type_shift(1)); }

 
//-------------------------------------------------------------------------
//
//      The following 2 masks are used with operand numbers
//
#define OPND_OUTER      0x80            
#define OPND_MASK       0x0F            
#define OPND_ALL        OPND_MASK       

idaman bool ida_export is_defarg(flags64_t F, int n);          
idaman bool ida_export is_off(flags64_t F, int n);             
idaman bool ida_export is_char(flags64_t F, int n);            
idaman bool ida_export is_seg(flags64_t F, int n);             
idaman bool ida_export is_enum(flags64_t F, int n);            
idaman bool ida_export is_manual(flags64_t F, int n);          
idaman bool ida_export is_stroff(flags64_t F, int n);          
idaman bool ida_export is_stkvar(flags64_t F, int n);          
idaman bool ida_export is_fltnum(flags64_t F, int n);          
idaman bool ida_export is_custfmt(flags64_t F, int n);         
idaman bool ida_export is_numop(flags64_t F, int n);           
idaman bool ida_export is_suspop(ea_t ea, flags64_t F, int n); 
 

 
idaman bool ida_export op_adds_xrefs(flags64_t F, int n);
 

 
idaman bool ida_export set_op_type(ea_t ea, flags64_t type, int n);
 

 
idaman bool ida_export op_seg(ea_t ea, int n);
 

 
idaman bool ida_export op_enum(ea_t ea, int n, tid_t id, uchar serial=0);
 

 
idaman tid_t ida_export get_enum_id(uchar *serial, ea_t ea, int n);
 

 
idaman bool ida_export op_stroff(
        const insn_t &insn,
        int n,
        const tid_t *path,
        int path_len,
        adiff_t delta);
 

 
idaman bool ida_export op_based_stroff(
        const insn_t &insn,
        int n,
        adiff_t opval,
        ea_t base);
 

 
idaman int ida_export get_stroff_path(tid_t *path, adiff_t *delta, ea_t ea, int n);

 
idaman bool ida_export op_stkvar(ea_t ea, int n);
 

 
idaman bool ida_export set_forced_operand(ea_t ea, int n, const char *op);
 

 
idaman ssize_t ida_export get_forced_operand(qstring *buf, ea_t ea, int n);
 

 
idaman bool ida_export is_forced_operand(ea_t ea, int n);
 
 
//-------------------------------------------------------------------------
inline constexpr flags64_t idaapi combine_flags(flags64_t F)
{
  return (F << get_operand_type_shift(0))
       | (F << get_operand_type_shift(1))
       | (F << get_operand_type_shift(2))
       | (F << get_operand_type_shift(3))
       | (F << get_operand_type_shift(4))
       | (F << get_operand_type_shift(5))
       | (F << get_operand_type_shift(6))
       | (F << get_operand_type_shift(7));
}
 
//-------------------------------------------------------------------------
inline constexpr flags64_t idaapi char_flag(void)    { return combine_flags(FF_N_CHAR); } 
inline constexpr flags64_t idaapi off_flag(void)     { return combine_flags(FF_N_OFF); }  
inline constexpr flags64_t idaapi enum_flag(void)    { return combine_flags(FF_N_ENUM); } 
inline constexpr flags64_t idaapi stroff_flag(void)  { return combine_flags(FF_N_STRO); } 
inline constexpr flags64_t idaapi stkvar_flag(void)  { return combine_flags(FF_N_STK); }  
inline constexpr flags64_t idaapi flt_flag(void)     { return combine_flags(FF_N_FLT); }  
inline constexpr flags64_t idaapi custfmt_flag(void) { return combine_flags(FF_N_CUST); } 
inline constexpr flags64_t idaapi seg_flag(void)     { return combine_flags(FF_N_SEG); }  
 
idaman flags64_t ida_export num_flag(void); 
inline constexpr flags64_t idaapi hex_flag(void)     { return combine_flags(FF_N_NUMH); }
inline constexpr flags64_t idaapi dec_flag(void)     { return combine_flags(FF_N_NUMD); } 
inline constexpr flags64_t idaapi oct_flag(void)     { return combine_flags(FF_N_NUMO); } 
inline constexpr flags64_t idaapi bin_flag(void)     { return combine_flags(FF_N_NUMB); } 

inline bool idaapi op_chr(ea_t ea, int n) { return set_op_type(ea, char_flag(), n); } 
inline bool idaapi op_num(ea_t ea, int n) { return set_op_type(ea, num_flag(), n); } 
inline bool idaapi op_hex(ea_t ea, int n) { return set_op_type(ea, hex_flag(), n); } 
inline bool idaapi op_dec(ea_t ea, int n) { return set_op_type(ea, dec_flag(), n); } 
inline bool idaapi op_oct(ea_t ea, int n) { return set_op_type(ea, oct_flag(), n); } 
inline bool idaapi op_bin(ea_t ea, int n) { return set_op_type(ea, bin_flag(), n); } 
inline bool idaapi op_flt(ea_t ea, int n) { return set_op_type(ea, flt_flag(), n); } 

 
idaman bool ida_export op_custfmt(ea_t ea, int n, int fid);
 

 
idaman bool ida_export clr_op_type(ea_t ea, int n);
 

 
idaman int ida_export get_default_radix(void);
 

 
idaman int ida_export get_radix(flags64_t F, int n);
 
 
//-------------------------------------------------------------------------
#define DT_TYPE 0xF0000000             
 
#define FF_BYTE     0x00000000         
#define FF_WORD     0x10000000         
#define FF_DWORD    0x20000000         
#define FF_QWORD    0x30000000         
#define FF_TBYTE    0x40000000         
#define FF_STRLIT   0x50000000         
#define FF_STRUCT   0x60000000         
#define FF_OWORD    0x70000000         
#define FF_FLOAT    0x80000000         
#define FF_DOUBLE   0x90000000         
#define FF_PACKREAL 0xA0000000         
#define FF_ALIGN    0xB0000000         
//                  0xC0000000         ///< reserved
#define FF_CUSTOM   0xD0000000         
#define FF_YWORD    0xE0000000         
#define FF_ZWORD    0xF0000000         

inline constexpr flags64_t idaapi code_flag(void)     { return FF_CODE; }              
inline constexpr flags64_t idaapi byte_flag(void)     { return FF_DATA|FF_BYTE; }      
inline constexpr flags64_t idaapi word_flag(void)     { return FF_DATA|FF_WORD; }      
inline constexpr flags64_t idaapi dword_flag(void)    { return FF_DATA|FF_DWORD; }     
inline constexpr flags64_t idaapi qword_flag(void)    { return FF_DATA|FF_QWORD; }     
inline constexpr flags64_t idaapi oword_flag(void)    { return FF_DATA|FF_OWORD; }     
inline constexpr flags64_t idaapi yword_flag(void)    { return FF_DATA|FF_YWORD; }     
inline constexpr flags64_t idaapi zword_flag(void)    { return FF_DATA|FF_ZWORD; }     
inline constexpr flags64_t idaapi tbyte_flag(void)    { return FF_DATA|FF_TBYTE; }     
inline constexpr flags64_t idaapi strlit_flag(void)   { return FF_DATA|FF_STRLIT; }    
inline constexpr flags64_t idaapi stru_flag(void)     { return FF_DATA|FF_STRUCT; }    
inline constexpr flags64_t idaapi cust_flag(void)     { return FF_DATA|FF_CUSTOM; }    
inline constexpr flags64_t idaapi align_flag(void)    { return FF_DATA|FF_ALIGN; }     
inline constexpr flags64_t idaapi float_flag(void)    { return FF_DATA|FF_FLOAT; }     
inline constexpr flags64_t idaapi double_flag(void)   { return FF_DATA|FF_DOUBLE; }    
inline constexpr flags64_t idaapi packreal_flag(void) { return FF_DATA|FF_PACKREAL; }  
 
inline THREAD_SAFE constexpr bool idaapi is_byte(flags64_t F)      { return is_data(F) && (F & DT_TYPE) == FF_BYTE; }      
inline THREAD_SAFE constexpr bool idaapi is_word(flags64_t F)      { return is_data(F) && (F & DT_TYPE) == FF_WORD; }      
inline THREAD_SAFE constexpr bool idaapi is_dword(flags64_t F)     { return is_data(F) && (F & DT_TYPE) == FF_DWORD; }     
inline THREAD_SAFE constexpr bool idaapi is_qword(flags64_t F)     { return is_data(F) && (F & DT_TYPE) == FF_QWORD; }     
inline THREAD_SAFE constexpr bool idaapi is_oword(flags64_t F)     { return is_data(F) && (F & DT_TYPE) == FF_OWORD; }     
inline THREAD_SAFE constexpr bool idaapi is_yword(flags64_t F)     { return is_data(F) && (F & DT_TYPE) == FF_YWORD; }     
inline THREAD_SAFE constexpr bool idaapi is_zword(flags64_t F)     { return is_data(F) && (F & DT_TYPE) == FF_ZWORD; }     
inline THREAD_SAFE constexpr bool idaapi is_tbyte(flags64_t F)     { return is_data(F) && (F & DT_TYPE) == FF_TBYTE; }     
inline THREAD_SAFE constexpr bool idaapi is_float(flags64_t F)     { return is_data(F) && (F & DT_TYPE) == FF_FLOAT; }     
inline THREAD_SAFE constexpr bool idaapi is_double(flags64_t F)    { return is_data(F) && (F & DT_TYPE) == FF_DOUBLE; }    
inline THREAD_SAFE constexpr bool idaapi is_pack_real(flags64_t F) { return is_data(F) && (F & DT_TYPE) == FF_PACKREAL; }  
inline THREAD_SAFE constexpr bool idaapi is_strlit(flags64_t F)    { return is_data(F) && (F & DT_TYPE) == FF_STRLIT; }    
inline THREAD_SAFE constexpr bool idaapi is_struct(flags64_t F)    { return is_data(F) && (F & DT_TYPE) == FF_STRUCT; }    
inline THREAD_SAFE constexpr bool idaapi is_align(flags64_t F)     { return is_data(F) && (F & DT_TYPE) == FF_ALIGN; }     
inline THREAD_SAFE constexpr bool idaapi is_custom(flags64_t F)    { return is_data(F) && (F & DT_TYPE) == FF_CUSTOM; }    
 
inline bool idaapi is_byte_ea(ea_t ea)       { return is_byte(get_flags32(ea)); }
inline bool idaapi is_word_ea(ea_t ea)       { return is_word(get_flags32(ea)); }
inline bool idaapi is_dword_ea(ea_t ea)      { return is_dword(get_flags32(ea)); }
inline bool idaapi is_qword_ea(ea_t ea)      { return is_qword(get_flags32(ea)); }
inline bool idaapi is_oword_ea(ea_t ea)      { return is_oword(get_flags32(ea)); }
inline bool idaapi is_yword_ea(ea_t ea)      { return is_yword(get_flags32(ea)); }
inline bool idaapi is_zword_ea(ea_t ea)      { return is_zword(get_flags32(ea)); }
inline bool idaapi is_tbyte_ea(ea_t ea)      { return is_tbyte(get_flags32(ea)); }
inline bool idaapi is_float_ea(ea_t ea)      { return is_float(get_flags32(ea)); }
inline bool idaapi is_double_ea(ea_t ea)     { return is_double(get_flags32(ea)); }
inline bool idaapi is_pack_real_ea(ea_t ea)  { return is_pack_real(get_flags32(ea)); }
inline bool idaapi is_strlit_ea(ea_t ea)     { return is_strlit(get_flags32(ea)); }
inline bool idaapi is_struct_ea(ea_t ea)     { return is_struct(get_flags32(ea)); }
inline bool idaapi is_align_ea(ea_t ea)      { return is_align(get_flags32(ea)); }
inline bool idaapi is_custom_ea(ea_t ea)     { return is_custom(get_flags32(ea)); }
 
inline THREAD_SAFE constexpr bool idaapi f_is_byte(flags64_t F, void *)      { return is_byte(F); }                        
inline THREAD_SAFE constexpr bool idaapi f_is_word(flags64_t F, void *)      { return is_word(F); }                        
inline THREAD_SAFE constexpr bool idaapi f_is_dword(flags64_t F, void *)     { return is_dword(F); }                       
inline THREAD_SAFE constexpr bool idaapi f_is_qword(flags64_t F, void *)     { return is_qword(F); }                       
inline THREAD_SAFE constexpr bool idaapi f_is_oword(flags64_t F, void *)     { return is_oword(F); }                       
inline THREAD_SAFE constexpr bool idaapi f_is_yword(flags64_t F, void *)     { return is_yword(F); }                       
inline THREAD_SAFE constexpr bool idaapi f_is_tbyte(flags64_t F, void *)     { return is_tbyte(F); }                       
inline THREAD_SAFE constexpr bool idaapi f_is_float(flags64_t F, void *)     { return is_float(F); }                       
inline THREAD_SAFE constexpr bool idaapi f_is_double(flags64_t F, void *)    { return is_double(F); }                      
inline THREAD_SAFE constexpr bool idaapi f_is_pack_real(flags64_t F, void *) { return is_pack_real(F); }                   
inline THREAD_SAFE constexpr bool idaapi f_is_strlit(flags64_t F, void *)    { return is_strlit(F); }                      
inline THREAD_SAFE constexpr bool idaapi f_is_struct(flags64_t F, void *)    { return is_struct(F); }                      
inline THREAD_SAFE constexpr bool idaapi f_is_align(flags64_t F, void *)     { return is_align(F); }                       
inline THREAD_SAFE constexpr bool idaapi f_is_custom(flags64_t F, void *)    { return is_custom(F); }                      
 

 
inline THREAD_SAFE constexpr bool idaapi is_same_data_type(flags64_t F1, flags64_t F2) { return ((F1 ^ F2) & DT_TYPE) == 0; }
 

 
idaman flags64_t ida_export get_flags_by_size(size_t size);
 


 
idaman bool ida_export create_data(
        ea_t ea,
        flags64_t dataflag,
        asize_t size,
        tid_t tid);
 
 
inline THREAD_SAFE flags64_t idaapi calc_dflags(flags64_t f, bool force) { return f | (force ? FF_COMM : 0); }
inline bool idaapi create_byte(ea_t ea, asize_t length, bool force=false)
{
  return create_data(ea, calc_dflags(FF_BYTE, force), length, BADNODE);
}

inline bool idaapi create_word(ea_t ea, asize_t length, bool force=false)
{
  return create_data(ea, calc_dflags(FF_WORD, force), length, BADNODE);
}

inline bool idaapi create_dword(ea_t ea, asize_t length, bool force=false)
{
  return create_data(ea, calc_dflags(FF_DWORD, force), length, BADNODE);
}

inline bool idaapi create_qword(ea_t ea, asize_t length, bool force=false)
{
  return create_data(ea, calc_dflags(FF_QWORD, force), length, BADNODE);
}

inline bool idaapi create_oword(ea_t ea, asize_t length, bool force=false)
{
  return create_data(ea, calc_dflags(FF_OWORD, force), length, BADNODE);
}

inline bool idaapi create_yword(ea_t ea, asize_t length, bool force=false)
{
  return create_data(ea, calc_dflags(FF_YWORD, force), length, BADNODE);
}

inline bool idaapi create_zword(ea_t ea, asize_t length, bool force=false)
{
  return create_data(ea, calc_dflags(FF_ZWORD, force), length, BADNODE);
}

inline bool idaapi create_tbyte(ea_t ea, asize_t length, bool force=false)
{
  return create_data(ea, calc_dflags(FF_TBYTE, force), length, BADNODE);
}

inline bool idaapi create_float(ea_t ea, asize_t length, bool force=false)
{
  return create_data(ea, calc_dflags(FF_FLOAT, force), length, BADNODE);
}

inline bool idaapi create_double(ea_t ea, asize_t length, bool force=false)
{
  return create_data(ea, calc_dflags(FF_DOUBLE, force), length, BADNODE);
}

inline bool idaapi create_packed_real(ea_t ea, asize_t length, bool force=false)
{
  return create_data(ea, calc_dflags(FF_PACKREAL, force), length, BADNODE);
}

inline bool idaapi create_struct(ea_t ea, asize_t length, tid_t tid, bool force=false)
{
  return create_data(ea, calc_dflags(FF_STRUCT, force), length, tid);
}

inline bool idaapi create_custdata(ea_t ea, asize_t length, int dtid, int fid, bool force=false)
{
  return create_data(ea, calc_dflags(FF_CUSTOM, force), length, dtid|(fid<<16));
}
 

 
idaman bool ida_export create_align(ea_t ea, asize_t length, int alignment);

 
idaman int  ida_export calc_min_align(asize_t length);
 

 
idaman int  ida_export calc_max_align(ea_t endea);

 
idaman int ida_export calc_def_align(ea_t ea, int mina, int maxa);
 

 
idaman bool ida_export create_16bit_data(ea_t ea, asize_t length);
 

 
idaman bool ida_export create_32bit_data(ea_t ea, asize_t length);
 



#define ALOPT_IGNHEADS 0x01 
#define ALOPT_IGNPRINT 0x02 
#define ALOPT_IGNCLT   0x04 
#define ALOPT_MAX4K    0x08 
#define ALOPT_ONLYTERM 0x10 
#define ALOPT_APPEND   0x20 


 
idaman size_t ida_export get_max_strlit_length(
        ea_t ea,
        int32 strtype,
        int options = 0);

#define STRCONV_ESCAPE   0x00000001 
#define STRCONV_REPLCHAR 0x00000002 
#define STRCONV_INCLLEN  0x00000004 

 
idaman ssize_t ida_export get_strlit_contents(
        qstring *utf8,
        ea_t ea,
        size_t len,
        int32 type,
        size_t *maxcps = nullptr,
        int flags = 0);
 

 
idaman bool ida_export create_strlit(ea_t start, size_t len, int32 strtype);
 
 
 
//-------------------------------------------------------------------------
#define PSTF_TNORM    0x00 
#define PSTF_TBRIEF   0x01 
#define PSTF_TINLIN   0x02 
#define PSTF_TMASK    0x03 
#define PSTF_HOTKEY   0x04 
#define PSTF_ENC      0x08 
#define PSTF_ONLY_ENC 0x0B 
#define PSTF_ATTRIB   0x10 
 

 
idaman bool ida_export print_strlit_type(
        qstring *out,
        int32 strtype,
        qstring *out_tooltip = nullptr,
        int flags = 0);
 

 
idaman opinfo_t *ida_export get_opinfo(
        opinfo_t *buf,
        ea_t ea,
        int n,
        flags64_t flags);
 

 
idaman bool ida_export set_opinfo(
        ea_t ea,
        int n,
        flags64_t flag,
        const opinfo_t *ti,
        bool suppress_events=false);
 

 
idaman asize_t ida_export get_data_elsize(ea_t ea, flags64_t F, const opinfo_t *ti=nullptr);
 

inline asize_t get_full_data_elsize(ea_t ea, flags64_t F, const opinfo_t *ti=nullptr)
{
  asize_t nbytes = get_data_elsize(ea, F, ti);
  return nbytes * bytesize(ea);
}
 

 
idaman int ida_export is_varsize_item(
        ea_t ea,
        flags64_t F,
        const opinfo_t *ti=nullptr,
        asize_t *itemsize=nullptr);
 

 
idaman asize_t ida_export get_possible_item_varsize(
        ea_t ea,
        const tinfo_t &tif);
 

 
idaman bool ida_export can_define_item(ea_t ea, asize_t length, flags64_t flags);

 
//-------------------------------------------------------------------------
#define MS_CODE 0xF0000000             
#define FF_FUNC 0x10000000             
//              0x20000000             // not used
#define FF_IMMD 0x40000000             
#define FF_JUMP 0x80000000             


 
inline THREAD_SAFE bool idaapi has_immd(flags64_t F)      { return is_code(F) && (F & FF_IMMD) != 0; }
 

 
inline THREAD_SAFE bool idaapi is_func(flags64_t F)      { return is_code(F) && (F & FF_FUNC) != 0; }
inline             bool idaapi is_func_ea(ea_t ea)       { return is_func(get_flags32(ea)); }
 

 
idaman bool ida_export set_immd(ea_t ea);
 

 
//-----------------------------------------------------------------------
// Custom data type and format definitions
//-----------------------------------------------------------------------

struct data_type_t
{
  int cbsize;                           
  void *ud;                             
  int props;                            
#define DTP_NODUP 0x0001                
  const char *name;                     
  const char *menu_name;                
  const char *hotkey;                   
  const char *asm_keyword;              
  asize_t value_size;                   

  bool is_present_in_menus() const { return menu_name != nullptr && asm_keyword != nullptr; }

  bool (idaapi *may_create_at)(
        void *ud,
        ea_t ea,
        size_t nbytes);

  asize_t (idaapi *calc_item_size)(
        void *ud,
        ea_t ea,
        asize_t maxsize);
 
#ifndef SWIG
  DECLARE_COMPARISONS(data_type_t);
#endif
};

struct data_format_t
{
  int32 cbsize;             
  void *ud;                 
  int props;                
  const char *name;         
  const char *menu_name;    
  const char *hotkey;       
  asize_t value_size;       
  int32 text_width;         

  bool is_present_in_menus() const { return menu_name != nullptr; }

  bool (idaapi *print)(
        void *ud,
        qstring *out,
        const void *value,
        asize_t size,
        ea_t current_ea,
        int operand_num,
        int dtid);

  bool (idaapi *scan)(
        void *ud,
        bytevec_t *value,
        const char *input,
        ea_t current_ea,
        int operand_num,
        qstring *errstr);

  void (idaapi *analyze)(
        void *ud,
        ea_t current_ea,
        int operand_num);
 
#ifndef SWIG
  DECLARE_COMPARISONS(data_format_t);
#endif
};
 

 
idaman int ida_export register_custom_data_type(const data_type_t *dtinfo);
 

 
idaman bool ida_export unregister_custom_data_type(int dtid);
 

 
idaman int ida_export register_custom_data_format(const data_format_t *dtform);
 

 
idaman bool ida_export unregister_custom_data_format(int dfid);
 

 
idaman const data_type_t *ida_export get_custom_data_type(int dtid);
 

 
idaman const data_format_t *ida_export get_custom_data_format(int dfid);
 

 
idaman bool ida_export attach_custom_data_format(int dtid, int dfid);
 

 
idaman bool ida_export detach_custom_data_format(int dtid, int dfid);
 

 
idaman bool ida_export is_attached_custom_data_format(int dtid, int dfid);

 
idaman int ida_export get_custom_data_types(
        intvec_t *out,
        asize_t min_size=0,
        asize_t max_size=BADADDR);
 

 
idaman int ida_export get_custom_data_formats(intvec_t *out, int dtid);
 

 
idaman int ida_export find_custom_data_type(const char *name);
 

 
idaman int ida_export find_custom_data_format(const char *name);
 
 
//--------------------------------------------------------------------------
//      I N D E N T E D   C O M M E N T S
//--------------------------------------------------------------------------

 
idaman bool ida_export set_cmt(ea_t ea, const char *comm, bool rptble);
 

 
idaman ssize_t ida_export get_cmt(qstring *buf, ea_t ea, bool rptble);
 

 
idaman bool ida_export append_cmt(ea_t ea, const char *str, bool rptble);
 
 
//--------------------------------------------------------------------
//      P R E D E F I N E D   C O M M E N T S
//--------------------------------------------------------------------

 
idaman ssize_t ida_export get_predef_insn_cmt(
        qstring *buf,
        const insn_t &ins);
 
 
//--------------------------------------------------------------------------
//      S E A R C H   F U N C T I O N S
//--------------------------------------------------------------------------
 
idaman ea_t ida_export find_byte(ea_t sEA, asize_t size, uchar value, int bin_search_flags);
 

 
idaman ea_t ida_export find_byter(ea_t sEA, asize_t size, uchar value, int bin_search_flags);
 
 
//-------------------------------------------------------------------------
struct compiled_binpat_t // compiled binary pattern compiled_binpat_t
{
  bytevec_t bytes;
  bytevec_t mask;
  rangevec_t strlits; // range of string literals, in _bytes_ ranges (not CPs)
  int encidx;
 
  compiled_binpat_t() : encidx(-1) {}
  bool all_bytes_defined() const { return mask.empty(); }
  void qclear() { bytes.qclear(); mask.qclear(); strlits.qclear(); encidx = -1; }
 
  bool operator==(const compiled_binpat_t &r) const
  {
    return bytes == r.bytes
        && mask == r.mask
        && strlits == r.strlits
        && encidx == r.encidx;
  }
  bool operator!=(const compiled_binpat_t &r) const { return !(*this == r); }
};
DECLARE_TYPE_AS_MOVABLE(compiled_binpat_t);
typedef qvector<compiled_binpat_t> compiled_binpat_vec_t;
 
#define PBSENC_DEF1BPU  0 
#define PBSENC_ALL     -1 

//          true  otherwise
idaman bool ida_export parse_binpat_str(
        compiled_binpat_vec_t *out,
        ea_t ea,
        const char *in,
        int radix,
        int strlits_encoding=PBSENC_DEF1BPU,
        qstring *errbuf=nullptr);
 

 
idaman ea_t ida_export bin_search(
        ea_t start_ea,
        ea_t end_ea,
        const compiled_binpat_vec_t &data,
        int flags,
        size_t *out_matched_idx=nullptr);
 
inline ea_t bin_search(
        ea_t start_ea,
        ea_t end_ea,
        const uchar *image,
        const uchar *mask,
        size_t len,
        int flags)
{
  compiled_binpat_vec_t bbv;
  compiled_binpat_t &bv = bbv.push_back();
  bv.bytes.append(image, len);
  if ( mask != nullptr )
    bv.mask.append(mask, len);
  return bin_search(start_ea, end_ea, bbv, flags);
}

#define BIN_SEARCH_CASE         0x01 
#define BIN_SEARCH_NOCASE       0x00 
#define BIN_SEARCH_NOBREAK      0x02 
#define BIN_SEARCH_INITED       0x04 
#define BIN_SEARCH_NOSHOW       0x08 
#define BIN_SEARCH_FORWARD      0x00 
#define BIN_SEARCH_BACKWARD     0x10 
#define BIN_SEARCH_BITMASK      0x20 
 

 
inline ea_t idaapi next_inited(ea_t ea, ea_t maxea)
{
  if ( ea >= maxea )
    return BADADDR;
  ++ea;
  return find_byte(ea, maxea-ea, 0, BIN_SEARCH_INITED);
}

 
inline ea_t idaapi prev_inited(ea_t ea, ea_t minea)
{
  if ( ea <= minea )
    return BADADDR;
  --ea;
  return find_byter(minea, ea-minea, 0, BIN_SEARCH_INITED);
}

 
idaman bool ida_export equal_bytes(
        ea_t ea,
        const uchar *image,
        const uchar *mask,
        size_t len,
        int bin_search_flags);

#define SKIP_FF_MASK  ((const uchar *)0xFF)
 
// Compare two bytes. This helper function is used for binary search.
inline bool bytes_match_for_bin_search(
        uchar c1,
        uchar c2,
        const uchar *mask,
        int i,
        int bin_search_flags)
{
  if ( (bin_search_flags & BIN_SEARCH_CASE) == 0 )
  {
    c1 = qtoupper(c1);
    c2 = qtoupper(c2);
  }
  if ( mask != nullptr )
  {
    if ( (bin_search_flags & BIN_SEARCH_BITMASK) != 0 )
      return ((c1 ^ c2) & mask[i]) == 0; // are bytes equal with mask applied?
    if ( mask == SKIP_FF_MASK )
    {
      if ( c2 == 0xFF )
        return true;
    }
    else if ( mask[i] == 0 )
    {
      return true;
    }
  }
  return c1 == c2;
}
 
idaman ea_t ida_export find_binary(
        ea_t startea,
        ea_t endea,
        const char *ubinstr,
        int radix,
        int sflag,
        int strlits_encoding=0);
 
//------------------------------------------------------------------------
//      H I D D E N   R A N G E S
//------------------------------------------------------------------------



class hidden_range_info_t : public range_t
{
public:
  const char *get_description() const { return description_.empty() ? nullptr : description_.c_str(); }
  void set_description(const char *v) { description_ = v; updated_ |= HRI_DESCRIPTION; }

  const char *get_header() const { return header_.empty() ? nullptr : header_.c_str(); }
  void set_header(const char *v) { header_ = v; updated_ |= HRI_HEADER; }

  const char *get_footer() const { return footer_.empty() ? nullptr : footer_.c_str(); }
  void set_footer(const char *v) { footer_ = v; updated_ |= HRI_FOOTER; }

  bool get_visible() const { return visible_; }
  void set_visible(bool v) { visible_ = v; updated_ |= HRI_VISIBLE; }

  bgcolor_t get_color() const { return color_; }
  void set_color(bgcolor_t v) { color_ = v; updated_ |= HRI_COLOR; }

  bool is_valid() const { return !empty(); }
 
private:
  uint32 updated_ = 0;          
  qstring description_;          
  qstring header_;               
  qstring footer_;               
  bool visible_ = false;         
  bgcolor_t color_ = DEFCOLOR;   
 
  friend struct kdata_t;

  enum
  {
    HRI_DESCRIPTION = 0x01,  
    HRI_HEADER      = 0x02,  
    HRI_FOOTER      = 0x04,  
    HRI_VISIBLE     = 0x08,  
    HRI_COLOR       = 0x10,  
    HRI_ALL         = 0x1F,  
  };
};

 

 
idaman bool ida_export get_hidden_range_info(hidden_range_info_t *hri, ea_t ea);
 

 
idaman bool ida_export get_hidden_range_info_by_num(hidden_range_info_t *hri, int n);
 

 
idaman bool ida_export update_hidden_range_info(const hidden_range_info_t *hri);
 

 
idaman ea_t ida_export get_first_hidden_range_ea(void);
 

 
idaman ea_t ida_export get_last_hidden_range_ea(void);
 

 
idaman ea_t ida_export get_next_hidden_range_ea(ea_t ea);
 

 
idaman ea_t ida_export get_prev_hidden_range_ea(ea_t ea);
 

 
idaman bool ida_export add_hidden_range(
        ea_t ea1,
        ea_t ea2,
        const char *description,
        const char *header,
        const char *footer,
        bgcolor_t color=DEFCOLOR);
 

 
idaman int ida_export get_hidden_range_qty(void);
 

 
idaman int ida_export get_hidden_range_num(ea_t ea);
 

 
idaman bool ida_export del_hidden_range(ea_t ea);
 
 

 
struct hidden_range_t : public range_t
{
  char *description;    
  char *header;         
  char *footer;         
  bool visible;         
  bgcolor_t color;      
};

idaman DEPRECATED bool ida_export update_hidden_range(const hidden_range_t *ha);

idaman DEPRECATED hidden_range_t *ida_export get_hidden_range(ea_t ea);

idaman DEPRECATED hidden_range_t *ida_export getn_hidden_range(int n);

idaman DEPRECATED hidden_range_t *ida_export get_prev_hidden_range(ea_t ea);

idaman DEPRECATED hidden_range_t *ida_export get_next_hidden_range(ea_t ea);

idaman DEPRECATED hidden_range_t *ida_export get_first_hidden_range(void);

idaman DEPRECATED hidden_range_t *ida_export get_last_hidden_range(void);
 

 
 
//--------------------------------------------------------------------------
#define GET_ITEM_HEAD_BODY        \
  if ( is_tail(get_flags32(ea)) ) \
    ea = prev_not_tail(ea);       \
  return ea;
inline ea_t idaapi get_item_head(ea_t ea) { GET_ITEM_HEAD_BODY }
 
//------------------------------------------------------------------------
//      M E M O R Y   M A P P I N G
//------------------------------------------------------------------------

 

 
idaman bool ida_export add_mapping(ea_t from, ea_t to, asize_t size);
 

 
idaman void ida_export del_mapping(ea_t ea);
 

 
idaman ea_t ida_export use_mapping(ea_t ea);

 
idaman size_t ida_export get_mappings_qty(void);

idaman bool ida_export get_mapping(
        ea_t *from,
        ea_t *to,
        asize_t *size,
        size_t n);
 
 
// byte array to hex string
inline THREAD_SAFE ssize_t get_hex_string(char *buf, size_t bufsize, const uchar *bytes, size_t len)
{
  const char *const start = buf;
  const char *const end   = buf + bufsize;
  for ( size_t i = 0; i < len; i++ )
    buf += ::qsnprintf(buf, end - buf, "%02X", *bytes++);
  return buf - start;
}
 
 
#ifndef IDA_KERNEL_PRIVATE_BYTES_ACCESS    // undefined bit masks so no one can use them directly
#undef MS_VAL
#undef FF_IVL
#undef MS_CLS
#undef FF_CODE
#undef FF_DATA
#undef FF_TAIL
#undef FF_UNK
#undef MS_COMM
#undef FF_COMM
#undef FF_REF
#undef FF_LINE
#undef FF_NAME
#undef FF_LABL
#undef FF_ANYNAME
#undef FF_FLOW
#undef FF_SIGN
#undef FF_BNOT
#undef DT_TYPE
#undef FF_BYTE
#undef FF_WORD
#undef FF_DWORD
#undef FF_QWORD
#undef FF_OWORD
#undef FF_YWORD
#undef FF_ZWORD
#undef FF_FLOAT
#undef FF_DOUBLE
#undef FF_TBYTE
#undef FF_PACKREAL
#undef FF_STRLIT
#undef FF_STRUCT
#undef FF_ALIGN
#undef FF_CUSTOM
#undef MS_CODE
#undef FF_FUNC
#undef FF_IMMD
//#undef FF_JUMP
#undef MS_TAIL
#undef TL_TSFT
#undef TL_TOFF
#undef MAX_TOFF
#endif // !IDA_KERNEL_PRIVATE_BYTES_ACCESS
#endif // BYTES_HPP