nalt.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2026 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef NALT_HPP
#define NALT_HPP
 
#include <ida.hpp>
#include <netnode.hpp>


#define  NALT_ENUM      uval_t(-2) 
#define  NALT_WIDE      uval_t(-1) 
#define  NALT_SWITCH    1          
//#define  NALT_OBASE1    2        // offset base 2
#define  NALT_STRUCT    3          
//#define  NALT_SEENF     4        // 'seen' flag (used in structures)
//#define  NALT_OOBASE0   5        // outer offset base 1
//#define  NALT_OOBASE1   6        // outer offset base 2
//#define  NALT_XREFPOS   7        // saved xref address in the xrefs window
#define  NALT_AFLAGS    8          
#define  NALT_LINNUM    9          
#define  NALT_ABSBASE  10          
#define  NALT_ENUM0    11          
#define  NALT_ENUM1    12          
//#define  NALT_STROFF0  13        // struct offset, struct id for the first operand
//#define  NALT_STROFF1  14        // struct offset, struct id for the second operand
#define  NALT_PURGE    15          
#define  NALT_STRTYPE  16          
#define  NALT_ALIGN    17          
//#define  NALT_HIGH0    18        // linear address of byte referenced by
//                                 // high 16 bits of an offset (FF_0HIGH)
//#define  NALT_HIGH1    19        // linear address of byte referenced by
//                                 // high 16 bits of an offset (FF_1HIGH)
#define  NALT_COLOR    20          

#define  NSUP_CMT       0       
#define  NSUP_REPCMT    1       
#define  NSUP_FOP1      2       
#define  NSUP_FOP2      3       
#define  NSUP_JINFO     4       
#define  NSUP_ARRAY     5       
#define  NSUP_OMFGRP    6       
#define  NSUP_FOP3      7       
#define  NSUP_SWITCH    8       
#define  NSUP_REF0      9       
#define  NSUP_REF1      10      
#define  NSUP_REF2      11      
#define  NSUP_OREF0     12      
#define  NSUP_OREF1     13      
#define  NSUP_OREF2     14      
#define  NSUP_STROFF0   15      
#define  NSUP_STROFF1   16      
#define  NSUP_SEGTRANS  17      
#define  NSUP_FOP4      18      
#define  NSUP_FOP5      19      
#define  NSUP_FOP6      20      
#define  NSUP_REF3      21      
#define  NSUP_REF4      22      
#define  NSUP_REF5      23      
#define  NSUP_OREF3     24      
#define  NSUP_OREF4     25      
#define  NSUP_OREF5     26      
#define  NSUP_XREFPOS   27      
#define  NSUP_CUSTDT    28      
#define  NSUP_GROUPS    29      
#define  NSUP_ARGEAS    30      
#define  NSUP_FOP7      31      
#define  NSUP_FOP8      32      
#define  NSUP_REF6      33      
#define  NSUP_REF7      34      
#define  NSUP_OREF6     35      
#define  NSUP_OREF7     36      
#define  NSUP_EX_FLAGS  37      
 
// values E_PREV..E_NEXT+1000 are reserved (1000..2000..3000 decimal)

#define  NSUP_POINTS    0x1000

#define  NSUP_MANUAL    0x2000

#define  NSUP_TYPEINFO  0x3000

#define  NSUP_REGVAR    0x4000

#define  NSUP_LLABEL    0x5000

#define  NSUP_REGARG    0x6000

#define  NSUP_FTAILS    0x7000

#define  NSUP_GROUP     0x8000

#define  NSUP_OPTYPES   0x9000

#define  NSUP_ORIGFMD   0x109000

#define  NSUP_FRAME     0x10A000


#define NALT_CREF_TO         'X'     
#define NALT_CREF_FROM       'x'     
#define NALT_DREF_TO         'D'     
#define NALT_DREF_FROM       'd'     

#define NSUP_GR_INFO         'g'     
#define NALT_GR_LAYX         'p'     
#define NSUP_GR_LAYT         'l'     

#define PATCH_TAG 'P'

#define IDB_DESKTOPS_NODE_NAME "$ desktops"
#define IDB_DESKTOPS_TAG       'S'   
#define IDB_DESKTOPS_TIMESTAMP nodeidx_t(-1)
 

 
idaman nodeidx_t ida_export ea2node(ea_t ea);
idaman ea_t ida_export node2ea(nodeidx_t ndx);
idaman nodeidx_t ida_export end_ea2node(ea_t ea);
inline netnode getnode(ea_t ea) { return netnode(ea2node(ea)); }
 
//--------------------------------------------------------------------------
//      C O N V E N I E N C E   F U N C T I O N S
//--------------------------------------------------------------------------

 
idaman tid_t ida_export get_strid(ea_t ea);


struct xrefpos_t
{
  ea_t ea;
  uchar type;  // the xref type (::cref_t or ::dref_t)
  xrefpos_t(ea_t ea_ = BADADDR, uchar type_ = 0) : ea(ea_), type(type_) {}
  bool is_valid() const { return ea != BADADDR; }
};
 
idaman ssize_t ida_export get_xrefpos(xrefpos_t *out, ea_t ea);
idaman void ida_export set_xrefpos(ea_t ea, const xrefpos_t *in);
inline void idaapi del_xrefpos(ea_t ea) { getnode(ea).supdel(NSUP_XREFPOS); }


#define AFL_LINNUM      0x00000001     
#define AFL_USERSP      0x00000002     
#define AFL_PUBNAM      0x00000004     
#define AFL_WEAKNAM     0x00000008     
#define AFL_HIDDEN      0x00000010     
#define AFL_MANUAL      0x00000020     
#define AFL_NOBRD       0x00000040     
#define AFL_ZSTROFF     0x00000080     
#define AFL_BNOT0       0x00000100     
#define AFL_BNOT1       0x00000200     
#define AFL_LIB         0x00000400     
#define AFL_TI          0x00000800     
#define AFL_TI0         0x00001000     
#define AFL_TI1         0x00002000     
#define AFL_LNAME       0x00004000     
#define AFL_TILCMT      0x00008000     
#define AFL_LZERO0      0x00010000     
#define AFL_LZERO1      0x00020000     
#define AFL_COLORED     0x00040000     
#define AFL_TERSESTR    0x00080000     
#define AFL_SIGN0       0x00100000     
#define AFL_SIGN1       0x00200000     
#define AFL_NORET       0x00400000     
#define AFL_FIXEDSPD    0x00800000     
#define AFL_ALIGNFLOW   0x01000000     
#define AFL_USERTI      0x02000000     
#define AFL_RETFP       0x04000000     
#define AFL_USEMODSP    0x08000000     
#define AFL_NOTCODE     0x10000000     
#define AFL_NOTPROC     0x20000000     
#define AFL_TYPE_GUESSED    0xC2000000 
#define AFL_IDA_GUESSED     0x00000000 
#define AFL_HR_GUESSED_FUNC 0x40000000 
#define AFL_HR_GUESSED_DATA 0x80000000 
#define AFL_HR_DETERMINED   0xC0000000 

using aflags_t = flags_t;
 
idaman void     ida_export set_aflags(ea_t ea, aflags_t flags);
idaman void     ida_export upd_abits(ea_t ea, aflags_t clr_bits, aflags_t set_bits);
idaman void     ida_export set_abits(ea_t ea, aflags_t bits);
idaman void     ida_export clr_abits(ea_t ea, aflags_t bits);
idaman aflags_t ida_export get_aflags(ea_t ea);
idaman void     ida_export del_aflags(ea_t ea);
 
inline constexpr bool has_aflag_linnum(aflags_t flags)       { return (flags & AFL_LINNUM)   != 0; }
inline constexpr bool is_aflag_usersp(aflags_t flags)        { return (flags & AFL_USERSP)   != 0; }
inline constexpr bool is_aflag_public_name(aflags_t flags)   { return (flags & AFL_PUBNAM)   != 0; }
inline constexpr bool is_aflag_weak_name(aflags_t flags)     { return (flags & AFL_WEAKNAM)  != 0; }
inline constexpr bool is_aflag_hidden_item(aflags_t flags)   { return (flags & AFL_HIDDEN)   != 0; }
inline constexpr bool is_aflag_manual_insn(aflags_t flags)   { return (flags & AFL_MANUAL)   != 0; }
inline constexpr bool is_aflag_hidden_border(aflags_t flags) { return (flags & AFL_NOBRD)    != 0; }
inline constexpr bool is_aflag_zstroff(aflags_t flags)       { return (flags & AFL_ZSTROFF)  != 0; }
inline constexpr bool is_aflag__bnot0(aflags_t flags)        { return (flags & AFL_BNOT0)    != 0; }
inline constexpr bool is_aflag__bnot1(aflags_t flags)        { return (flags & AFL_BNOT1)    != 0; }
inline constexpr bool is_aflag_libitem(aflags_t flags)       { return (flags & AFL_LIB)      != 0; }
inline constexpr bool has_aflag_ti(aflags_t flags)           { return (flags & AFL_TI)       != 0; }
inline constexpr bool has_aflag_ti0(aflags_t flags)          { return (flags & AFL_TI0)      != 0; }
inline constexpr bool has_aflag_ti1(aflags_t flags)          { return (flags & AFL_TI1)      != 0; }
inline constexpr bool has_aflag_lname(aflags_t flags)        { return (flags & AFL_LNAME)    != 0; }
inline constexpr bool is_aflag_tilcmt(aflags_t flags)        { return (flags & AFL_TILCMT)   != 0; }
inline constexpr bool is_aflag_lzero0(aflags_t flags)        { return (flags & AFL_LZERO0)   != 0; }
inline constexpr bool is_aflag_lzero1(aflags_t flags)        { return (flags & AFL_LZERO1)   != 0; }
inline constexpr bool is_aflag_colored_item(aflags_t flags)  { return (flags & AFL_COLORED)  != 0; }
inline constexpr bool is_aflag_terse_struc(aflags_t flags)   { return (flags & AFL_TERSESTR) != 0; }
inline constexpr bool is_aflag__invsign0(aflags_t flags)     { return (flags & AFL_SIGN0)    != 0; }
inline constexpr bool is_aflag__invsign1(aflags_t flags)     { return (flags & AFL_SIGN1)    != 0; }
inline constexpr bool is_aflag_noret(aflags_t flags)         { return (flags & AFL_NORET)    != 0; }
inline constexpr bool is_aflag_fixed_spd(aflags_t flags)     { return (flags & AFL_FIXEDSPD) != 0; }
inline constexpr bool is_aflag_align_flow(aflags_t flags)    { return (flags & AFL_ALIGNFLOW)!= 0; }
inline constexpr bool is_aflag_userti(aflags_t flags)        { return (flags & AFL_USERTI)   != 0; }
inline constexpr bool is_aflag_retfp(aflags_t flags)         { return (flags & AFL_RETFP)    != 0; }
inline constexpr bool uses_aflag_modsp(aflags_t flags)       { return (flags & AFL_USEMODSP) != 0; }
inline constexpr bool is_aflag_notcode(aflags_t flags)       { return (flags & AFL_NOTCODE)  != 0; }
inline constexpr bool is_aflag_notproc(aflags_t flags)       { return (flags & AFL_NOTPROC)  != 0; }
inline constexpr bool is_aflag_type_guessed_by_ida(aflags_t flags)        { return (flags & AFL_TYPE_GUESSED) == AFL_IDA_GUESSED;     }
inline constexpr bool is_aflag_func_guessed_by_hexrays(aflags_t flags)    { return (flags & AFL_TYPE_GUESSED) == AFL_HR_GUESSED_FUNC; }
inline constexpr bool is_aflag_data_guessed_by_hexrays(aflags_t flags)    { return (flags & AFL_TYPE_GUESSED) == AFL_HR_GUESSED_DATA; }
inline constexpr bool is_aflag_type_determined_by_hexrays(aflags_t flags) { return (flags & AFL_TYPE_GUESSED) == AFL_HR_DETERMINED;   }
inline constexpr bool is_aflag_type_guessed_by_hexrays(aflags_t flags)
{
  return (flags & AFL_TYPE_GUESSED) == AFL_HR_GUESSED_FUNC
      || (flags & AFL_TYPE_GUESSED) == AFL_HR_GUESSED_DATA
      || (flags & AFL_TYPE_GUESSED) == AFL_HR_DETERMINED;
}
 
inline bool is_hidden_item(ea_t ea)   { return is_aflag_hidden_item(get_aflags(ea)); }
inline void hide_item(ea_t ea)        { set_abits(ea, AFL_HIDDEN); }
inline void unhide_item(ea_t ea)      { clr_abits(ea, AFL_HIDDEN); }
 
inline bool is_hidden_border(ea_t ea) { return is_aflag_hidden_border(get_aflags(ea)); }
inline void hide_border(ea_t ea)      { set_abits(ea, AFL_NOBRD); }
inline void unhide_border(ea_t ea)    { clr_abits(ea, AFL_NOBRD); }
 
inline bool uses_modsp(ea_t ea)       { return uses_aflag_modsp(get_aflags(ea)); }
inline void set_usemodsp(ea_t ea)     { set_abits(ea, AFL_USEMODSP); }
inline void clr_usemodsp(ea_t ea)     { clr_abits(ea, AFL_USEMODSP); }
 
inline bool is_zstroff(ea_t ea)       { return is_aflag_zstroff(get_aflags(ea)); }
inline void set_zstroff(ea_t ea)      { set_abits(ea, AFL_ZSTROFF); }
inline void clr_zstroff(ea_t ea)      { clr_abits(ea, AFL_ZSTROFF); }
 
inline bool is__bnot0(ea_t ea)        { return is_aflag__bnot0(get_aflags(ea)); }
inline void set__bnot0(ea_t ea)       { set_abits(ea, AFL_BNOT0); }
inline void clr__bnot0(ea_t ea)       { clr_abits(ea, AFL_BNOT0); }
 
inline bool is__bnot1(ea_t ea)        { return is_aflag__bnot1(get_aflags(ea)); }
inline void set__bnot1(ea_t ea)       { set_abits(ea, AFL_BNOT1); }
inline void clr__bnot1(ea_t ea)       { clr_abits(ea, AFL_BNOT1); }
 
inline bool is_libitem(ea_t ea)       { return is_aflag_libitem(get_aflags(ea)); }
inline void set_libitem(ea_t ea)      { set_abits(ea, AFL_LIB); }
inline void clr_libitem(ea_t ea)      { clr_abits(ea, AFL_LIB); }
 
inline bool has_ti(ea_t ea)           { return has_aflag_ti(get_aflags(ea)); }
inline void set_has_ti(ea_t ea)       { set_abits(ea, AFL_TI); }
inline void clr_has_ti(ea_t ea)       { clr_abits(ea, AFL_TI); }
 
inline bool has_ti0(ea_t ea)          { return has_aflag_ti0(get_aflags(ea)); }
inline void set_has_ti0(ea_t ea)      { set_abits(ea, AFL_TI0); }
inline void clr_has_ti0(ea_t ea)      { clr_abits(ea, AFL_TI0); }
 
inline bool has_ti1(ea_t ea)          { return has_aflag_ti1(get_aflags(ea)); }
inline void set_has_ti1(ea_t ea)      { set_abits(ea, AFL_TI1); }
inline void clr_has_ti1(ea_t ea)      { clr_abits(ea, AFL_TI1); }
 
inline bool has_lname(ea_t ea)        { return has_aflag_lname(get_aflags(ea)); }
inline void set_has_lname(ea_t ea)    { set_abits(ea, AFL_LNAME); }
inline void clr_has_lname(ea_t ea)    { clr_abits(ea, AFL_LNAME); }
 
inline bool is_tilcmt(ea_t ea)        { return is_aflag_tilcmt(get_aflags(ea)); }
inline void set_tilcmt(ea_t ea)       { set_abits(ea, AFL_TILCMT); }
inline void clr_tilcmt(ea_t ea)       { clr_abits(ea, AFL_TILCMT); }
 
inline bool is_usersp(ea_t ea)        { return is_aflag_usersp(get_aflags(ea)); }
inline void set_usersp(ea_t ea)       { set_abits(ea, AFL_USERSP); }
inline void clr_usersp(ea_t ea)       { clr_abits(ea, AFL_USERSP); }
 
inline bool is_lzero0(ea_t ea)        { return is_aflag_lzero0(get_aflags(ea)); }
inline void set_lzero0(ea_t ea)       { set_abits(ea, AFL_LZERO0); }
inline void clr_lzero0(ea_t ea)       { clr_abits(ea, AFL_LZERO0); }
 
inline bool is_lzero1(ea_t ea)        { return is_aflag_lzero1(get_aflags(ea)); }
inline void set_lzero1(ea_t ea)       { set_abits(ea, AFL_LZERO1); }
inline void clr_lzero1(ea_t ea)       { clr_abits(ea, AFL_LZERO1); }
 
inline bool is_colored_item(ea_t ea)  { return is_aflag_colored_item(get_aflags(ea)); }
inline void set_colored_item(ea_t ea) { set_abits(ea, AFL_COLORED); } // use set_item_color()
inline void clr_colored_item(ea_t ea) { clr_abits(ea, AFL_COLORED); } // use del_item_color()
 
inline bool is_terse_struc(ea_t ea)   { return is_aflag_terse_struc(get_aflags(ea)); }
inline void set_terse_struc(ea_t ea)  { set_abits(ea, AFL_TERSESTR); }
inline void clr_terse_struc(ea_t ea)  { clr_abits(ea, AFL_TERSESTR); }
 
inline bool is__invsign0(ea_t ea)     { return is_aflag__invsign0(get_aflags(ea)); }
inline void set__invsign0(ea_t ea)    { set_abits(ea, AFL_SIGN0); }
inline void clr__invsign0(ea_t ea)    { clr_abits(ea, AFL_SIGN0); }
 
inline bool is__invsign1(ea_t ea)     { return is_aflag__invsign1(get_aflags(ea)); }
inline void set__invsign1(ea_t ea)    { set_abits(ea, AFL_SIGN1); }
inline void clr__invsign1(ea_t ea)    { clr_abits(ea, AFL_SIGN1); }
 
inline bool is_noret(ea_t ea)         { return is_aflag_noret(get_aflags(ea)); }
inline void set_noret(ea_t ea)        { set_abits(ea, AFL_NORET); }
inline void clr_noret(ea_t ea)        { clr_abits(ea, AFL_NORET); }
 
inline bool is_fixed_spd(ea_t ea)     { return is_aflag_fixed_spd(get_aflags(ea)); }
inline void set_fixed_spd(ea_t ea)    { set_abits(ea, AFL_FIXEDSPD); }
inline void clr_fixed_spd(ea_t ea)    { clr_abits(ea, AFL_FIXEDSPD); }
 
inline bool is_align_flow(ea_t ea)    { return is_aflag_align_flow(get_aflags(ea)); }
inline void set_align_flow(ea_t ea)   { set_abits(ea, AFL_ALIGNFLOW); }
inline void clr_align_flow(ea_t ea)   { clr_abits(ea, AFL_ALIGNFLOW); }
 
inline bool is_userti(ea_t ea)        { return is_aflag_userti(get_aflags(ea)); }
inline void set_userti(ea_t ea)       { upd_abits(ea, AFL_TYPE_GUESSED, AFL_USERTI); }
inline void clr_userti(ea_t ea)       { clr_abits(ea, AFL_TYPE_GUESSED); } // use set_ida_guessed_type()
 
inline bool is_retfp(ea_t ea)         { return is_aflag_retfp(get_aflags(ea)); }
inline void set_retfp(ea_t ea)        { set_abits(ea, AFL_RETFP); }
inline void clr_retfp(ea_t ea)        { clr_abits(ea, AFL_RETFP); }
 
inline bool is_notproc(ea_t ea)       { return is_aflag_notproc(get_aflags(ea)); }
inline void set_notproc(ea_t ea)      { set_abits(ea, AFL_NOTPROC); }
inline void clr_notproc(ea_t ea)      { clr_abits(ea, AFL_NOTPROC); }
 
inline bool is_type_guessed_by_ida(ea_t ea)        { return is_aflag_type_guessed_by_ida(get_aflags(ea));        }
inline bool is_func_guessed_by_hexrays(ea_t ea)    { return is_aflag_func_guessed_by_hexrays(get_aflags(ea));    }
inline bool is_data_guessed_by_hexrays(ea_t ea)    { return is_aflag_data_guessed_by_hexrays(get_aflags(ea));    }
inline bool is_type_determined_by_hexrays(ea_t ea) { return is_aflag_type_determined_by_hexrays(get_aflags(ea)); }
inline bool is_type_guessed_by_hexrays(ea_t ea)    { return is_aflag_type_guessed_by_hexrays(get_aflags(ea));    }
 
inline void set_type_guessed_by_ida(ea_t ea)        { upd_abits(ea, AFL_TYPE_GUESSED, AFL_IDA_GUESSED);     }
inline void set_func_guessed_by_hexrays(ea_t ea)    { upd_abits(ea, AFL_TYPE_GUESSED, AFL_HR_GUESSED_FUNC); }
inline void set_data_guessed_by_hexrays(ea_t ea)    { upd_abits(ea, AFL_TYPE_GUESSED, AFL_HR_GUESSED_DATA); }
inline void set_type_determined_by_hexrays(ea_t ea) { upd_abits(ea, AFL_TYPE_GUESSED, AFL_HR_DETERMINED);   }

idaman void ida_export set_notcode(ea_t ea);

inline void clr_notcode(ea_t ea) { clr_abits(ea, AFL_NOTCODE); }

inline bool is_notcode(ea_t ea) { return is_aflag_notcode(get_aflags(ea)); }
 

 
inline void set_visible_item(ea_t ea, bool visible)
{
  if ( visible )
    unhide_item(ea);
  else
    hide_item(ea);
}

 
inline bool is_visible_item(ea_t ea) { return !is_hidden_item(ea); }
 

 
inline bool is_finally_visible_item(ea_t ea)
{
  return (inf_get_cmtflg() & SCF_SHHID_ITEM) != 0 || is_visible_item(ea);
}
 

idaman void   ida_export set_source_linnum(ea_t ea, uval_t lnnum);
idaman uval_t ida_export get_source_linnum(ea_t ea);
idaman void   ida_export del_source_linnum(ea_t ea);

inline ea_t get_absbase(ea_t ea)
{
  ea_t x;
  return getnode(ea).supval(NALT_ABSBASE, &x, sizeof(x), atag) > 0 ? ea_t(x-1) : ea_t(-1);
}
inline void set_absbase(ea_t ea, ea_t x)
{
  x++;
  getnode(ea).supset(NALT_ABSBASE, &x, sizeof(x), atag);
}
inline void del_absbase(ea_t ea) { getnode(ea).supdel(NALT_ABSBASE, atag); }

idaman ea_t ida_export get_ind_purged(ea_t ea);
inline void set_ind_purged(ea_t ea, ea_t x)
{
  x++;
  getnode(ea).supset(NALT_PURGE, &x, sizeof(x), atag);
}
inline void del_ind_purged(ea_t ea) { getnode(ea).supdel(NALT_PURGE, atag); }

idaman uint32 ida_export get_str_type(ea_t ea);
idaman void   ida_export set_str_type(ea_t ea, uint32 x);
idaman void   ida_export del_str_type(ea_t ea);
 
// Number of bytes per "units" in a string. E.g., ASCII, Windows-1252,
// UTF-8 all take up one byte per unit, while UTF-16 variations take 2 and
// UTF-32 variations take 4.
// (Note that an "unit" in this context is not necessarily a character,
// since UTF-8-encoded characters can be encoded in up to 4 bytes,
// and UTF-16-encoded characters can be encoded in up to 2 bytes.)
#define STRWIDTH_1B 0
#define STRWIDTH_2B 1
#define STRWIDTH_4B 2
#define STRWIDTH_MASK 0x03
 
// The string layout; how the string is laid out in data.
#define STRLYT_TERMCHR 0
#define STRLYT_PASCAL1 1
#define STRLYT_PASCAL2 2
#define STRLYT_PASCAL4 3
#define STRLYT_DECOMP  4
#define STRLYT_MASK 0xFC
#define STRLYT_SHIFT 2
 

#define STRTYPE_TERMCHR   (STRWIDTH_1B|STRLYT_TERMCHR<<STRLYT_SHIFT) 
#define STRTYPE_C         STRTYPE_TERMCHR
#define STRTYPE_C_16      (STRWIDTH_2B|STRLYT_TERMCHR<<STRLYT_SHIFT)
#define STRTYPE_C_32      (STRWIDTH_4B|STRLYT_TERMCHR<<STRLYT_SHIFT)
#define STRTYPE_PASCAL    (STRWIDTH_1B|STRLYT_PASCAL1<<STRLYT_SHIFT)
#define STRTYPE_PASCAL_16 (STRWIDTH_2B|STRLYT_PASCAL1<<STRLYT_SHIFT)
#define STRTYPE_PASCAL_32 (STRWIDTH_4B|STRLYT_PASCAL1<<STRLYT_SHIFT)
#define STRTYPE_LEN2      (STRWIDTH_1B|STRLYT_PASCAL2<<STRLYT_SHIFT)
#define STRTYPE_LEN2_16   (STRWIDTH_2B|STRLYT_PASCAL2<<STRLYT_SHIFT)
#define STRTYPE_LEN2_32   (STRWIDTH_4B|STRLYT_PASCAL2<<STRLYT_SHIFT)
#define STRTYPE_LEN4      (STRWIDTH_1B|STRLYT_PASCAL4<<STRLYT_SHIFT)
#define STRTYPE_LEN4_16   (STRWIDTH_2B|STRLYT_PASCAL4<<STRLYT_SHIFT)
#define STRTYPE_LEN4_32   (STRWIDTH_4B|STRLYT_PASCAL4<<STRLYT_SHIFT)
#define STRTYPE_DECOMP    (STRWIDTH_1B|STRLYT_DECOMP<<STRLYT_SHIFT)

inline THREAD_SAFE uchar idaapi get_str_type_code(int32 strtype) { return uchar(strtype); }
inline THREAD_SAFE char get_str_term1(int32 strtype) { return char(strtype>>8); }
inline THREAD_SAFE char get_str_term2(int32 strtype) { return char(strtype>>16); }
                                // if the second termination character is
                                // '\0', then it doesn't exist.
inline THREAD_SAFE uchar idaapi get_str_encoding_idx(int32 strtype) { return uchar(strtype>>24); }
inline THREAD_SAFE int32 set_str_encoding_idx(int32 strtype, int encoding_idx)
{
  return (strtype & 0xFFFFFF) | ((uchar)encoding_idx << 24);
}

inline THREAD_SAFE int32 make_str_type(
        uchar type_code,
        int encoding_idx,
        uchar term1 = 0,
        uchar term2 = 0)
{
  return type_code
       | (term1 << 8)
       | (term2 << 16)
       | ((uchar)encoding_idx << 24);
}
 
 
inline THREAD_SAFE bool is_pascal(int32 strtype)
{
  int lyt = get_str_type_code(strtype) >> STRLYT_SHIFT;
  return lyt >= STRLYT_PASCAL1 && lyt <= STRLYT_PASCAL4;
}
 
inline THREAD_SAFE size_t get_str_type_prefix_length(int32 strtype)
{
  switch ( get_str_type_code(strtype) )
  {
    case STRTYPE_LEN4_32:
    case STRTYPE_LEN4_16:
    case STRTYPE_LEN4:
      return 4;
    case STRTYPE_LEN2_32:
    case STRTYPE_LEN2_16:
    case STRTYPE_LEN2:
      return 2;
    case STRTYPE_PASCAL_32:
    case STRTYPE_PASCAL_16:
    case STRTYPE_PASCAL:
      return 1;
  }
  return 0;
}

 
#define STRENC_DEFAULT 0x00  
#define STRENC_NONE    0xFF  

inline uint32 get_alignment(ea_t ea)
{
  uint32 x;
  return getnode(ea).supval(NALT_ALIGN, &x, sizeof(x), atag) > 0 ? uint32(x-1) : uint32(-1);
}
inline void set_alignment(ea_t ea, uint32 x)
{
  x++;
  getnode(ea).supset(NALT_ALIGN, &x, sizeof(x), atag);
}
inline void del_alignment(ea_t ea) { getnode(ea).supdel(NALT_ALIGN, atag); }
 

idaman void      ida_export set_item_color(ea_t ea, bgcolor_t color);
idaman bgcolor_t ida_export get_item_color(ea_t ea);      // returns DEFCOLOR if no color
idaman bool      ida_export del_item_color(ea_t ea);
 
 
//-------------------------------------------------------------------------
struct array_parameters_t
{
  int32 flags;
#define AP_ALLOWDUPS    0x00000001      
#define AP_SIGNED       0x00000002      
#define AP_INDEX        0x00000004      
#define AP_ARRAY        0x00000008      
#define AP_IDXBASEMASK  0x000000F0      
#define   AP_IDXDEC     0x00000000      
#define   AP_IDXHEX     0x00000010      
#define   AP_IDXOCT     0x00000020      
#define   AP_IDXBIN     0x00000030      
 
  int32 lineitems;                      
  int32 alignment;                      
 
  array_parameters_t(int32 _f=AP_ALLOWDUPS, int32 _l=0, int32 _a=-1) : flags(_f), lineitems(_l), alignment(_a) {}
  bool is_default() const { return flags == AP_ALLOWDUPS && lineitems == 0 && alignment == -1; }
};
idaman ssize_t ida_export get_array_parameters(array_parameters_t *out, ea_t ea);
idaman void ida_export set_array_parameters(ea_t ea, const array_parameters_t *in);
inline void idaapi del_array_parameters(ea_t ea) { getnode(ea).supdel(NSUP_ARRAY); }
 
//--------------------------------------------------------------------------
struct switch_info_t
{
  uint32 flags;                    
#define SWI_SPARSE      0x00000001 
#define SWI_V32         0x00000002 
#define SWI_J32         0x00000004 
#define SWI_VSPLIT      0x00000008 
#define SWI_USER        0x00000010 
#define SWI_DEF_IN_TBL  0x00000020 
#define SWI_JMP_INV     0x00000040 
#define SWI_SHIFT_MASK  0x00000180 
#define SWI_ELBASE      0x00000200 
#define SWI_JSIZE       0x00000400 
#define SWI_VSIZE       0x00000800 
#define SWI_SEPARATE    0x00001000 
#define SWI_SIGNED      0x00002000 
#define SWI_CUSTOM      0x00004000 
//#define SWI_EXTENDED  0x00008000 ///< reserved
#define SWI_INDIRECT    0x00010000 
#define SWI_SUBTRACT    0x00020000 
#define SWI_HXNOLOWCASE 0x00040000 
#define SWI_STDTBL      0x00080000 
#define SWI_DEFRET      0x00100000 
#define SWI_SELFREL     0x00200000 
#define SWI_JMPINSN     0x00400000 
#define SWI_VERSION     0x00800000 

  int get_shift(void) const { return ((flags & SWI_SHIFT_MASK) >> 7); }

  void set_shift(int shift)
  {
    flags &= ~SWI_SHIFT_MASK;
    flags |= ((shift & 3) << 7);
  }
 
  int get_jtable_element_size(void) const
  { // this brain damaged logic is needed for compatibility with old versions
    int code = flags & (SWI_J32|SWI_JSIZE);
    if ( code == 0 )
      return 2;
    if ( code == SWI_J32 )
      return 4;
    if ( code == SWI_JSIZE )
      return 1;
    return 8;
  }
  void set_jtable_element_size(int size)
  {
    flags &= ~(SWI_J32|SWI_JSIZE);
    switch ( size )
    {
      case 4:
        flags |= SWI_J32;
        break;
      case 1:
        flags |= SWI_JSIZE;
        break;
      case 8:
        flags |= SWI_J32|SWI_JSIZE;
        break;
      case 2:
        break;
      default:
        INTERR(1297);
    }
  }
  int get_vtable_element_size(void) const
  {
    int code = flags & (SWI_V32|SWI_VSIZE);
    if ( code == 0 )
      return 2;
    if ( code == SWI_V32 )
      return 4;
    if ( code == SWI_VSIZE )
      return 1;
    return 8;
  }
  void set_vtable_element_size(int size)
  {
    flags &= ~(SWI_V32|SWI_VSIZE);
    switch ( size )
    {
      case 4:
        flags |= SWI_V32;
        break;
      case 1:
        flags |= SWI_VSIZE;
        break;
      case 8:
        flags |= SWI_V32|SWI_VSIZE;
        break;
      case 2:
        break;
      default:
        INTERR(1298);
    }
  }
 
  bool has_default(void)  const { return defjump != BADADDR;             }
  bool has_elbase(void)   const { return (flags & SWI_ELBASE)      != 0; }
  bool is_sparse(void)    const { return (flags & SWI_SPARSE)      != 0; }
  bool is_custom(void)    const { return (flags & SWI_CUSTOM)      != 0; }
  bool is_indirect(void)  const { return (flags & SWI_INDIRECT)    != 0; }
  bool is_subtract(void)  const { return (flags & SWI_SUBTRACT)    != 0; }
  bool is_nolowcase(void) const { return (flags & SWI_HXNOLOWCASE) != 0; }
  bool use_std_table(void) const { return !is_custom() || (flags & SWI_STDTBL) != 0; }
  bool is_user_defined() const
  {
    return get_version() >= 2 && (flags & SWI_USER) != 0;
  }
 
  ushort ncases = 0;            
  ea_t jumps = BADADDR;         
  union
  {
    ea_t values;                
    uval_t lowcase;             
  };
  ea_t defjump = BADADDR;       
  ea_t startea = BADADDR;       
  int jcases = 0;               
 
  sval_t ind_lowcase = 0;
  sval_t get_lowcase(void) const { return is_indirect() ? ind_lowcase : lowcase; }
  ea_t elbase = 0;              
 
  int regnum = -1;              
  op_dtype_t regdtype = 0;      
 
  int get_jtable_size(void) const { return is_indirect() ? jcases : ncases; }
  void set_jtable_size(int size)
  {
    if ( is_indirect() )
      jcases = size;
    else
      ncases = uint16(size);
  }
  void set_elbase(ea_t base)
  {
    elbase = base;
    flags |= SWI_ELBASE;
  }
 
  void set_expr(int r, op_dtype_t dt) { regnum = r; regdtype = dt; }

  bool get_jrange_vrange(range_t *jrange = nullptr, range_t *vrange = nullptr) const
  {
    if ( !use_std_table() )
      return false;
    if ( jrange != nullptr )
    {
      int n = get_jtable_size();
      if ( (flags & SWI_DEF_IN_TBL) != 0 )
        ++n;
      int jsize = get_jtable_element_size();
      *jrange = range_t(jumps, jumps + jsize * n);
    }
    if ( vrange != nullptr && is_sparse() )
    {
      int vsize = get_vtable_element_size();
      *vrange = range_t(values, values + vsize * ncases);
    }
    return true;
  }
 
  uval_t custom = 0;            
 
  enum { SWITCH_INFO_VERSION = 2 };
  int version = SWITCH_INFO_VERSION;
  int get_version() const { return (flags & SWI_VERSION) == 0 ? 1 : version; }
 
  // version 2
  ea_t expr_ea = BADADDR;       
  eavec_t marks;                
 
  switch_info_t() : flags(SWI_VERSION), lowcase(0) {}
  void clear() { *this = switch_info_t(); }
};

idaman ssize_t ida_export get_switch_info(switch_info_t *out, ea_t ea);
idaman void ida_export set_switch_info(ea_t ea, const switch_info_t &in);
idaman void ida_export del_switch_info(ea_t ea);

inline ea_t get_switch_parent(ea_t ea)
{
  ea_t x;
  return getnode(ea).supval(NALT_SWITCH, &x, sizeof(x), atag) > 0 ? ea_t(x-1) : ea_t(-1);
}
inline void set_switch_parent(ea_t ea, ea_t x)
{
  x++;
  getnode(ea).supset(NALT_SWITCH, &x, sizeof(x), atag);
}
inline void del_switch_parent(ea_t ea) { getnode(ea).supdel(NALT_SWITCH, atag); }

struct custom_data_type_ids_t
{
  int16 dtid;               
  int16 fids[UA_MAXOP];     
 
  void set(tid_t tid)
  {
    memset(fids, -1, sizeof(fids));
    dtid = uint16(tid);
    fids[0] = uint16(tid >> 16);
  }
  tid_t get_dtid() const
  {
    return uint16(dtid) | (uint16(-1) << 16);
  }
#ifndef SWIG
  DECLARE_COMPARISONS(custom_data_type_ids_t);
#endif
};
idaman int  ida_export get_custom_data_type_ids(custom_data_type_ids_t *cdis, ea_t ea);
idaman void ida_export set_custom_data_type_ids(ea_t ea, const custom_data_type_ids_t *cdis);
inline void idaapi del_custom_data_type_ids(ea_t ea) { getnode(ea).supdel(NSUP_CUSTDT); }
 
typedef uchar reftype_t;  
const reftype_t
  V695_REF_OFF8 = 0,      
  REF_OFF16  = 1,         
  REF_OFF32  = 2,         
  REF_LOW8   = 3,         
  REF_LOW16  = 4,         
  REF_HIGH8  = 5,         
  REF_HIGH16 = 6,         
  V695_REF_VHIGH  = 7,    
  V695_REF_VLOW   = 8,    
  REF_OFF64  = 9,         
  REF_OFF8   = 10,        
  REF_LOW32  = 11,        
  REF_HIGH32 = 12,        
  REF_LAST = REF_HIGH32;

 
inline bool is_reftype_target_optional(reftype_t type);

 
idaman reftype_t ida_export get_reftype_by_size(size_t size);

struct refinfo_t
{
  ea_t    target;                 
  ea_t    base;                   
  adiff_t tdelta;                 
  uint32  flags;                  
#define REFINFO_TYPE      0x000F  
#define REFINFO_RVAOFF    0x0010  
#define REFINFO_PASTEND   0x0020  
#define REFINFO_CUSTOM    0x0040  
#define REFINFO_NOBASE    0x0080  
#define REFINFO_SUBTRACT  0x0100  
#define REFINFO_SIGNEDOP  0x0200  
#define REFINFO_IGNZERO   0x0400  
#define REFINFO_NO_ZEROS  REFINFO_IGNZERO 
#define REFINFO_NO_ONES   0x0800  
#define REFINFO_SELFREF   0x1000  
#define REFINFO_USER      0x2000  
 
  reftype_t type(void) const
  {
    return reftype_t(flags & (REFINFO_TYPE | REFINFO_CUSTOM));
  }
 
  bool is_target_optional() const 
  {
    reftype_t rt = flags & (REFINFO_TYPE | REFINFO_CUSTOM);
    return is_reftype_target_optional(rt);
  }
 
  bool no_base_xref(void) const { return (flags & REFINFO_NOBASE) != 0; }
  bool is_pastend(void)   const { return (flags & REFINFO_PASTEND) != 0; }
  bool is_rvaoff(void)    const { return (flags & REFINFO_RVAOFF) != 0; }
  bool is_custom(void)    const { return (flags & REFINFO_CUSTOM) != 0; }
  bool is_subtract(void)  const { return (flags & REFINFO_SUBTRACT) != 0; }
  bool is_signed(void)    const { return (flags & REFINFO_SIGNEDOP) != 0; }
  bool is_ignore_zero(void) const { return (flags & REFINFO_IGNZERO) != 0; }
  bool is_no_zeros(void)  const { return is_ignore_zero(); } 
  bool is_no_ones(void)   const { return (flags & REFINFO_NO_ONES) != 0; }
  bool is_selfref(void)   const { return (flags & REFINFO_SELFREF) != 0; }
  bool is_user(void)      const { return (flags & REFINFO_USER) != 0; }
 
  // RT can include REFINFO_CUSTOM bit
  void set_type(reftype_t rt)
  {
    flags &= ~(REFINFO_TYPE | REFINFO_CUSTOM);
    flags |= rt;
  }
 
  // init the structure with some default values
  // reft_and_flags should be REF_xxx optionally ORed with some REFINFO_xxx flags
  void init(uint32 reft_and_flags, ea_t _base = 0, ea_t _target = BADADDR, adiff_t _tdelta = 0)
  {
    flags = reft_and_flags;
    base = _base;
    target = _target;
    tdelta = _tdelta;
  }
 
  // internal use
#ifndef SWIG
  bool _require_base() const { return !is_rvaoff() && !is_selfref(); }
  DECLARE_COMPARISONS(refinfo_t);
#endif
};

struct custom_refinfo_handler_t
{
  int32 cbsize;                 
  const char *name;             
  const char *desc;             
  int props;                    
#define RHF_TGTOPT 0x0001       
 
  // this callback prepares the full offset expression in buf and
  // returns 1 if it is a simple expression or 2 if it is a complex one.
  // Or this callback checks the compliance of opval and fullvalue,
  // and possibly updates values of target and fullvalue,
  // and prepares the format,
  // and returns 3 to continue standard processing with updated values.
  // Or this callback just prepares the format and returns 4 to continue.
  // It returns 0 in the case of error.
  // It is guaranteed that before calling this callback, the
  // calc_reference_data() callback is always called.
  int (idaapi *gen_expr)(
        qstring *buf,
        qstring *format,      // buffer for the format (if retcode>=3)
        ea_t ea,
        int opnum,
        const refinfo_t &ri,
        ea_t from,
        adiff_t *opval,       // the output value is not used
        ea_t *target,         // the target prepared by calc_reference_data()
        ea_t *fullvalue,
        int getn_flags);
 
  // this callback replaces calc_target.
  // It calculates target and base,
  // and calculates an internal variable fullvalue,
  // and checks the compliance of opval and fullvalue,
  // and returns the success flag.
  bool (idaapi *calc_reference_data)(
        ea_t *target,
        ea_t *base,
        ea_t from,
        const refinfo_t &ri,
        adiff_t opval);
 
  // just custom format
  void (idaapi *get_format)(qstring *format);
 
#ifndef SWIG
  DECLARE_COMPARISONS(custom_refinfo_handler_t);
#endif
};
 

 
idaman int ida_export register_custom_refinfo(const custom_refinfo_handler_t *crh);
 

 
idaman bool ida_export unregister_custom_refinfo(int crid);
 

 
idaman int ida_export find_custom_refinfo(const char *name);
 

 
idaman const custom_refinfo_handler_t *ida_export get_custom_refinfo(int crid);
 

 
inline const custom_refinfo_handler_t *idaapi get_custom_refinfo_handler(
        const refinfo_t &ri)
{
  return ri.is_custom() ? get_custom_refinfo(ri.type()) : nullptr;
}
 
// inline implementation
inline bool is_reftype_target_optional(reftype_t type)
{
  if ( (type & REFINFO_CUSTOM) != 0 )
  {
    const custom_refinfo_handler_t *cfh = get_custom_refinfo(type);
    if ( cfh == nullptr )
      return false;
    return (cfh->props & RHF_TGTOPT) != 0;
  }
  switch ( type )
  {
    case REF_OFF8:
    case REF_OFF16:
    case REF_OFF32:
    case REF_OFF64:
      return true;
  }
  return false;
}
 

 
struct refinfo_desc_t
{
  uint32 type;      
  const char *name; 
  const char *desc; 
};
DECLARE_TYPE_AS_MOVABLE(refinfo_desc_t);
typedef qvector<refinfo_desc_t> refinfo_desc_vec_t;
idaman void ida_export get_refinfo_descs(refinfo_desc_vec_t *descs);
 
 
#define MAXSTRUCPATH  32        

struct strpath_t
{
  int len;
  tid_t ids[MAXSTRUCPATH]; // for union member ids
  adiff_t delta;
#ifndef SWIG
  DECLARE_COMPARISONS(strpath_t);
#endif
};

struct enum_const_t
{
  tid_t tid;
  uchar serial;
#ifndef SWIG
  DECLARE_COMPARISONS(enum_const_t)
  {
    COMPARE_FIELDS(tid);
    COMPARE_FIELDS(serial);
    return 0;
  }
#endif
};

union opinfo_t
{
  refinfo_t ri;              
  tid_t tid;                 
  strpath_t path;            
  int32 strtype;             
  enum_const_t ec;           
  custom_data_type_ids_t cd; 
#ifndef SWIG
  int compare_opinfos(const opinfo_t &r, flags64_t flag, int n) const;
#endif
};
 
//-------------------------------------------------------------------------
 
struct printop_t
{
  uint32 unused = 0;    // not used anymore, use flags64 instead (kept for backward compat)
  opinfo_t ti;          // new operand type
#define POF_VALID_TI     0x1 // is operand type initialized?
#define POF_VALID_AFLAGS 0x2 // internal
#define POF_IS_F64       0x4 // internal
  uchar features;       // features this instance holds
  int suspop = 0;       // out: will be set by print_operand()
  aflags_t aflags = 0;  // additional aflags
  flags64_t flags = 0;  // new operand representation flags
 
  printop_t() : features(POF_IS_F64) { memset(&ti, 0, sizeof(ti)); }
  bool is_ti_initialized() const { return (features & POF_VALID_TI) != 0; }
  void set_ti_initialized(bool v=true) { setflag(features, POF_VALID_TI, v); }
  bool is_aflags_initialized() const { return (features & POF_VALID_AFLAGS) != 0; }
  void set_aflags_initialized(bool v=true) { setflag(features, POF_VALID_AFLAGS, v); }
  bool is_f64() const { return (features & POF_IS_F64) != 0; }
 
  const opinfo_t *get_ti() const { return is_ti_initialized() ? &ti : nullptr; }
};

idaman bool ida_export set_refinfo_ex(ea_t ea, int n, const refinfo_t *ri);
idaman bool ida_export set_refinfo(
        ea_t ea,
        int n,
        reftype_t type,
        ea_t target=BADADDR,
        ea_t base=0,
        adiff_t tdelta=0);
idaman bool ida_export get_refinfo(refinfo_t *ri, ea_t ea, int n);
idaman bool ida_export del_refinfo(ea_t ea, int n);
 
//--------------------------------------------------------------------------
idaman void ida_export write_struc_path(ea_t ea, int idx, const tid_t *path, int plen, adiff_t delta);
idaman int  ida_export read_struc_path(tid_t *path, adiff_t *delta, ea_t ea, int idx);  // returns plen

 
 
//--------------------------------------------------------------------------
// type information (ti) storage
// up to 256 operands are supported for ti.
 
typedef uchar type_t;
typedef uchar p_list;
class tinfo_t;

idaman bool ida_export get_tinfo(tinfo_t *tif, ea_t ea);
idaman bool ida_export set_tinfo(ea_t ea, const tinfo_t *tif);
inline void idaapi del_tinfo(ea_t ea) { set_tinfo(ea, nullptr); }

idaman bool ida_export get_op_tinfo(tinfo_t *tif, ea_t ea, int n);
idaman bool ida_export set_op_tinfo(ea_t ea, int n, const tinfo_t *tif);
inline void idaapi del_op_tinfo(ea_t ea, int n) { set_op_tinfo(ea, n, nullptr); }
 
//------------------------------------------------------------------------//
 
// supvals
#define RIDX_FILE_FORMAT_NAME        1     
#define RIDX_SELECTORS               2     
#define RIDX_GROUPS                 64     
#define RIDX_H_PATH                 65     
#define RIDX_C_MACROS               66     
#define RIDX_SMALL_IDC_OLD          67     
#define RIDX_NOTEPAD                68     
#define RIDX_INCLUDE              1100     
#define RIDX_SMALL_IDC            1200     
#define RIDX_DUALOP_GRAPH         1300     
#define RIDX_DUALOP_TEXT          1301     
#define RIDX_MD5                  1302     
#define RIDX_IDA_VERSION          1303     
 
#define RIDX_STR_ENCODINGS        1305     
#define RIDX_SRCDBG_PATHS         1306     
#define RIDX_DBG_BINPATHS         1328     
#define RIDX_SHA256               1349     
#define RIDX_ABINAME              1350     
#define RIDX_ARCHIVE_PATH         1351     
#define RIDX_PROBLEMS             1352     
#define RIDX_SRCDBG_UNDESIRED     1353     
 
// altvals
#define RIDX_ALT_VERSION        uval_t(-1) 
#define RIDX_ALT_CTIME          uval_t(-2) 
#define RIDX_ALT_ELAPSED        uval_t(-3) 
#define RIDX_ALT_NOPENS         uval_t(-4) 
#define RIDX_ALT_CRC32          uval_t(-5) 
#define RIDX_ALT_IMAGEBASE      uval_t(-6) 
#define RIDX_ALT_IDSNODE        uval_t(-7) 
#define RIDX_ALT_FSIZE          uval_t(-8) 
#define RIDX_ALT_OUTFILEENC     uval_t(-9) 
 
//---------------------------------------------------------------------------
idaman ssize_t ida_export get_root_filename(char *buf, size_t bufsize);

idaman ssize_t ida_export dbg_get_input_path(char *buf, size_t bufsize);
 
// The following functions should eventually be replaced by exported functions
#ifndef __KERNEL__
inline ssize_t idaapi get_input_file_path(char *buf, size_t bufsize)
{
  return getinf_buf(INF_INPUT_FILE_PATH, buf, bufsize);
}

inline void set_root_filename(const char *file) { setinf_buf(INF_INPUT_FILE_PATH, file); }

inline size_t idaapi retrieve_input_file_size(void) { return getinf(INF_FSIZE); }

inline uint32 idaapi retrieve_input_file_crc32(void) { return uint32(getinf(INF_CRC32)); }

inline bool idaapi retrieve_input_file_md5(uchar hash[16]) { return getinf_buf(INF_MD5, hash, 16) == 16; }

inline bool idaapi retrieve_input_file_sha256(uchar hash[32]) { return getinf_buf(INF_SHA256, hash, 32) == 32; }

inline ssize_t idaapi get_asm_inc_file(qstring *buf) { return getinf_str(buf, INF_INCLUDE); }

inline bool idaapi set_asm_inc_file(const char *file) { return setinf_buf(INF_INCLUDE, file); }

inline ea_t idaapi get_imagebase(void) { return getinf(INF_IMAGEBASE); }

inline void idaapi set_imagebase(ea_t base) { setinf(INF_IMAGEBASE, base); }

inline netnode idaapi get_ids_modnode(void) { return getinf(INF_IDSNODE); }

inline void idaapi set_ids_modnode(netnode id) { setinf(INF_IDSNODE, id); }

inline ssize_t idaapi get_archive_path(qstring *out) { return getinf_str(out, INF_ARCHIVE_PATH); }

inline bool set_archive_path(const char *file) { return setinf_buf(INF_ARCHIVE_PATH, file); }

inline ssize_t idaapi get_loader_format_name(qstring *out) { return getinf_str(out, INF_FILE_FORMAT_NAME); }

inline void set_loader_format_name(const char *name) { setinf_buf(INF_FILE_FORMAT_NAME, name); }

inline ssize_t idaapi get_initial_ida_version(qstring *out) { return getinf_str(out, INF_IDA_VERSION); }

inline ssize_t idaapi get_ida_notepad_text(qstring *out) { return getinf_str(out, INF_NOTEPAD); }

inline void idaapi set_ida_notepad_text(const char *text, size_t size=0) { setinf_buf(INF_NOTEPAD, text, size); }

inline ssize_t idaapi get_srcdbg_paths(qstring *out) { return getinf_str(out, INF_SRCDBG_PATHS); }

inline void idaapi set_srcdbg_paths(const char *paths) { setinf_buf(INF_SRCDBG_PATHS, paths); }

inline ssize_t idaapi get_srcdbg_undesired_paths(qstring *out) { return getinf_str(out, INF_SRCDBG_UNDESIRED); }

inline void idaapi set_srcdbg_undesired_paths(const char *paths) { setinf_buf(INF_SRCDBG_UNDESIRED, paths); }

inline ushort idaapi get_initial_idb_version() { return ushort(getinf(INF_INITIAL_VERSION)); }

inline time_t idaapi get_idb_ctime() { return getinf(INF_CTIME); }

inline size_t idaapi get_elapsed_secs() { return getinf(INF_ELAPSED); }

inline size_t idaapi get_idb_nopens() { return getinf(INF_NOPENS); }
 
#endif
 
//---------------------------------------------------------------------------

 
idaman int ida_export get_encoding_qty();
 

 
idaman const char *ida_export get_encoding_name(int idx);
 

 
idaman int ida_export add_encoding(const char *encname);
 

 
idaman bool ida_export del_encoding(int idx);
 

 
idaman bool ida_export rename_encoding(int idx, const char *encname);
 
 
#define BPU_1B 1
#define BPU_2B 2
#define BPU_4B 4

 
idaman int ida_export get_encoding_bpu(int idx);
 

idaman int ida_export get_encoding_bpu_by_name(const char *encname);
 
 
//-------------------------------------------------------------------------
inline int get_strtype_bpu(int32 strtype)
{
  int w = get_str_type_code(strtype) & STRWIDTH_MASK;
  return w == STRWIDTH_2B ? BPU_2B
       : w == STRWIDTH_4B ? BPU_4B
       :                    BPU_1B;
}

 
idaman int ida_export get_default_encoding_idx(int bpu);
 

 
idaman bool ida_export set_default_encoding_idx(int bpu, int idx);
 

 
inline const char *idaapi encoding_from_strtype(int32 strtype)
{
  uchar enc = get_str_encoding_idx(strtype);
  if ( enc == STRENC_DEFAULT )
    enc = get_default_encoding_idx(get_strtype_bpu(strtype));
  return get_encoding_name(enc);
}
 

 
idaman int ida_export get_outfile_encoding_idx();
 

 
idaman bool ida_export set_outfile_encoding_idx(int idx);
 

 
//------------------------------------------------------------------------//

 
idaman uint ida_export get_import_module_qty();
 

 
idaman bool ida_export get_import_module_name(qstring *buf, int mod_index);
 

 
typedef int idaapi import_enum_cb_t(ea_t ea, const char *name, uval_t ord, void *param);
 

 
idaman int ida_export enum_import_names(int mod_index, import_enum_cb_t *callback, void *param=nullptr);
 

 
idaman void ida_export delete_imports(void);

 
struct import_entry_t
{
  qstring name;               
  qvector<uval_t> ordinals;   
  int mod_index = -1;         
};
 
idaman bool ida_export get_import_entry(import_entry_t *entry, ea_t ea);

 

 
idaman int ida_export validate_idb_names(bool do_repair);
 
 
#define GOTEA_NODE_NAME "$ got"  
#define GOTEA_NODE_IDX  0
 
//--------------------------------------------------------------------------
// Set address of .got section
inline void set_gotea(ea_t gotea)
{
  netnode n;
  n.create(GOTEA_NODE_NAME);
  n.altset(GOTEA_NODE_IDX, ea2node(gotea)+1);
}
 
//--------------------------------------------------------------------------
// Get address of .got section
inline ea_t get_gotea(void)
{
  netnode n(GOTEA_NODE_NAME);
  return exist(n) ? node2ea(n.altval(GOTEA_NODE_IDX) - 1) : BADADDR;
}
 
 
#ifndef IDA_KERNEL_PRIVATE_NALT_ACCESS    // undefined bit masks so no one can use them directly
#undef AFL_LINNUM
#undef AFL_USERSP
#undef AFL_PUBNAM
#undef AFL_WEAKNAM
#undef AFL_HIDDEN
#undef AFL_MANUAL
#undef AFL_NOBRD
#undef AFL_ZSTROFF
#undef AFL_BNOT0
#undef AFL_BNOT1
#undef AFL_LIB
#undef AFL_TI
#undef AFL_TI0
#undef AFL_TI1
#undef AFL_LNAME
#undef AFL_TILCMT
#undef AFL_LZERO0
#undef AFL_LZERO1
#undef AFL_COLORED
#undef AFL_TERSESTR
#undef AFL_SIGN0
#undef AFL_SIGN1
#undef AFL_NORET
#undef AFL_FIXEDSPD
#undef NALT_ENUM
#undef NALT_WIDE
#undef NALT_SWITCH
//#undef NALT_STRUCT
#undef NALT_XREFPOS
#undef NALT_AFLAGS
#undef NALT_LINNUM
#undef NALT_ABSBASE
//#undef NALT_ENUM0
//#undef NALT_ENUM1
#undef NALT_PURGE
#undef NALT_STRTYPE
#undef NALT_ALIGN
#undef NALT_COLOR
#undef NSUP_CMT
#undef NSUP_REPCMT
#undef NSUP_FOP1
#undef NSUP_FOP2
#undef NSUP_JINFO
#undef NSUP_ARRAY
#undef NSUP_OMFGRP
#undef NSUP_FOP3
#undef NSUP_SWITCH
#undef NSUP_REF0
#undef NSUP_REF1
#undef NSUP_REF2
#undef NSUP_OREF0
#undef NSUP_OREF1
#undef NSUP_OREF2
#undef NSUP_STROFF0
#undef NSUP_STROFF1
#undef NSUP_SEGTRANS
#undef NSUP_FOP4
#undef NSUP_FOP5
#undef NSUP_FOP6
#undef NSUP_FOP7
#undef NSUP_FOP8
#undef NSUP_REF3
#undef NSUP_REF4
#undef NSUP_REF5
#undef NSUP_REF6
#undef NSUP_REF7
#undef NSUP_OREF3
#undef NSUP_OREF4
#undef NSUP_OREF5
#undef NSUP_OREF6
#undef NSUP_OREF7
#undef NSUP_MANUAL
#undef NSUP_FTAILS
#undef NSUP_GROUP
#endif // !IDA_KERNEL_PRIVATE_NALT_ACCESS
#endif // NALT_HPP