ida.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2025 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef _IDA_HPP
#define _IDA_HPP
 
#include <pro.h>
#include <range.hpp>
 
class plugin_t;
struct plugmod_t;

 
//--------------------------------------------------------------------------
enum filetype_t
{
  f_EXE_old,            
  f_COM_old,            
  f_BIN,                
  f_DRV,                
  f_WIN,                
  f_HEX,                
  f_MEX,                
  f_LX,                 
  f_LE,                 
  f_NLM,                
  f_COFF,               
  f_PE,                 
  f_OMF,                
  f_SREC,               
  f_ZIP,                
  f_OMFLIB,             
  f_AR,                 
  f_LOADER,             
  f_ELF,                
  f_W32RUN,             
  f_AOUT,               
  f_PRC,                
  f_EXE,                
  f_COM,                
  f_AIXAR,              
  f_MACHO,              
  f_PSXOBJ,             
  f_MD1IMG,             
};

inline bool is_filetype_like_binary(filetype_t ft)
{ return ft == f_BIN || ft == f_HEX || ft == f_MEX || ft == f_SREC; }
 
//--------------------------------------------------------------------------
 
typedef uchar comp_t;   
typedef uchar cm_t;     
typedef uint32 callcnv_t;
typedef qvector<callcnv_t> callcnvs_t;

struct compiler_info_t
{
  comp_t id = 0;        
  cm_t cm = 0;          
  uchar size_i = 0;     
  uchar size_b = 0;     
  uchar size_e = 0;     
  uchar defalign = 0;   
  uchar size_s = 0;     
  uchar size_l = 0;     
  uchar size_ll = 0;    
  uchar size_ldbl = 0;  
  callcnv_t _new_callcnv = 0; // do not access directly; use get_cc/set_cc
  inline callcnv_t get_cc() const;
  inline void set_cc(callcnv_t cc);
};
 
//--------------------------------------------------------------------------
enum storage_type_t
{
  STT_CUR = -1, 
  STT_VA  = 0,  
  STT_MM  = 1,  
  STT_DBG = 2,  
};

#ifdef __EA64__
#define EA64_ALIGN(n) uint32 n;
#else
#define EA64_ALIGN(n)
#endif
 
//--------------------------------------------------------------------------
#define IDAINFO_TAG_SIZE 3
#define IDAINFO_PROCNAME_SIZE 16
#define IDAINFO_STRLIT_PREF_SIZE 16
struct idainfo
{
  char tag[IDAINFO_TAG_SIZE];           
  char zero;                            
  ushort version;                       
  char procname[IDAINFO_PROCNAME_SIZE]; 
 
  ushort s_genflags;                    
#define INFFL_AUTO       0x01           
#define INFFL_ALLASM     0x02           
#define INFFL_LOADIDC    0x04           
#define INFFL_NOUSER     0x08           
#define INFFL_READONLY   0x10           
#define INFFL_CHKOPS     0x20           
#define INFFL_NMOPS      0x40           
#define INFFL_GRAPH_VIEW 0x80           
 
  uint32 lflags;                        
#define LFLG_PC_FPP     0x00000001      
#define LFLG_PC_FLAT    0x00000002      
#define LFLG_64BIT      0x00000004      
#define LFLG_IS_DLL     0x00000008      
#define LFLG_FLAT_OFF32 0x00000010      
#define LFLG_MSF        0x00000020      
#define LFLG_WIDE_HBF   0x00000040      
#define LFLG_DBG_NOPATH 0x00000080      
#define LFLG_SNAPSHOT   0x00000100      
#define LFLG_PACK       0x00000200      
#define LFLG_COMPRESS   0x00000400      
#define LFLG_KERNMODE   0x00000800      
#define LFLG_ILP32      0x00001000      

#define IDB_UNPACKED   0                
#define IDB_PACKED     1                
#define IDB_COMPRESSED 2                
 
  uint32 database_change_count;         
 
  ushort filetype;                      
 
  ushort ostype;                        
 
  ushort apptype;                       
 
  uchar asmtype;                        
 
  uchar specsegs;                       
 
  uint32 af;                            
#define AF_CODE         0x00000001      
#define AF_MARKCODE     0x00000002      
#define AF_JUMPTBL      0x00000004      
#define AF_PURDAT       0x00000008      
#define AF_USED         0x00000010      
#define AF_UNK          0x00000020      
 
#define AF_PROCPTR      0x00000040      
#define AF_PROC         0x00000080      
#define AF_FTAIL        0x00000100      
#define AF_LVAR         0x00000200      
#define AF_STKARG       0x00000400      
#define AF_REGARG       0x00000800      
#define AF_TRACE        0x00001000      
#define AF_VERSP        0x00002000      
#define AF_ANORET       0x00004000      
#define AF_MEMFUNC      0x00008000      
#define AF_TRFUNC       0x00010000      
 
#define AF_STRLIT       0x00020000      
#define AF_CHKUNI       0x00040000      
#define AF_FIXUP        0x00080000      
#define AF_DREFOFF      0x00100000      
#define AF_IMMOFF       0x00200000      
#define AF_DATOFF       0x00400000      
 
#define AF_FLIRT        0x00800000      
#define AF_SIGCMT       0x01000000      
#define AF_SIGMLT       0x02000000      
#define AF_HFLIRT       0x04000000      
 
#define AF_JFUNC        0x08000000      
#define AF_NULLSUB      0x10000000      
 
#define AF_DODATA       0x20000000      
#define AF_DOCODE       0x40000000      
#define AF_FINAL        0x80000000      
  uint32 af2;                           
#define AF2_DOEH        0x00000001      
#define AF2_DORTTI      0x00000002      
#define AF2_MACRO       0x00000004      
#define AF2_MERGESTR    0x00000008      
  uval_t baseaddr;                      
  sel_t start_ss;                       
  sel_t start_cs;                       
  ea_t start_ip;                        
  ea_t start_ea;                        
  ea_t start_sp;                        
  ea_t main;                            
  ea_t min_ea;                          
  ea_t max_ea;                          
  ea_t omin_ea;                         
  ea_t omax_ea;                         
 
  ea_t lowoff;                          
  ea_t highoff;                         
 
  uval_t maxref;                        
 
  range_t privrange;                    
  sval_t netdelta;                      

  uchar xrefnum;                        
  uchar type_xrefnum;                   
  uchar refcmtnum;                      
  uchar s_xrefflag;                     
#define SW_SEGXRF       0x01            
#define SW_XRFMRK       0x02            
#define SW_XRFFNC       0x04            
#define SW_XRFVAL       0x08            

  ushort max_autoname_len;              
  char nametype;                        
#define NM_REL_OFF      0
#define NM_PTR_OFF      1
#define NM_NAM_OFF      2
#define NM_REL_EA       3
#define NM_PTR_EA       4
#define NM_NAM_EA       5
#define NM_EA           6
#define NM_EA4          7
#define NM_EA8          8
#define NM_SHORT        9
#define NM_SERIAL       10
 
  uint32 short_demnames;                
  uint32 long_demnames;                 
  uchar demnames;                       
#define DEMNAM_MASK  3                  
#define DEMNAM_CMNT  0                  
#define DEMNAM_NAME  1                  
#define DEMNAM_NONE  2                  
#define DEMNAM_GCC3  4                  
#define DEMNAM_FIRST 8                  
 
  uchar listnames;                      
#define LN_NORMAL       0x01            
#define LN_PUBLIC       0x02            
#define LN_AUTO         0x04            
#define LN_WEAK         0x08            

  uchar indent;                         
  uchar cmt_indent;                     
  ushort margin;                        
  ushort lenxref;                       
  uint32 outflags;                      
#define OFLG_SHOW_VOID    0x002         
#define OFLG_SHOW_AUTO    0x004         
#define OFLG_GEN_NULL     0x010         
#define OFLG_SHOW_PREF    0x020         
#define OFLG_PREF_SEG     0x040         
#define OFLG_LZERO        0x080         
#define OFLG_GEN_ORG      0x100         
#define OFLG_GEN_ASSUME   0x200         
#define OFLG_GEN_TRYBLKS  0x400         
 
  uchar s_cmtflg;                       
#define SCF_RPTCMT       0x01            
#define SCF_ALLCMT       0x02            
#define SCF_NOCMT        0x04            
#define SCF_LINNUM       0x08            
#define SCF_TESTMODE     0x10            
#define SCF_SHHID_ITEM   0x20            
#define SCF_SHHID_FUNC   0x40            
#define SCF_SHHID_SEGM   0x80            
 
  uchar s_limiter;                      
#define LMT_THIN        0x01            
#define LMT_THICK       0x02            
#define LMT_EMPTY       0x04            
 
  short bin_prefix_size;                
  uchar s_prefflag;                     
#define PREF_SEGADR     0x01            
#define PREF_FNCOFF     0x02            
#define PREF_STACK      0x04            
#define PREF_PFXTRUNC   0x08            

  uchar strlit_flags;                   
#define STRF_GEN        0x01            
#define STRF_AUTO       0x02            
#define STRF_SERIAL     0x04            
#define STRF_UNICODE    0x08            
#define STRF_COMMENT    0x10            
#define STRF_SAVECASE   0x20            
  uchar strlit_break;                   
  char strlit_zeroes;                   
  int32 strtype;                        
  char strlit_pref[IDAINFO_STRLIT_PREF_SIZE]; 
  uval_t strlit_sernum;                 
 
  // DATA ITEMS
  uval_t datatypes;                     

  compiler_info_t cc;                   
  uint32 abibits;                       

#define ABI_8ALIGN4       0x00000001    
#define ABI_PACK_STKARGS  0x00000002    
#define ABI_BIGARG_ALIGN  0x00000004    
#define ABI_STACK_LDBL    0x00000008    
#define ABI_STACK_VARARGS 0x00000010    
#define ABI_HARD_FLOAT    0x00000020    
#define ABI_SET_BY_USER   0x00000040    
#define ABI_GCC_LAYOUT    0x00000080    
#define ABI_MAP_STKARGS   0x00000100    
#define ABI_HUGEARG_ALIGN 0x00000200    
 
  uint32 appcall_options;               
  EA64_ALIGN(padding);
 
};
 
enum inftag_t
{
  INF_VERSION               =  0,
  INF_PROCNAME              =  1,
  INF_GENFLAGS              =  2,
  INF_LFLAGS                =  3,
  INF_DATABASE_CHANGE_COUNT =  4,
  INF_FILETYPE              =  5,
  INF_OSTYPE                =  6,
  INF_APPTYPE               =  7,
  INF_ASMTYPE               =  8,
  INF_SPECSEGS              =  9,
  INF_AF                    = 10,
  INF_AF2                   = 11,
  INF_BASEADDR              = 12,
  INF_START_SS              = 13,
  INF_START_CS              = 14,
  INF_START_IP              = 15,
  INF_START_EA              = 16,
  INF_START_SP              = 17,
  INF_MAIN                  = 18,
  INF_MIN_EA                = 19,
  INF_MAX_EA                = 20,
  INF_OMIN_EA               = 21,
  INF_OMAX_EA               = 22,
  INF_LOWOFF                = 23,
  INF_HIGHOFF               = 24,
  INF_MAXREF                = 25,
  INF_PRIVRANGE             = 26,
  INF_PRIVRANGE_START_EA    = 27,
  INF_PRIVRANGE_END_EA      = 28,
  INF_NETDELTA              = 29,
  INF_XREFNUM               = 30,
  INF_TYPE_XREFNUM          = 31,
  INF_REFCMTNUM             = 32,
  INF_XREFFLAG              = 33,
  INF_MAX_AUTONAME_LEN      = 34,
  INF_NAMETYPE              = 35,
  INF_SHORT_DEMNAMES        = 36,
  INF_LONG_DEMNAMES         = 37,
  INF_DEMNAMES              = 38,
  INF_LISTNAMES             = 39,
  INF_INDENT                = 40,
  INF_CMT_INDENT            = 41,
  INF_MARGIN                = 42,
  INF_LENXREF               = 43,
  INF_OUTFLAGS              = 44,
  INF_CMTFLG                = 45,
  INF_LIMITER               = 46,
  INF_BIN_PREFIX_SIZE       = 47,
  INF_PREFFLAG              = 48,
  INF_STRLIT_FLAGS          = 49,
  INF_STRLIT_BREAK          = 50,
  INF_STRLIT_ZEROES         = 51,
  INF_STRTYPE               = 52,
  INF_STRLIT_PREF           = 53,
  INF_STRLIT_SERNUM         = 54,
  INF_DATATYPES             = 55,
  INF_OBSOLETE_CC           = 56,
  INF_CC_ID                 = 57,
  INF_CC_CM                 = 58,
  INF_CC_SIZE_I             = 59,
  INF_CC_SIZE_B             = 60,
  INF_CC_SIZE_E             = 61,
  INF_CC_DEFALIGN           = 62,
  INF_CC_SIZE_S             = 63,
  INF_CC_SIZE_L             = 64,
  INF_CC_SIZE_LL            = 65,
  INF_CC_SIZE_LDBL          = 66,
  INF_ABIBITS               = 67,
  INF_APPCALL_OPTIONS       = 68,
 
  // root node fields
  INF_FILE_FORMAT_NAME      = 69, 
  INF_GROUPS                = 70, 
  INF_H_PATH                = 71, 
  INF_C_MACROS              = 72, 
  INF_INCLUDE               = 73, 
  INF_DUALOP_GRAPH          = 74, 
  INF_DUALOP_TEXT           = 75, 
  INF_MD5                   = 76, 
  INF_IDA_VERSION           = 77, 
  INF_STR_ENCODINGS         = 78, 
  INF_DBG_BINPATHS          = 79, 
  INF_SHA256                = 80, 
  INF_ABINAME               = 81, 
  INF_ARCHIVE_PATH          = 82, 
  INF_PROBLEMS              = 83, 
 
  INF_SELECTORS             = 84, 
  INF_NOTEPAD               = 85, 
  INF_SRCDBG_PATHS          = 86, 
  INF_SRCDBG_UNDESIRED      = 87, 
  INF_INITIAL_VERSION       = 88, 
  INF_CTIME                 = 89, 
  INF_ELAPSED               = 90, 
  INF_NOPENS                = 91, 
  INF_CRC32                 = 92, 
  INF_IMAGEBASE             = 93, 
  INF_IDSNODE               = 94, 
  INF_FSIZE                 = 95, 
  INF_OUTFILEENC            = 96, 
  INF_INPUT_FILE_PATH       = 97,
 
  // more inf fields
  INF_COMPILER_INFO         = 98,
  INF_CALLCNV               = 99,
  INF_LAST = 100,
};

idaman size_t ida_export getinf(inftag_t tag);

idaman ssize_t ida_export getinf_buf(inftag_t tag, void *buf, size_t bufsize);

idaman ssize_t ida_export getinf_str(qstring *buf, inftag_t tag);

idaman bool ida_export getinf_flag(inftag_t tag, uint32 flag);

idaman bool ida_export setinf(inftag_t tag, ssize_t value);

idaman bool ida_export setinf_buf(inftag_t tag, const void *buf, size_t bufsize=0);

idaman bool ida_export setinf_flag(inftag_t tag, uint32 flag, bool value=true);

idaman bool ida_export delinf(inftag_t tag);
 
 
// <INF_ACCESSORS>
inline ushort inf_get_version() { return ushort(getinf(INF_VERSION)); }
inline bool inf_set_version(ushort _v) { return setinf(INF_VERSION, ssize_t(_v)); }
 
inline ushort inf_get_genflags() { return ushort(getinf(INF_GENFLAGS)); }
inline bool inf_set_genflags(ushort _v) { return setinf(INF_GENFLAGS, ssize_t(_v)); }
inline bool inf_is_auto_enabled(void) { return getinf_flag(INF_GENFLAGS, INFFL_AUTO); }
inline bool inf_set_auto_enabled(bool _v=true) { return setinf_flag(INF_GENFLAGS, INFFL_AUTO, _v); }
inline bool inf_use_allasm(void) { return getinf_flag(INF_GENFLAGS, INFFL_ALLASM); }
inline bool inf_set_use_allasm(bool _v=true) { return setinf_flag(INF_GENFLAGS, INFFL_ALLASM, _v); }
inline bool inf_loading_idc(void) { return getinf_flag(INF_GENFLAGS, INFFL_LOADIDC); }
inline bool inf_set_loading_idc(bool _v=true) { return setinf_flag(INF_GENFLAGS, INFFL_LOADIDC, _v); }
inline bool inf_no_store_user_info(void) { return getinf_flag(INF_GENFLAGS, INFFL_NOUSER); }
inline bool inf_set_no_store_user_info(bool _v=true) { return setinf_flag(INF_GENFLAGS, INFFL_NOUSER, _v); }
inline bool inf_readonly_idb(void) { return getinf_flag(INF_GENFLAGS, INFFL_READONLY); }
inline bool inf_set_readonly_idb(bool _v=true) { return setinf_flag(INF_GENFLAGS, INFFL_READONLY, _v); }
inline bool inf_check_manual_ops(void) { return getinf_flag(INF_GENFLAGS, INFFL_CHKOPS); }
inline bool inf_set_check_manual_ops(bool _v=true) { return setinf_flag(INF_GENFLAGS, INFFL_CHKOPS, _v); }
inline bool inf_allow_non_matched_ops(void) { return getinf_flag(INF_GENFLAGS, INFFL_NMOPS); }
inline bool inf_set_allow_non_matched_ops(bool _v=true) { return setinf_flag(INF_GENFLAGS, INFFL_NMOPS, _v); }
inline bool inf_is_graph_view(void) { return getinf_flag(INF_GENFLAGS, INFFL_GRAPH_VIEW); }
inline bool inf_set_graph_view(bool _v=true) { return setinf_flag(INF_GENFLAGS, INFFL_GRAPH_VIEW, _v); }
 
inline uint32 inf_get_lflags() { return uint32(getinf(INF_LFLAGS)); }
inline bool inf_set_lflags(uint32 _v) { return setinf(INF_LFLAGS, ssize_t(_v)); }
inline bool inf_decode_fpp(void) { return getinf_flag(INF_LFLAGS, LFLG_PC_FPP); }
inline bool inf_set_decode_fpp(bool _v=true) { return setinf_flag(INF_LFLAGS, LFLG_PC_FPP, _v); }
// unfortunately the name inf_is_32bit was used in the past to mean inf_is_32bit_or_higher.
// it was misleading, this is why we have more explicit names now.
inline bool inf_is_32bit_or_higher(void) { return getinf_flag(INF_LFLAGS, LFLG_PC_FLAT); }
inline bool inf_is_32bit_exactly(void) { return (getinf(INF_LFLAGS) & (LFLG_PC_FLAT|LFLG_64BIT)) == LFLG_PC_FLAT; }
inline bool inf_set_32bit(bool _v=true) { return setinf_flag(INF_LFLAGS, LFLG_PC_FLAT, _v); }
inline bool inf_is_16bit(void) { return !inf_is_32bit_or_higher(); }
inline bool inf_is_64bit(void) { return getinf_flag(INF_LFLAGS, LFLG_64BIT); }
inline bool inf_set_64bit(bool _v=true) { return setinf_flag(INF_LFLAGS, LFLG_64BIT, _v); }
inline bool inf_is_ilp32() { return (getinf(INF_LFLAGS) & (LFLG_PC_FLAT|LFLG_64BIT|LFLG_ILP32)) == (LFLG_PC_FLAT|LFLG_ILP32); }
inline bool inf_set_ilp32(bool _v=true) { return setinf_flag(INF_LFLAGS, LFLG_ILP32, _v); }
inline bool inf_is_dll(void) { return getinf_flag(INF_LFLAGS, LFLG_IS_DLL); }
inline bool inf_set_dll(bool _v=true) { return setinf_flag(INF_LFLAGS, LFLG_IS_DLL, _v); }
inline bool inf_is_flat_off32(void) { return getinf_flag(INF_LFLAGS, LFLG_FLAT_OFF32); }
inline bool inf_set_flat_off32(bool _v=true) { return setinf_flag(INF_LFLAGS, LFLG_FLAT_OFF32, _v); }
inline bool inf_is_be(void) { return getinf_flag(INF_LFLAGS, LFLG_MSF); }
inline bool inf_set_be(bool _v=true) { return setinf_flag(INF_LFLAGS, LFLG_MSF, _v); }
inline bool inf_is_wide_high_byte_first(void) { return getinf_flag(INF_LFLAGS, LFLG_WIDE_HBF); }
inline bool inf_set_wide_high_byte_first(bool _v=true) { return setinf_flag(INF_LFLAGS, LFLG_WIDE_HBF, _v); }
inline bool inf_dbg_no_store_path(void) { return getinf_flag(INF_LFLAGS, LFLG_DBG_NOPATH); }
inline bool inf_set_dbg_no_store_path(bool _v=true) { return setinf_flag(INF_LFLAGS, LFLG_DBG_NOPATH, _v); }
inline bool inf_is_snapshot(void) { return getinf_flag(INF_LFLAGS, LFLG_SNAPSHOT); }
inline bool inf_set_snapshot(bool _v=true) { return setinf_flag(INF_LFLAGS, LFLG_SNAPSHOT, _v); }
inline bool inf_pack_idb(void) { return getinf_flag(INF_LFLAGS, LFLG_PACK); }
inline bool inf_set_pack_idb(bool _v=true) { return setinf_flag(INF_LFLAGS, LFLG_PACK, _v); }
inline bool inf_compress_idb(void) { return getinf_flag(INF_LFLAGS, LFLG_COMPRESS); }
inline bool inf_set_compress_idb(bool _v=true) { return setinf_flag(INF_LFLAGS, LFLG_COMPRESS, _v); }
inline bool inf_is_kernel_mode(void) { return getinf_flag(INF_LFLAGS, LFLG_KERNMODE); }
inline bool inf_set_kernel_mode(bool _v=true) { return setinf_flag(INF_LFLAGS, LFLG_KERNMODE, _v); }
 
inline uint inf_get_app_bitness(void) // return 16, 32, or 64
{
#ifdef __EA64__
  uint32 f = getinf(INF_LFLAGS) & (LFLG_PC_FLAT|LFLG_64BIT);
  return f == 0 ? 16 : f == LFLG_PC_FLAT ? 32 : 64;
#else
  return inf_is_32bit_or_higher() ? 32 : 16;
#endif
}
 
inline void inf_set_app_bitness(uint bitness) // bitness: 16, 32, or 64
{
  switch ( bitness )
  {
#ifdef __EA64__
    case 64: inf_set_64bit(); break;
#endif
    case 32: inf_set_64bit(false); inf_set_32bit(); break;
    case 16: inf_set_32bit(false); break;
    default: INTERR(2781);
  }
}
 
inline uint32 inf_get_database_change_count() { return uint32(getinf(INF_DATABASE_CHANGE_COUNT)); }
inline bool inf_set_database_change_count(uint32 _v) { return setinf(INF_DATABASE_CHANGE_COUNT, ssize_t(_v)); }
 
inline filetype_t inf_get_filetype() { return filetype_t(getinf(INF_FILETYPE)); }
inline bool inf_set_filetype(filetype_t _v) { return setinf(INF_FILETYPE, ssize_t(_v)); }
 
inline ushort inf_get_ostype() { return ushort(getinf(INF_OSTYPE)); }
inline bool inf_set_ostype(ushort _v) { return setinf(INF_OSTYPE, ssize_t(_v)); }
 
inline ushort inf_get_apptype() { return ushort(getinf(INF_APPTYPE)); }
inline bool inf_set_apptype(ushort _v) { return setinf(INF_APPTYPE, ssize_t(_v)); }
 
inline uchar inf_get_asmtype() { return uchar(getinf(INF_ASMTYPE)); }
inline bool inf_set_asmtype(uchar _v) { return setinf(INF_ASMTYPE, ssize_t(_v)); }
 
inline uchar inf_get_specsegs() { return uchar(getinf(INF_SPECSEGS)); }
inline bool inf_set_specsegs(uchar _v) { return setinf(INF_SPECSEGS, ssize_t(_v)); }
 
inline uint32 inf_get_af() { return uint32(getinf(INF_AF)); }
inline bool inf_set_af(uint32 _v) { return setinf(INF_AF, ssize_t(_v)); }
inline bool inf_trace_flow(void) { return getinf_flag(INF_AF, AF_CODE); }
inline bool inf_set_trace_flow(bool _v=true) { return setinf_flag(INF_AF, AF_CODE, _v); }
inline bool inf_mark_code(void) { return getinf_flag(INF_AF, AF_MARKCODE); }
inline bool inf_set_mark_code(bool _v=true) { return setinf_flag(INF_AF, AF_MARKCODE, _v); }
inline bool inf_create_jump_tables(void) { return getinf_flag(INF_AF, AF_JUMPTBL); }
inline bool inf_set_create_jump_tables(bool _v=true) { return setinf_flag(INF_AF, AF_JUMPTBL, _v); }
inline bool inf_noflow_to_data(void) { return getinf_flag(INF_AF, AF_PURDAT); }
inline bool inf_set_noflow_to_data(bool _v=true) { return setinf_flag(INF_AF, AF_PURDAT, _v); }
inline bool inf_create_all_xrefs(void) { return getinf_flag(INF_AF, AF_USED); }
inline bool inf_set_create_all_xrefs(bool _v=true) { return setinf_flag(INF_AF, AF_USED, _v); }
inline bool inf_del_no_xref_insns(void) { return getinf_flag(INF_AF, AF_UNK); }
inline bool inf_set_del_no_xref_insns(bool _v=true) { return setinf_flag(INF_AF, AF_UNK, _v); }
inline bool inf_create_func_from_ptr(void) { return getinf_flag(INF_AF, AF_PROCPTR); }
inline bool inf_set_create_func_from_ptr(bool _v=true) { return setinf_flag(INF_AF, AF_PROCPTR, _v); }
inline bool inf_create_func_from_call(void) { return getinf_flag(INF_AF, AF_PROC); }
inline bool inf_set_create_func_from_call(bool _v=true) { return setinf_flag(INF_AF, AF_PROC, _v); }
inline bool inf_create_func_tails(void) { return getinf_flag(INF_AF, AF_FTAIL); }
inline bool inf_set_create_func_tails(bool _v=true) { return setinf_flag(INF_AF, AF_FTAIL, _v); }
inline bool inf_should_create_stkvars(void) { return getinf_flag(INF_AF, AF_LVAR); }
inline bool inf_set_should_create_stkvars(bool _v=true) { return setinf_flag(INF_AF, AF_LVAR, _v); }
inline bool inf_propagate_stkargs(void) { return getinf_flag(INF_AF, AF_STKARG); }
inline bool inf_set_propagate_stkargs(bool _v=true) { return setinf_flag(INF_AF, AF_STKARG, _v); }
inline bool inf_propagate_regargs(void) { return getinf_flag(INF_AF, AF_REGARG); }
inline bool inf_set_propagate_regargs(bool _v=true) { return setinf_flag(INF_AF, AF_REGARG, _v); }
inline bool inf_should_trace_sp(void) { return getinf_flag(INF_AF, AF_TRACE); }
inline bool inf_set_should_trace_sp(bool _v=true) { return setinf_flag(INF_AF, AF_TRACE, _v); }
inline bool inf_full_sp_ana(void) { return getinf_flag(INF_AF, AF_VERSP); }
inline bool inf_set_full_sp_ana(bool _v=true) { return setinf_flag(INF_AF, AF_VERSP, _v); }
inline bool inf_noret_ana(void) { return getinf_flag(INF_AF, AF_ANORET); }
inline bool inf_set_noret_ana(bool _v=true) { return setinf_flag(INF_AF, AF_ANORET, _v); }
inline bool inf_guess_func_type(void) { return getinf_flag(INF_AF, AF_MEMFUNC); }
inline bool inf_set_guess_func_type(bool _v=true) { return setinf_flag(INF_AF, AF_MEMFUNC, _v); }
inline bool inf_truncate_on_del(void) { return getinf_flag(INF_AF, AF_TRFUNC); }
inline bool inf_set_truncate_on_del(bool _v=true) { return setinf_flag(INF_AF, AF_TRFUNC, _v); }
inline bool inf_create_strlit_on_xref(void) { return getinf_flag(INF_AF, AF_STRLIT); }
inline bool inf_set_create_strlit_on_xref(bool _v=true) { return setinf_flag(INF_AF, AF_STRLIT, _v); }
inline bool inf_check_unicode_strlits(void) { return getinf_flag(INF_AF, AF_CHKUNI); }
inline bool inf_set_check_unicode_strlits(bool _v=true) { return setinf_flag(INF_AF, AF_CHKUNI, _v); }
inline bool inf_create_off_using_fixup(void) { return getinf_flag(INF_AF, AF_FIXUP); }
inline bool inf_set_create_off_using_fixup(bool _v=true) { return setinf_flag(INF_AF, AF_FIXUP, _v); }
inline bool inf_create_off_on_dref(void) { return getinf_flag(INF_AF, AF_DREFOFF); }
inline bool inf_set_create_off_on_dref(bool _v=true) { return setinf_flag(INF_AF, AF_DREFOFF, _v); }
inline bool inf_op_offset(void) { return getinf_flag(INF_AF, AF_IMMOFF); }
inline bool inf_set_op_offset(bool _v=true) { return setinf_flag(INF_AF, AF_IMMOFF, _v); }
inline bool inf_data_offset(void) { return getinf_flag(INF_AF, AF_DATOFF); }
inline bool inf_set_data_offset(bool _v=true) { return setinf_flag(INF_AF, AF_DATOFF, _v); }
inline bool inf_use_flirt(void) { return getinf_flag(INF_AF, AF_FLIRT); }
inline bool inf_set_use_flirt(bool _v=true) { return setinf_flag(INF_AF, AF_FLIRT, _v); }
inline bool inf_append_sigcmt(void) { return getinf_flag(INF_AF, AF_SIGCMT); }
inline bool inf_set_append_sigcmt(bool _v=true) { return setinf_flag(INF_AF, AF_SIGCMT, _v); }
inline bool inf_allow_sigmulti(void) { return getinf_flag(INF_AF, AF_SIGMLT); }
inline bool inf_set_allow_sigmulti(bool _v=true) { return setinf_flag(INF_AF, AF_SIGMLT, _v); }
inline bool inf_hide_libfuncs(void) { return getinf_flag(INF_AF, AF_HFLIRT); }
inline bool inf_set_hide_libfuncs(bool _v=true) { return setinf_flag(INF_AF, AF_HFLIRT, _v); }
inline bool inf_rename_jumpfunc(void) { return getinf_flag(INF_AF, AF_JFUNC); }
inline bool inf_set_rename_jumpfunc(bool _v=true) { return setinf_flag(INF_AF, AF_JFUNC, _v); }
inline bool inf_rename_nullsub(void) { return getinf_flag(INF_AF, AF_NULLSUB); }
inline bool inf_set_rename_nullsub(bool _v=true) { return setinf_flag(INF_AF, AF_NULLSUB, _v); }
inline bool inf_coagulate_data(void) { return getinf_flag(INF_AF, AF_DODATA); }
inline bool inf_set_coagulate_data(bool _v=true) { return setinf_flag(INF_AF, AF_DODATA, _v); }
inline bool inf_coagulate_code(void) { return getinf_flag(INF_AF, AF_DOCODE); }
inline bool inf_set_coagulate_code(bool _v=true) { return setinf_flag(INF_AF, AF_DOCODE, _v); }
inline bool inf_final_pass(void) { return getinf_flag(INF_AF, AF_FINAL); }
inline bool inf_set_final_pass(bool _v=true) { return setinf_flag(INF_AF, AF_FINAL, _v); }
 
inline uint32 inf_get_af2() { return uint32(getinf(INF_AF2)); }
inline bool inf_set_af2(uint32 _v) { return setinf(INF_AF2, ssize_t(_v)); }
inline bool inf_handle_eh(void) { return getinf_flag(INF_AF2, AF2_DOEH); }
inline bool inf_set_handle_eh(bool _v=true) { return setinf_flag(INF_AF2, AF2_DOEH, _v); }
inline bool inf_handle_rtti(void) { return getinf_flag(INF_AF2, AF2_DORTTI); }
inline bool inf_set_handle_rtti(bool _v=true) { return setinf_flag(INF_AF2, AF2_DORTTI, _v); }
inline bool inf_macros_enabled(void) { return getinf_flag(INF_AF2, AF2_MACRO); }
inline bool inf_set_macros_enabled(bool _v=true) { return setinf_flag(INF_AF2, AF2_MACRO, _v); }
inline bool inf_merge_strlits(void) { return getinf_flag(INF_AF2, AF2_MERGESTR); }
inline bool inf_set_merge_strlits(bool _v=true) { return setinf_flag(INF_AF2, AF2_MERGESTR, _v); }
 
inline uval_t inf_get_baseaddr() { return uval_t(getinf(INF_BASEADDR)); }
inline bool inf_set_baseaddr(uval_t _v) { return setinf(INF_BASEADDR, ssize_t(_v)); }
 
inline sel_t inf_get_start_ss() { return sel_t(getinf(INF_START_SS)); }
inline bool inf_set_start_ss(sel_t _v) { return setinf(INF_START_SS, ssize_t(_v)); }
 
inline sel_t inf_get_start_cs() { return sel_t(getinf(INF_START_CS)); }
inline bool inf_set_start_cs(sel_t _v) { return setinf(INF_START_CS, ssize_t(_v)); }
 
inline ea_t inf_get_start_ip() { return ea_t(getinf(INF_START_IP)); }
inline bool inf_set_start_ip(ea_t _v) { return setinf(INF_START_IP, ssize_t(_v)); }
 
inline ea_t inf_get_start_ea() { return ea_t(getinf(INF_START_EA)); }
inline bool inf_set_start_ea(ea_t _v) { return setinf(INF_START_EA, ssize_t(_v)); }
 
inline ea_t inf_get_start_sp() { return ea_t(getinf(INF_START_SP)); }
inline bool inf_set_start_sp(ea_t _v) { return setinf(INF_START_SP, ssize_t(_v)); }
 
inline ea_t inf_get_main() { return ea_t(getinf(INF_MAIN)); }
inline bool inf_set_main(ea_t _v) { return setinf(INF_MAIN, ssize_t(_v)); }
 
inline ea_t inf_get_min_ea() { return ea_t(getinf(INF_MIN_EA)); }
inline bool inf_set_min_ea(ea_t _v) { return setinf(INF_MIN_EA, ssize_t(_v)); }
 
inline ea_t inf_get_max_ea() { return ea_t(getinf(INF_MAX_EA)); }
inline bool inf_set_max_ea(ea_t _v) { return setinf(INF_MAX_EA, ssize_t(_v)); }
 
inline ea_t inf_get_omin_ea() { return ea_t(getinf(INF_OMIN_EA)); }
inline bool inf_set_omin_ea(ea_t _v) { return setinf(INF_OMIN_EA, ssize_t(_v)); }
 
inline ea_t inf_get_omax_ea() { return ea_t(getinf(INF_OMAX_EA)); }
inline bool inf_set_omax_ea(ea_t _v) { return setinf(INF_OMAX_EA, ssize_t(_v)); }
 
inline ea_t inf_get_lowoff() { return ea_t(getinf(INF_LOWOFF)); }
inline bool inf_set_lowoff(ea_t _v) { return setinf(INF_LOWOFF, ssize_t(_v)); }
 
inline ea_t inf_get_highoff() { return ea_t(getinf(INF_HIGHOFF)); }
inline bool inf_set_highoff(ea_t _v) { return setinf(INF_HIGHOFF, ssize_t(_v)); }
 
inline uval_t inf_get_maxref() { return uval_t(getinf(INF_MAXREF)); }
inline bool inf_set_maxref(uval_t _v) { return setinf(INF_MAXREF, ssize_t(_v)); }
 
inline sval_t inf_get_netdelta() { return sval_t(getinf(INF_NETDELTA)); }
inline bool inf_set_netdelta(sval_t _v) { return setinf(INF_NETDELTA, ssize_t(_v)); }
 
inline uchar inf_get_xrefnum() { return uchar(getinf(INF_XREFNUM)); }
inline bool inf_set_xrefnum(uchar _v) { return setinf(INF_XREFNUM, ssize_t(_v)); }
 
inline uchar inf_get_type_xrefnum() { return uchar(getinf(INF_TYPE_XREFNUM)); }
inline bool inf_set_type_xrefnum(uchar _v) { return setinf(INF_TYPE_XREFNUM, ssize_t(_v)); }
 
inline uchar inf_get_refcmtnum() { return uchar(getinf(INF_REFCMTNUM)); }
inline bool inf_set_refcmtnum(uchar _v) { return setinf(INF_REFCMTNUM, ssize_t(_v)); }
 
inline uchar inf_get_xrefflag() { return uchar(getinf(INF_XREFFLAG)); }
inline bool inf_set_xrefflag(uchar _v) { return setinf(INF_XREFFLAG, ssize_t(_v)); }
inline bool inf_show_xref_seg(void) { return getinf_flag(INF_XREFFLAG, SW_SEGXRF); }
inline bool inf_set_show_xref_seg(bool _v=true) { return setinf_flag(INF_XREFFLAG, SW_SEGXRF, _v); }
inline bool inf_show_xref_tmarks(void) { return getinf_flag(INF_XREFFLAG, SW_XRFMRK); }
inline bool inf_set_show_xref_tmarks(bool _v=true) { return setinf_flag(INF_XREFFLAG, SW_XRFMRK, _v); }
inline bool inf_show_xref_fncoff(void) { return getinf_flag(INF_XREFFLAG, SW_XRFFNC); }
inline bool inf_set_show_xref_fncoff(bool _v=true) { return setinf_flag(INF_XREFFLAG, SW_XRFFNC, _v); }
inline bool inf_show_xref_val(void) { return getinf_flag(INF_XREFFLAG, SW_XRFVAL); }
inline bool inf_set_show_xref_val(bool _v=true) { return setinf_flag(INF_XREFFLAG, SW_XRFVAL, _v); }
 
inline ushort inf_get_max_autoname_len() { return ushort(getinf(INF_MAX_AUTONAME_LEN)); }
inline bool inf_set_max_autoname_len(ushort _v) { return setinf(INF_MAX_AUTONAME_LEN, ssize_t(_v)); }
 
inline char inf_get_nametype() { return char(getinf(INF_NAMETYPE)); }
inline bool inf_set_nametype(char _v) { return setinf(INF_NAMETYPE, ssize_t(_v)); }
 
inline uint32 inf_get_short_demnames() { return uint32(getinf(INF_SHORT_DEMNAMES)); }
inline bool inf_set_short_demnames(uint32 _v) { return setinf(INF_SHORT_DEMNAMES, ssize_t(_v)); }
 
inline uint32 inf_get_long_demnames() { return uint32(getinf(INF_LONG_DEMNAMES)); }
inline bool inf_set_long_demnames(uint32 _v) { return setinf(INF_LONG_DEMNAMES, ssize_t(_v)); }
 
inline uchar inf_get_demnames() { return uchar(getinf(INF_DEMNAMES)); }
inline bool inf_set_demnames(uchar _v) { return setinf(INF_DEMNAMES, ssize_t(_v)); }
 
inline uchar inf_get_listnames() { return uchar(getinf(INF_LISTNAMES)); }
inline bool inf_set_listnames(uchar _v) { return setinf(INF_LISTNAMES, ssize_t(_v)); }
 
inline uchar inf_get_indent() { return uchar(getinf(INF_INDENT)); }
inline bool inf_set_indent(uchar _v) { return setinf(INF_INDENT, ssize_t(_v)); }
 
inline uchar inf_get_cmt_indent() { return uchar(getinf(INF_CMT_INDENT)); }
inline bool inf_set_cmt_indent(uchar _v) { return setinf(INF_CMT_INDENT, ssize_t(_v)); }
 
inline ushort inf_get_margin() { return ushort(getinf(INF_MARGIN)); }
inline bool inf_set_margin(ushort _v) { return setinf(INF_MARGIN, ssize_t(_v)); }
 
inline ushort inf_get_lenxref() { return ushort(getinf(INF_LENXREF)); }
inline bool inf_set_lenxref(ushort _v) { return setinf(INF_LENXREF, ssize_t(_v)); }
 
inline uint32 inf_get_outflags() { return uint32(getinf(INF_OUTFLAGS)); }
inline bool inf_set_outflags(uint32 _v) { return setinf(INF_OUTFLAGS, ssize_t(_v)); }
inline bool inf_show_void(void) { return getinf_flag(INF_OUTFLAGS, OFLG_SHOW_VOID); }
inline bool inf_set_show_void(bool _v=true) { return setinf_flag(INF_OUTFLAGS, OFLG_SHOW_VOID, _v); }
inline bool inf_show_auto(void) { return getinf_flag(INF_OUTFLAGS, OFLG_SHOW_AUTO); }
inline bool inf_set_show_auto(bool _v=true) { return setinf_flag(INF_OUTFLAGS, OFLG_SHOW_AUTO, _v); }
inline bool inf_gen_null(void) { return getinf_flag(INF_OUTFLAGS, OFLG_GEN_NULL); }
inline bool inf_set_gen_null(bool _v=true) { return setinf_flag(INF_OUTFLAGS, OFLG_GEN_NULL, _v); }
inline bool inf_show_line_pref(void) { return getinf_flag(INF_OUTFLAGS, OFLG_SHOW_PREF); }
inline bool inf_set_show_line_pref(bool _v=true) { return setinf_flag(INF_OUTFLAGS, OFLG_SHOW_PREF, _v); }
inline bool inf_line_pref_with_seg(void) { return getinf_flag(INF_OUTFLAGS, OFLG_PREF_SEG); }
inline bool inf_set_line_pref_with_seg(bool _v=true) { return setinf_flag(INF_OUTFLAGS, OFLG_PREF_SEG, _v); }
inline bool inf_gen_lzero(void) { return getinf_flag(INF_OUTFLAGS, OFLG_LZERO); }
inline bool inf_set_gen_lzero(bool _v=true) { return setinf_flag(INF_OUTFLAGS, OFLG_LZERO, _v); }
inline bool inf_gen_org(void) { return getinf_flag(INF_OUTFLAGS, OFLG_GEN_ORG); }
inline bool inf_set_gen_org(bool _v=true) { return setinf_flag(INF_OUTFLAGS, OFLG_GEN_ORG, _v); }
inline bool inf_gen_assume(void) { return getinf_flag(INF_OUTFLAGS, OFLG_GEN_ASSUME); }
inline bool inf_set_gen_assume(bool _v=true) { return setinf_flag(INF_OUTFLAGS, OFLG_GEN_ASSUME, _v); }
inline bool inf_gen_tryblks(void) { return getinf_flag(INF_OUTFLAGS, OFLG_GEN_TRYBLKS); }
inline bool inf_set_gen_tryblks(bool _v=true) { return setinf_flag(INF_OUTFLAGS, OFLG_GEN_TRYBLKS, _v); }
 
inline uchar inf_get_cmtflg() { return uchar(getinf(INF_CMTFLG)); }
inline bool inf_set_cmtflg(uchar _v) { return setinf(INF_CMTFLG, ssize_t(_v)); }
inline bool inf_show_repeatables(void) { return getinf_flag(INF_CMTFLG, SCF_RPTCMT); }
inline bool inf_set_show_repeatables(bool _v=true) { return setinf_flag(INF_CMTFLG, SCF_RPTCMT, _v); }
inline bool inf_show_all_comments(void) { return getinf_flag(INF_CMTFLG, SCF_ALLCMT); }
inline bool inf_set_show_all_comments(bool _v=true) { return setinf_flag(INF_CMTFLG, SCF_ALLCMT, _v); }
inline bool inf_hide_comments(void) { return getinf_flag(INF_CMTFLG, SCF_NOCMT); }
inline bool inf_set_hide_comments(bool _v=true) { return setinf_flag(INF_CMTFLG, SCF_NOCMT, _v); }
inline bool inf_show_src_linnum(void) { return getinf_flag(INF_CMTFLG, SCF_LINNUM); }
inline bool inf_set_show_src_linnum(bool _v=true) { return setinf_flag(INF_CMTFLG, SCF_LINNUM, _v); }
inline bool inf_test_mode(void) { return getinf_flag(INF_CMTFLG, SCF_TESTMODE); }
inline bool inf_show_hidden_insns(void) { return getinf_flag(INF_CMTFLG, SCF_SHHID_ITEM); }
inline bool inf_set_show_hidden_insns(bool _v=true) { return setinf_flag(INF_CMTFLG, SCF_SHHID_ITEM, _v); }
inline bool inf_show_hidden_funcs(void) { return getinf_flag(INF_CMTFLG, SCF_SHHID_FUNC); }
inline bool inf_set_show_hidden_funcs(bool _v=true) { return setinf_flag(INF_CMTFLG, SCF_SHHID_FUNC, _v); }
inline bool inf_show_hidden_segms(void) { return getinf_flag(INF_CMTFLG, SCF_SHHID_SEGM); }
inline bool inf_set_show_hidden_segms(bool _v=true) { return setinf_flag(INF_CMTFLG, SCF_SHHID_SEGM, _v); }
 
inline uchar inf_get_limiter() { return uchar(getinf(INF_LIMITER)); }
inline bool inf_set_limiter(uchar _v) { return setinf(INF_LIMITER, ssize_t(_v)); }
inline bool inf_is_limiter_thin(void) { return getinf_flag(INF_LIMITER, LMT_THIN); }
inline bool inf_set_limiter_thin(bool _v=true) { return setinf_flag(INF_LIMITER, LMT_THIN, _v); }
inline bool inf_is_limiter_thick(void) { return getinf_flag(INF_LIMITER, LMT_THICK); }
inline bool inf_set_limiter_thick(bool _v=true) { return setinf_flag(INF_LIMITER, LMT_THICK, _v); }
inline bool inf_is_limiter_empty(void) { return getinf_flag(INF_LIMITER, LMT_EMPTY); }
inline bool inf_set_limiter_empty(bool _v=true) { return setinf_flag(INF_LIMITER, LMT_EMPTY, _v); }
 
inline short inf_get_bin_prefix_size() { return short(getinf(INF_BIN_PREFIX_SIZE)); }
inline bool inf_set_bin_prefix_size(short _v) { return setinf(INF_BIN_PREFIX_SIZE, ssize_t(_v)); }
 
inline uchar inf_get_prefflag() { return uchar(getinf(INF_PREFFLAG)); }
inline bool inf_set_prefflag(uchar _v) { return setinf(INF_PREFFLAG, ssize_t(_v)); }
inline bool inf_prefix_show_segaddr(void) { return getinf_flag(INF_PREFFLAG, PREF_SEGADR); }
inline bool inf_set_prefix_show_segaddr(bool _v=true) { return setinf_flag(INF_PREFFLAG, PREF_SEGADR, _v); }
inline bool inf_prefix_show_funcoff(void) { return getinf_flag(INF_PREFFLAG, PREF_FNCOFF); }
inline bool inf_set_prefix_show_funcoff(bool _v=true) { return setinf_flag(INF_PREFFLAG, PREF_FNCOFF, _v); }
inline bool inf_prefix_show_stack(void) { return getinf_flag(INF_PREFFLAG, PREF_STACK); }
inline bool inf_set_prefix_show_stack(bool _v=true) { return setinf_flag(INF_PREFFLAG, PREF_STACK, _v); }
inline bool inf_prefix_truncate_opcode_bytes(void) { return getinf_flag(INF_PREFFLAG, PREF_PFXTRUNC); }
inline bool inf_set_prefix_truncate_opcode_bytes(bool _v=true) { return setinf_flag(INF_PREFFLAG, PREF_PFXTRUNC, _v); }
 
inline uchar inf_get_strlit_flags() { return uchar(getinf(INF_STRLIT_FLAGS)); }
inline bool inf_set_strlit_flags(uchar _v) { return setinf(INF_STRLIT_FLAGS, ssize_t(_v)); }
inline bool inf_strlit_names(void) { return getinf_flag(INF_STRLIT_FLAGS, STRF_GEN); }
inline bool inf_set_strlit_names(bool _v=true) { return setinf_flag(INF_STRLIT_FLAGS, STRF_GEN, _v); }
inline bool inf_strlit_name_bit(void) { return getinf_flag(INF_STRLIT_FLAGS, STRF_AUTO); }
inline bool inf_set_strlit_name_bit(bool _v=true) { return setinf_flag(INF_STRLIT_FLAGS, STRF_AUTO, _v); }
inline bool inf_strlit_serial_names(void) { return getinf_flag(INF_STRLIT_FLAGS, STRF_SERIAL); }
inline bool inf_set_strlit_serial_names(bool _v=true) { return setinf_flag(INF_STRLIT_FLAGS, STRF_SERIAL, _v); }
inline bool inf_unicode_strlits(void) { return getinf_flag(INF_STRLIT_FLAGS, STRF_UNICODE); }
inline bool inf_set_unicode_strlits(bool _v=true) { return setinf_flag(INF_STRLIT_FLAGS, STRF_UNICODE, _v); }
inline bool inf_strlit_autocmt(void) { return getinf_flag(INF_STRLIT_FLAGS, STRF_COMMENT); }
inline bool inf_set_strlit_autocmt(bool _v=true) { return setinf_flag(INF_STRLIT_FLAGS, STRF_COMMENT, _v); }
inline bool inf_strlit_savecase(void) { return getinf_flag(INF_STRLIT_FLAGS, STRF_SAVECASE); }
inline bool inf_set_strlit_savecase(bool _v=true) { return setinf_flag(INF_STRLIT_FLAGS, STRF_SAVECASE, _v); }
 
inline uchar inf_get_strlit_break() { return uchar(getinf(INF_STRLIT_BREAK)); }
inline bool inf_set_strlit_break(uchar _v) { return setinf(INF_STRLIT_BREAK, ssize_t(_v)); }
 
inline char inf_get_strlit_zeroes() { return char(getinf(INF_STRLIT_ZEROES)); }
inline bool inf_set_strlit_zeroes(char _v) { return setinf(INF_STRLIT_ZEROES, ssize_t(_v)); }
 
inline int32 inf_get_strtype() { return int32(getinf(INF_STRTYPE)); }
inline bool inf_set_strtype(int32 _v) { return setinf(INF_STRTYPE, ssize_t(_v)); }
 
inline uval_t inf_get_strlit_sernum() { return uval_t(getinf(INF_STRLIT_SERNUM)); }
inline bool inf_set_strlit_sernum(uval_t _v) { return setinf(INF_STRLIT_SERNUM, ssize_t(_v)); }
 
inline uval_t inf_get_datatypes() { return uval_t(getinf(INF_DATATYPES)); }
inline bool inf_set_datatypes(uval_t _v) { return setinf(INF_DATATYPES, ssize_t(_v)); }
 
inline uint32 inf_get_abibits() { return uint32(getinf(INF_ABIBITS)); }
inline bool inf_set_abibits(uint32 _v) { return setinf(INF_ABIBITS, ssize_t(_v)); }
inline bool inf_is_mem_aligned4(void) { return getinf_flag(INF_ABIBITS, ABI_8ALIGN4); }
inline bool inf_set_mem_aligned4(bool _v=true) { return setinf_flag(INF_ABIBITS, ABI_8ALIGN4, _v); }
inline bool inf_pack_stkargs(void) { return getinf_flag(INF_ABIBITS, ABI_PACK_STKARGS); }
inline bool inf_set_pack_stkargs(bool _v=true) { return setinf_flag(INF_ABIBITS, ABI_PACK_STKARGS, _v); }
inline bool inf_big_arg_align(void) { return getinf_flag(INF_ABIBITS, ABI_BIGARG_ALIGN); }
inline bool inf_set_big_arg_align(bool _v=true) { return setinf_flag(INF_ABIBITS, ABI_BIGARG_ALIGN, _v); }
inline bool inf_stack_ldbl(void) { return getinf_flag(INF_ABIBITS, ABI_STACK_LDBL); }
inline bool inf_set_stack_ldbl(bool _v=true) { return setinf_flag(INF_ABIBITS, ABI_STACK_LDBL, _v); }
inline bool inf_stack_varargs(void) { return getinf_flag(INF_ABIBITS, ABI_STACK_VARARGS); }
inline bool inf_set_stack_varargs(bool _v=true) { return setinf_flag(INF_ABIBITS, ABI_STACK_VARARGS, _v); }
inline bool inf_is_hard_float(void) { return getinf_flag(INF_ABIBITS, ABI_HARD_FLOAT); }
inline bool inf_set_hard_float(bool _v=true) { return setinf_flag(INF_ABIBITS, ABI_HARD_FLOAT, _v); }
inline bool inf_abi_set_by_user(void) { return getinf_flag(INF_ABIBITS, ABI_SET_BY_USER); }
inline bool inf_set_abi_set_by_user(bool _v=true) { return setinf_flag(INF_ABIBITS, ABI_SET_BY_USER, _v); }
inline bool inf_use_gcc_layout(void) { return getinf_flag(INF_ABIBITS, ABI_GCC_LAYOUT); }
inline bool inf_set_use_gcc_layout(bool _v=true) { return setinf_flag(INF_ABIBITS, ABI_GCC_LAYOUT, _v); }
inline bool inf_map_stkargs(void) { return getinf_flag(INF_ABIBITS, ABI_MAP_STKARGS); }
inline bool inf_set_map_stkargs(bool _v=true) { return setinf_flag(INF_ABIBITS, ABI_MAP_STKARGS, _v); }
inline bool inf_huge_arg_align(void) { return getinf_flag(INF_ABIBITS, ABI_HUGEARG_ALIGN); }
inline bool inf_set_huge_arg_align(bool _v=true) { return setinf_flag(INF_ABIBITS, ABI_HUGEARG_ALIGN, _v); }
 
inline uint32 inf_get_appcall_options() { return uint32(getinf(INF_APPCALL_OPTIONS)); }
inline bool inf_set_appcall_options(uint32 _v) { return setinf(INF_APPCALL_OPTIONS, ssize_t(_v)); }
 
inline ea_t inf_get_privrange_start_ea() { return ea_t(getinf(INF_PRIVRANGE_START_EA)); }
inline bool inf_set_privrange_start_ea(ea_t _v) { return setinf(INF_PRIVRANGE_START_EA, ssize_t(_v)); }
 
inline ea_t inf_get_privrange_end_ea() { return ea_t(getinf(INF_PRIVRANGE_END_EA)); }
inline bool inf_set_privrange_end_ea(ea_t _v) { return setinf(INF_PRIVRANGE_END_EA, ssize_t(_v)); }
 
inline comp_t inf_get_cc_id() { return comp_t(getinf(INF_CC_ID)); }
inline bool inf_set_cc_id(comp_t _v) { return setinf(INF_CC_ID, ssize_t(_v)); }
 
inline cm_t inf_get_cc_cm() { return cm_t(getinf(INF_CC_CM)); }
inline bool inf_set_cc_cm(cm_t _v) { return setinf(INF_CC_CM, ssize_t(_v)); }
 
inline callcnv_t inf_get_callcnv() { return callcnv_t(getinf(INF_CALLCNV)); }
inline bool inf_set_callcnv(callcnv_t _v) { return setinf(INF_CALLCNV, ssize_t(_v)); }
 
inline uchar inf_get_cc_size_i() { return uchar(getinf(INF_CC_SIZE_I)); }
inline bool inf_set_cc_size_i(uchar _v) { return setinf(INF_CC_SIZE_I, ssize_t(_v)); }
 
inline uchar inf_get_cc_size_b() { return uchar(getinf(INF_CC_SIZE_B)); }
inline bool inf_set_cc_size_b(uchar _v) { return setinf(INF_CC_SIZE_B, ssize_t(_v)); }
 
inline uchar inf_get_cc_size_e() { return uchar(getinf(INF_CC_SIZE_E)); }
inline bool inf_set_cc_size_e(uchar _v) { return setinf(INF_CC_SIZE_E, ssize_t(_v)); }
 
inline uchar inf_get_cc_defalign() { return uchar(getinf(INF_CC_DEFALIGN)); }
inline bool inf_set_cc_defalign(uchar _v) { return setinf(INF_CC_DEFALIGN, ssize_t(_v)); }
 
inline uchar inf_get_cc_size_s() { return uchar(getinf(INF_CC_SIZE_S)); }
inline bool inf_set_cc_size_s(uchar _v) { return setinf(INF_CC_SIZE_S, ssize_t(_v)); }
 
inline uchar inf_get_cc_size_l() { return uchar(getinf(INF_CC_SIZE_L)); }
inline bool inf_set_cc_size_l(uchar _v) { return setinf(INF_CC_SIZE_L, ssize_t(_v)); }
 
inline uchar inf_get_cc_size_ll() { return uchar(getinf(INF_CC_SIZE_LL)); }
inline bool inf_set_cc_size_ll(uchar _v) { return setinf(INF_CC_SIZE_LL, ssize_t(_v)); }
 
inline uchar inf_get_cc_size_ldbl() { return uchar(getinf(INF_CC_SIZE_LDBL)); }
inline bool inf_set_cc_size_ldbl(uchar _v) { return setinf(INF_CC_SIZE_LDBL, ssize_t(_v)); }
 
inline bool inf_get_procname(char *buf, size_t bufsize=IDAINFO_PROCNAME_SIZE)
{
  return getinf_buf(INF_PROCNAME, buf, bufsize) > 0;
}
inline qstring inf_get_procname()
{
  char buf[IDAINFO_PROCNAME_SIZE];
  if ( !getinf_buf(INF_PROCNAME, buf, sizeof(buf)) )
    buf[0] = '\0';
  return qstring(buf);
}
inline bool inf_set_procname(const char *_v, size_t len=size_t(-1))
{
  if ( _v == nullptr )
    return false;
  if ( len == size_t(-1) )
    len = ::qstrlen(_v);
  return setinf_buf(INF_PROCNAME, _v, qmin(len, IDAINFO_PROCNAME_SIZE));
}
 
inline bool inf_get_strlit_pref(char *buf, size_t bufsize=IDAINFO_STRLIT_PREF_SIZE)
{
  return getinf_buf(INF_STRLIT_PREF, buf, bufsize) > 0;
}
inline qstring inf_get_strlit_pref()
{
  char buf[IDAINFO_STRLIT_PREF_SIZE];
  if ( !getinf_buf(INF_STRLIT_PREF, buf, sizeof(buf)) )
    buf[0] = '\0';
  return qstring(buf);
}
inline bool inf_set_strlit_pref(const char *_v, size_t len=size_t(-1))
{
  if ( _v == nullptr )
    return false;
  if ( len == size_t(-1) )
    len = ::qstrlen(_v);
  return setinf_buf(INF_STRLIT_PREF, _v, qmin(len, IDAINFO_STRLIT_PREF_SIZE));
}
 
inline bool inf_get_cc(compiler_info_t *out) { return getinf_buf(INF_COMPILER_INFO, out, sizeof(*out)) > 0; }
inline bool inf_set_cc(const compiler_info_t &_v) { return setinf_buf(INF_COMPILER_INFO, &_v, sizeof(_v)); }
 
inline bool inf_get_privrange(range_t *out) { return getinf_buf(INF_PRIVRANGE, out, sizeof(*out)) > 0; }
inline bool inf_set_privrange(const range_t &_v) { return setinf_buf(INF_PRIVRANGE, &_v, sizeof(_v)); }
 
// </INF_ACCESSORS>
 
inline range_t inf_get_privrange() { range_t r; inf_get_privrange(&r); return r; }

inline ushort inf_get_af_low() { return inf_get_af() & 0xffff; }
inline void inf_set_af_low(ushort saf) { uint32 af = (inf_get_af() & 0xffff0000) | saf; inf_set_af(af); }
inline ushort inf_get_af_high() { return (inf_get_af() >> 16) & 0xffff; }
inline void inf_set_af_high(ushort saf2) { uint32 af = (inf_get_af() & 0xffff) | (saf2 << 16); inf_set_af(af); }
inline ushort inf_get_af2_low() { return inf_get_af2() & 0xffff; }
inline void inf_set_af2_low(ushort saf) { uint32 af2 = (inf_get_af2() & 0xffff0000) | saf; inf_set_af2(af2); }
 
inline int inf_get_pack_mode()
{
  uint32 lflags = inf_get_lflags();
  return (lflags & LFLG_COMPRESS) != 0 ? IDB_COMPRESSED
       : (lflags & LFLG_PACK) != 0     ? IDB_PACKED
       :                                 IDB_UNPACKED;
}
 
inline int inf_set_pack_mode(int pack_mode)
{
  int old = inf_get_pack_mode();
  uint32 lflags = inf_get_lflags();
  setflag(lflags, LFLG_COMPRESS, pack_mode == IDB_COMPRESSED);
  setflag(lflags, LFLG_PACK,     pack_mode == IDB_PACKED);
  inf_set_lflags(lflags);
  return old;
}
 
inline void inf_inc_database_change_count(int cnt=1)
{ inf_set_database_change_count(inf_get_database_change_count()+cnt); }

inline uchar inf_get_demname_form(void) { return uchar(inf_get_demnames() & DEMNAM_MASK); }
 
inline uval_t inf_postinc_strlit_sernum(uval_t cnt=1)
{
  uval_t was = inf_get_strlit_sernum();
  inf_set_strlit_sernum(was + cnt);
  return was;
}
 
inline bool inf_like_binary(void)
{ return is_filetype_like_binary(inf_get_filetype()); }
 
 
 
//-------------------------------------------------------------------------
 
#define UA_MAXOP        8
 

 
inline int calc_default_idaplace_flags(void)
{
  return 0;
}
 
//-------------------------------------------------------------------------
 
inline ea_t idaapi to_ea(sel_t reg_cs, uval_t reg_ip)
{
  return (reg_cs << 4) + reg_ip;
}
 
//-------------------------------------------------------------------------
 
struct ea_helper_t
{
  const uval_t mask32 = 0xFFFFFFFF;
 
#ifdef __EA64__
  const uval_t mask64 = 0xFFFFFFFFFFFFFFFFULL;
 
  uval_t mask = mask64;
  int ea_size = 8;
  bool enabled = true;  // can be disabled for old databases
 
  void setup(bool is_64bit)
  {
    if ( enabled )
    {
      mask = is_64bit ? mask64 : mask32;
      ea_size = is_64bit ? 8 : 4;
    }
  }
  void disable()
  {
    enabled = false;
    mask = mask64;
    ea_size = 8;
  }
 
  bool is_enabled() const           { return enabled; }
  sval_t ea2sval(uval_t v) const    { return ea_size == 8 ? v : int32(v); }
  uval_t trunc_uval(uval_t v) const { return v & mask; }
  ea_t uval2ea(uval_t v) const      { return v == mask ? BADADDR : v; }
  bool fits_ea_space(ea_t ea) const { return ea <= mask; }
  bool fits_ea_space(const range_t &r) const
  {
    return fits_ea_space(r.start_ea) && fits_ea_space(r.end_ea);
  }
  ea_t trunc_ea(ea_t ea) const
  {
#ifdef TESTABLE_BUILD
    QASSERT(2762, ea != BADADDR);  // do not permit to truncate BADADDR
#endif
    return ea & mask;
  }
  ea_t ea_space_end() const
  {
    // 0x1'0000'0000 is the end of the 32-bit address space in ida64
    return ea_size == 8 ? BADADDR : ea_t(BADADDR32) + 1;
  }
  ea_t to_ea(sel_t cs, uval_t ip) const
  {
    ea_t ea = ::to_ea(cs, ip);
    if ( !like_badaddr(ea) )
      ea = trunc_ea(ea);
    return ea;
  }
  ea_t fix_ea_tid(ea_t ea) const
  {
    return ea_size == 8 || inf_get_privrange().contains(ea)
         ? ea
         : uval2ea(trunc_uval(ea));
  }
  bool is_ea_add_ok(uval_t x, uval_t y) const
  {
    if ( x == BADADDR )
      return y == 0;
    if ( y == BADADDR )
      return x == 0;
#ifdef TESTABLE_BUILD
    QASSERT(2763, fits_ea_space(x) && fits_ea_space(y));
#endif
    return y <= mask - x;
  }
  sval_t sval_max() const { return ea_size == 8 ? SVAL_MAX : INT_MAX; }
  sval_t sval_min() const { return ea_size == 8 ? SVAL_MIN : INT_MIN; }
#else // __EA64__
  const uval_t mask = mask32;
  const int ea_size = sizeof(ea_t);
 
  void setup(bool /*is_64bit*/)              {}
  bool is_enabled() const                    { return false; }
  sval_t ea2sval(uval_t v) const             { return v; }
  ea_t uval2ea(uval_t v) const               { return v; }
  bool fits_ea_space(ea_t /*ea*/) const      { return true; }
  bool fits_ea_space(const range_t &) const  { return true; }
  ea_t trunc_ea(ea_t ea) const               { return ea; }
  ea_t ea_space_end() const                  { return BADADDR; }
  uval_t trunc_uval(uval_t v) const          { return v; }
  ea_t to_ea(sel_t cs, uval_t ip) const      { return ::to_ea(cs, ip); }
  ea_t fix_ea_tid(ea_t ea) const             { return ea; }
 
  bool is_ea_add_ok(uval_t x, uval_t y) const { return is_add_ok<uval_t>(x, y); }
  sval_t sval_max() const { return SVAL_MAX; }
  sval_t sval_min() const { return SVAL_MIN; }
#endif
 
  bool like_badaddr(ea_t ea) const { return uval2ea(ea) == BADADDR; }
  ea_t align_ea(ea_t ea, int size) const { return trunc_ea(align_up(ea, size)); }
  bool advance_ea(ea_t *ea, asize_t n) const
  {
    if ( !is_ea_add_ok(*ea, n) )
      return false;
    *ea += n;
    return true;
  }
};
 
#ifndef SWIG
#define DEFINE_EA_HELPER_FUNCS(eh) \
  const ea_helper_t &eah() const               { return (eh); }\
  bool fits_ea_space(ea_t _ea) const           { return (eh).fits_ea_space(_ea); }\
  bool fits_ea_space(const range_t &r) const   { return (eh).fits_ea_space(r); }\
  ea_t trunc_ea(ea_t _ea) const                { return (eh).trunc_ea(_ea); }\
  uval_t trunc_uval(uval_t v) const            { return (eh).trunc_uval(v); }\
  ea_t ea_space_end() const                    { return (eh).ea_space_end(); }\
  ea_t to_ea(sel_t cs, uval_t ip) const        { return (eh).to_ea(cs, ip); }\
  sval_t ea2sval(ea_t _ea) const               { return (eh).ea2sval(_ea); }\
  ea_t uval2ea(uval_t v) const                 { return (eh).uval2ea(v); }\
  bool like_badaddr(ea_t _ea) const            { return (eh).like_badaddr(_ea); }\
  bool is_ea_add_ok(uval_t x, uval_t y) const  { return (eh).is_ea_add_ok(x, y); }\
  sval_t sval_max() const                      { return (eh).sval_max(); }\
  ea_t align_ea(ea_t _ea, int size) const      { return (eh).align_ea(_ea, size); }\
  bool advance_ea(ea_t *_ea, asize_t _n) const { return (eh).advance_ea(_ea, _n); }\
  ea_t fix_ea_tid(ea_t _ea) const              { return (eh).fix_ea_tid(_ea); }
#else
#define DEFINE_EA_HELPER_FUNCS(eh)
#endif

#define IDB_EXT32 "idb"
#define IDB_EXT64 "i64"
#ifdef __EA64__
#define IDB_EXT IDB_EXT64
#else
#define IDB_EXT IDB_EXT32
#endif
 
//--------------------------------------------------------------------------
enum hook_type_t
{
  HT_IDP,         
  HT_UI,          
  HT_DBG,         
  HT_IDB,         
  HT_DEV,         
  HT_VIEW,        
  HT_OUTPUT,      
  HT_GRAPH,       
  HT_IDD,         
  HT_LAST
};
 
 
//--------------------------------------------------------------------------
 
typedef ssize_t idaapi hook_cb_t(void *user_data, int notification_code, va_list va);
 

 
idaman DEPRECATED bool ida_export hook_to_notification_point(
        hook_type_t hook_type,
        hook_cb_t *cb,
        void *user_data = nullptr);
 

 
idaman DEPRECATED int ida_export unhook_from_notification_point(
        hook_type_t hook_type,
        hook_cb_t *cb,
        void *user_data = nullptr);
 

 
idaman ssize_t ida_export invoke_callbacks(hook_type_t hook_type, int notification_code, va_list va);
 

 
struct post_event_visitor_t
{
 
  virtual ssize_t idaapi handle_post_event(
        ssize_t code,
        int notification_code,
        va_list va) = 0;
 
  virtual ~post_event_visitor_t() {}
};
 

 
idaman bool ida_export register_post_event_visitor(
        hook_type_t hook_type,
        post_event_visitor_t *visitor,
        const plugmod_t *owner);
 

 
idaman bool ida_export unregister_post_event_visitor(
        hook_type_t hook_type,
        post_event_visitor_t *visitor);
 

idaman ssize_t ida_export get_dbctx_id();

idaman size_t ida_export get_dbctx_qty();

idaman struct dbctx_t *ida_export switch_dbctx(size_t idx);

idaman bool ida_export is_database_busy();

idaman size_t ida_export validate_idb(uint32 vld_flags=0);
#define VLD_AUTO_REPAIR 0x01  
#define VLD_DIALOG      0x02  
#define VLD_SILENT      0x04  

idaman bool ida_export move_privrange(ea_t new_privrange_start);
 
 
//--------------------------------------------------------------------------
struct idbattr_valmap_t
{
  uint64 value;
  const char *valname;
};
 
//--------------------------------------------------------------------------
struct idbattr_info_t
{
  const char *name;             
  uintptr_t offset;             
  size_t width;                 
  uint64 bitmask;               
  uchar tag;                    
  const idbattr_valmap_t *vmap; 
  const char *individual_node;  
  uint idi_flags;
#define IDI_STRUCFLD    0        
#define IDI_ALTVAL      0x00001  
#define IDI_SUPVAL      0x00002  
#define IDI_VALOBJ      0x00004  
#define IDI_BLOB        0x00008  
#define IDI_SCALAR      0        
#define IDI_CSTR        0x00010  
#define IDI_QSTRING     0x00020  
#define IDI_BYTEARRAY   0x00040  
#define IDI_EA_HEX      0        
#define IDI_DEC         0x00080  
#define IDI_HEX         0x00100  
#define IDI_INC         0x00200  
#define IDI_MAP_VAL     0x00400  
#define IDI_HASH        0x00800  
#define IDI_HLPSTRUC    0x01000  
#define IDI_READONLY    0x02000  
#define IDI_BITMAP      0x04000  
#define IDI_ONOFF       0x08000  
#define IDI_NOMERGE     0x10000  
 
#define IDI_NODEVAL (IDI_ALTVAL|IDI_SUPVAL|IDI_VALOBJ|IDI_BLOB)
#define IDI_BUFVAR  (IDI_CSTR|IDI_BYTEARRAY|IDI_QSTRING|IDI_BITMAP)
 
  uint32 maxsize;               
 
  bool is_node_altval() const  { return (idi_flags & IDI_ALTVAL)  != 0; }
  bool is_node_supval() const  { return (idi_flags & IDI_SUPVAL)  != 0; }
  bool is_node_valobj() const  { return (idi_flags & IDI_VALOBJ)  != 0; }
  bool is_node_blob() const    { return (idi_flags & IDI_BLOB)    != 0; }
  bool is_node_var() const     { return (idi_flags & IDI_NODEVAL) != 0; }
  bool is_struc_field() const  { return !is_node_var(); }
  bool is_cstr() const         { return (idi_flags & IDI_CSTR)      != 0; }
  bool is_qstring() const      { return (idi_flags & IDI_QSTRING)   != 0; }
  bool is_bytearray() const    { return (idi_flags & IDI_BYTEARRAY) != 0; }
  bool is_buf_var() const      { return (idi_flags & IDI_BUFVAR)    != 0; }
  bool is_decimal() const      { return (idi_flags & IDI_DEC)       != 0; }
  bool is_hexadecimal() const  { return (idi_flags & IDI_HEX)       != 0; }
  bool is_readonly_var() const { return (idi_flags & IDI_READONLY)  != 0; }
  bool is_incremented() const  { return (idi_flags & IDI_INC)       != 0; }
  bool is_val_mapped() const   { return (idi_flags & IDI_MAP_VAL)   != 0; }
  bool is_hash() const         { return (idi_flags & IDI_HASH)      != 0; }
  bool use_hlpstruc() const    { return (idi_flags & IDI_HLPSTRUC)  != 0; }
  bool is_bitmap() const       { return (idi_flags & IDI_BITMAP)    != 0; }
  bool is_onoff() const        { return (idi_flags & IDI_ONOFF)     != 0; }
  bool is_scalar_var() const   { return !is_buf_var(); }
  bool is_bitfield() const     { return bitmask != 0 || is_bitmap(); }
  bool is_boolean() const
  {
    return is_bitmap() || (bitmask != 0 && is_pow2(bitmask));
  }
  bool has_individual_node() const  { return individual_node != nullptr; }
 
  const char *str_true() const  { return is_onoff() ? "on"  : "true"; }
  const char *str_false() const { return is_onoff() ? "off" : "false"; }
 
  size_t ridx() const          { QASSERT(1932, is_node_var()); return offset; }
  const char *hashname() const { QASSERT(2040, is_hash()); return (const char *)offset; }
  bool operator < (const idbattr_info_t &r) const
  {
    return strcmp(name, r.name) < 0;
  }
 
};
DECLARE_TYPE_AS_MOVABLE(idbattr_info_t);
 
#endif // _IDA_HPP