lines.hpp

Go to the documentation of this file.

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

 
struct range_t;
 
//---------------------------------------------------------------------------
//      C O L O R   D E F I N I T I O N S
//---------------------------------------------------------------------------


#define COLOR_ON        '\1'     
#define COLOR_OFF       '\2'     
#define COLOR_ESC       '\3'     
#define COLOR_INV       '\4'     
 
#define SCOLOR_ON       "\1"     
#define SCOLOR_OFF      "\2"     
#define SCOLOR_ESC      "\3"     
#define SCOLOR_INV      "\4"     

inline THREAD_SAFE bool requires_color_esc(char c) { return c >= COLOR_ON && c <= COLOR_INV; }
 
typedef uchar color_t;           
const color_t
  COLOR_DEFAULT  = 0x01,         
  COLOR_REGCMT   = 0x02,         
  COLOR_RPTCMT   = 0x03,         
  COLOR_AUTOCMT  = 0x04,         
  COLOR_INSN     = 0x05,         
  COLOR_DATNAME  = 0x06,         
  COLOR_DNAME    = 0x07,         
  COLOR_DEMNAME  = 0x08,         
  COLOR_SYMBOL   = 0x09,         
  COLOR_CHAR     = 0x0A,         
  COLOR_STRING   = 0x0B,         
  COLOR_NUMBER   = 0x0C,         
  COLOR_VOIDOP   = 0x0D,         
  COLOR_CREF     = 0x0E,         
  COLOR_DREF     = 0x0F,         
  COLOR_CREFTAIL = 0x10,         
  COLOR_DREFTAIL = 0x11,         
  COLOR_ERROR    = 0x12,         
  COLOR_PREFIX   = 0x13,         
  COLOR_BINPREF  = 0x14,         
  COLOR_EXTRA    = 0x15,         
  COLOR_ALTOP    = 0x16,         
  COLOR_HIDNAME  = 0x17,         
  COLOR_LIBNAME  = 0x18,         
  COLOR_LOCNAME  = 0x19,         
  COLOR_CODNAME  = 0x1A,         
  COLOR_ASMDIR   = 0x1B,         
  COLOR_MACRO    = 0x1C,         
  COLOR_DSTR     = 0x1D,         
  COLOR_DCHAR    = 0x1E,         
  COLOR_DNUM     = 0x1F,         
  COLOR_KEYWORD  = 0x20,         
  COLOR_REG      = 0x21,         
  COLOR_IMPNAME  = 0x22,         
  COLOR_SEGNAME  = 0x23,         
  COLOR_UNKNAME  = 0x24,         
  COLOR_CNAME    = 0x25,         
  COLOR_UNAME    = 0x26,         
  COLOR_COLLAPSED= 0x27,         
  COLOR_FG_MAX   = 0x28,         
 
  // Fictive colors
 
  COLOR_ADDR     = COLOR_FG_MAX, 
 
  COLOR_OPND1    = COLOR_ADDR+1, 
  COLOR_OPND2    = COLOR_ADDR+2, 
  COLOR_OPND3    = COLOR_ADDR+3, 
  COLOR_OPND4    = COLOR_ADDR+4, 
  COLOR_OPND5    = COLOR_ADDR+5, 
  COLOR_OPND6    = COLOR_ADDR+6, 
  COLOR_OPND7    = COLOR_ADDR+7, 
  COLOR_OPND8    = COLOR_ADDR+8, 
 
 
  COLOR_RESERVED1= COLOR_ADDR+11,
  COLOR_LUMINA   = COLOR_ADDR+12,
 
  COLOR_ADDR_EXPR = COLOR_ADDR+13,
 
  COLOR_GROUP     = COLOR_ADDR+14;

#define COLOR_ADDR_SIZE (sizeof(ea_t)*2)

#define SCOLOR_DEFAULT   "\x01"  
#define SCOLOR_REGCMT    "\x02"  
#define SCOLOR_RPTCMT    "\x03"  
#define SCOLOR_AUTOCMT   "\x04"  
#define SCOLOR_INSN      "\x05"  
#define SCOLOR_DATNAME   "\x06"  
#define SCOLOR_DNAME     "\x07"  
#define SCOLOR_DEMNAME   "\x08"  
#define SCOLOR_SYMBOL    "\x09"  
#define SCOLOR_CHAR      "\x0A"  
#define SCOLOR_STRING    "\x0B"  
#define SCOLOR_NUMBER    "\x0C"  
#define SCOLOR_VOIDOP    "\x0D"  
#define SCOLOR_CREF      "\x0E"  
#define SCOLOR_DREF      "\x0F"  
#define SCOLOR_CREFTAIL  "\x10"  
#define SCOLOR_DREFTAIL  "\x11"  
#define SCOLOR_ERROR     "\x12"  
#define SCOLOR_PREFIX    "\x13"  
#define SCOLOR_BINPREF   "\x14"  
#define SCOLOR_EXTRA     "\x15"  
#define SCOLOR_ALTOP     "\x16"  
#define SCOLOR_HIDNAME   "\x17"  
#define SCOLOR_LIBNAME   "\x18"  
#define SCOLOR_LOCNAME   "\x19"  
#define SCOLOR_CODNAME   "\x1A"  
#define SCOLOR_ASMDIR    "\x1B"  
#define SCOLOR_MACRO     "\x1C"  
#define SCOLOR_DSTR      "\x1D"  
#define SCOLOR_DCHAR     "\x1E"  
#define SCOLOR_DNUM      "\x1F"  
#define SCOLOR_KEYWORD   "\x20"  
#define SCOLOR_REG       "\x21"  
#define SCOLOR_IMPNAME   "\x22"  
#define SCOLOR_SEGNAME   "\x23"  
#define SCOLOR_UNKNAME   "\x24"  
#define SCOLOR_CNAME     "\x25"  
#define SCOLOR_UNAME     "\x26"  
#define SCOLOR_COLLAPSED "\x27"  
#define SCOLOR_ADDR      "\x28"  
 
//----------------- Line prefix colors --------------------------------------
#define COLOR_DEFAULT    0x01   
#define COLOR_SELECTED   0x02   
#define COLOR_LIBFUNC    0x03   
#define COLOR_REGFUNC    0x04   
#define COLOR_CODE       0x05   
#define COLOR_DATA       0x06   
#define COLOR_UNKNOWN    0x07   
#define COLOR_EXTERN     0x08   
#define COLOR_CURITEM    0x09   
#define COLOR_CURLINE    0x0A   
#define COLOR_HIDLINE    0x0B   
#define COLOR_LUMFUNC    0x0C   
#define COLOR_BG_MAX     0x0D   
 
#define PALETTE_SIZE       (COLOR_FG_MAX+COLOR_BG_MAX)
 

#define COLSTR(str,tag) SCOLOR_ON tag str SCOLOR_OFF tag
 
//----------------- Colors for tiplace_t ------------------------------------
const color_t
  COLOR_NAME    = COLOR_CNAME,    
  COLOR_TYPE    = COLOR_HIDNAME,  
  COLOR_ATTR    = COLOR_HIDNAME,  
  COLOR_TNUM    = COLOR_LIBNAME,  
  COLOR_CMT     = COLOR_NUMBER,   
  COLOR_ARGLOC  = COLOR_CREFTAIL, 
  COLOR_ARGNAME = COLOR_REG,      
  COLOR_PRAGMA  = COLOR_MACRO;    
 
#define SCOLOR_NAME    SCOLOR_CNAME
#define SCOLOR_TYPE    SCOLOR_HIDNAME
#define SCOLOR_ATTR    SCOLOR_HIDNAME
#define SCOLOR_TNUM    SCOLOR_LIBNAME
#define SCOLOR_CMT     SCOLOR_NUMBER
#define SCOLOR_ARGLOC  SCOLOR_CREFTAIL
#define SCOLOR_ARGNAME SCOLOR_REG
#define SCOLOR_PRAGMA  SCOLOR_MACRO
 
 
//------------------------------------------------------------------------


 
idaman THREAD_SAFE void ida_export tag_addr(qstring *buf, ea_t ea, bool ins=false);
 

 
idaman THREAD_SAFE ea_t ida_export tag_get_addr(const char *line);
 

 
idaman THREAD_SAFE const char *ida_export tag_advance(const char *line, int cnt);
 

 
idaman THREAD_SAFE const char *ida_export tag_skipcodes(const char *line);
 

 
idaman THREAD_SAFE const char *ida_export tag_skipcode(const char *line);
 

 
idaman THREAD_SAFE ssize_t ida_export tag_strlen(const char *line);
 

 
idaman THREAD_SAFE ssize_t ida_export tag_remove(qstring *buf, const char *str, int init_level=0);
 
inline THREAD_SAFE ssize_t idaapi tag_remove(qstring *buf, const qstring &str, int init_level=0)
{
  return tag_remove(buf, str.c_str(), init_level);
}
 
inline THREAD_SAFE ssize_t idaapi tag_remove(qstring *buf, int init_level=0)
{
  if ( buf->empty() )
    return 0;
  return tag_remove(buf, buf->begin(), init_level);
}


 

idaman color_t   ida_export calc_prefix_color(ea_t ea);

idaman bgcolor_t ida_export calc_bg_color(ea_t ea);
 
 
//------------------------------------------------------------------------
//      S O U R C E   F I L E S
//------------------------------------------------------------------------


 
idaman bool ida_export add_sourcefile(ea_t ea1, ea_t ea2, const char *filename);
 

 
idaman DEPRECATED const char *ida_export get_sourcefile(ea_t ea, range_t *bounds=nullptr);
 

 
idaman bool ida_export get_sourcefile_by_ea(qstring *out, ea_t ea, range_t *bounds=nullptr);
 

 
idaman bool ida_export del_sourcefile(ea_t ea);

 
idaman size_t ida_export get_sourcefiles_qty(void);

 
struct sourcefile_info_t
{
  range_t range;        
  qstring filename;     
};

 
idaman bool ida_export getn_sourcefile(sourcefile_info_t *out, size_t n);

struct sourcefile_t : public range_t
{
  qstring filename;
};
typedef qvector<sourcefile_t> sourcefilevec_t;

idaman bool ida_export add_sourcefiles(const sourcefilevec_t &items);
 
//------------------------------------------------------------------------
//      G E N E R A T I O N   O F   D I S A S S E M B L E D   T E X T
//------------------------------------------------------------------------


idaman bool ida_export install_user_defined_prefix(
        size_t prefix_len,
        struct user_defined_prefix_t *udp,
        const void *owner);

struct user_defined_prefix_t
{
  user_defined_prefix_t(size_t prefix_len, const void *owner)
  {
    install_user_defined_prefix(prefix_len, this, owner);
  }

  virtual idaapi ~user_defined_prefix_t()
  {
    install_user_defined_prefix(0, this, nullptr);
  }
 
  // Get a user-defined prefix.
  virtual void idaapi get_user_defined_prefix(
        qstring *vout,
        ea_t ea,
        const class insn_t &insn,
        int lnnum,
        int indent,
        const char *line) = 0;
};

 
//------------------------------------------------------------------------
//      A N T E R I O R / P O S T E R I O R   L I N E S
//------------------------------------------------------------------------


 
idaman AS_PRINTF(3, 0) bool ida_export vadd_extra_line(
        ea_t ea,
        int vel_flags,     // see VEL_...
        const char *format,
        va_list va);
 
#define VEL_POST 0x01      
#define VEL_CMT  0x02      
 

 
AS_PRINTF(3, 4) inline bool add_extra_line(ea_t ea, bool isprev, const char *format, ...)
{
  va_list va;
  va_start(va,format);
  int vel_flags = (isprev ? 0 : VEL_POST);
  bool ok = vadd_extra_line(ea, vel_flags, format, va);
  va_end(va);
  return ok;
}
 

 
AS_PRINTF(3, 4) inline bool add_extra_cmt(ea_t ea, bool isprev, const char *format, ...)
{
  va_list va;
  va_start(va,format);
  int vel_flags = (isprev ? 0 : VEL_POST) | VEL_CMT;
  bool ok = vadd_extra_line(ea, vel_flags, format, va);
  va_end(va);
  return ok;
}
 

 
AS_PRINTF(1, 2) inline bool add_pgm_cmt(const char *format, ...)
{
  va_list va;
  va_start(va,format);
  bool ok = vadd_extra_line(inf_get_min_ea(), VEL_CMT, format, va);
  va_end(va);
  return ok;
}


 
// Generate disassembly (many lines) and put them into a buffer
// Returns number of generated lines
idaman int ida_export generate_disassembly(
        qstrvec_t *out,         // buffer to hold generated lines
        int *lnnum,             // number of "the most interesting" line
        ea_t ea,                // address to generate disassembly for
        int maxsize,            // maximum number of lines
        int flags = 0);
 
#define GDISMF_AS_STACK (1 << 0) 
#define GDISMF_ADDR_TAG (1 << 1) 
#define GDISMF_REMOVE_TAGS (1 << 2) 
#define GDISMF_UNHIDE   (1 << 3) 
 
// Generate one line of disassembly
// This function discards all "non-interesting" lines
// It is designed to generate one-line descriptions
// of addresses for lists, etc.
idaman bool ida_export generate_disasm_line(
        qstring *buf,           // output buffer
        ea_t ea,                // address to generate disassembly for
        int flags=0);
#define GENDSM_FORCE_CODE  (1 << 0)     
#define GENDSM_MULTI_LINE  (1 << 1)     
#define GENDSM_REMOVE_TAGS (1 << 2)     
#define GENDSM_UNHIDE      (1 << 3)     

 
idaman int ida_export get_last_pfxlen();
 
 
// Get pointer to the sequence of characters denoting 'close comment'
// empty string means no comment (the current assembler has no open-comment close-comment pairs)
// This function uses ash.cmnt2
 
idaman const char *ida_export closing_comment();
 
 
// Every anterior/posterior line has its number.
// Anterior  lines have numbers from E_PREV
// Posterior lines have numbers from E_NEXT
 
const int E_PREV = 1000; 
const int E_NEXT = 2000; 
 
idaman int ida_export get_first_free_extra_cmtidx(ea_t ea, int start);
idaman bool ida_export update_extra_cmt(ea_t ea, int what, const char *str);
idaman bool ida_export del_extra_cmt(ea_t ea, int what);
idaman ssize_t ida_export get_extra_cmt(qstring *buf, ea_t ea, int what);
idaman void ida_export delete_extra_cmts(ea_t ea, int what);
 
idaman ea_t ida_export align_down_to_stack(ea_t newea);
idaman ea_t ida_export align_up_to_stack(ea_t ea1, ea_t ea2=BADADDR);
 
// A helper class, to encode from UTF-8, -> into the target encoding.
// This is typically used when generating listings (or any kind of
// output file.)
struct encoder_t
{
  // whether or not a message should be printed, letting the
  // user know that some text couldn't be recoded properly
  enum notify_recerr_t
  {
    nr_none,
    nr_once,
  };
 
  virtual ~encoder_t() {}
  virtual bool idaapi get_bom(bytevec_t *out) const = 0;
  // returns true if conversion was entirely successful, false otherwise.
  // codepoints that couldn't be converted, will be output as C
  // literal-escaped UTF-8 sequences (e.g., "\xC3\xD9"), and if
  // 'nr_once' was passed at creation-time, a one-time notification
  // well be output in the messages window.
  virtual bool idaapi encode(qstring *s) const = 0;
  // encode()s the UTF-8 string composed by format + args, and
  // returns true if all the resulting bytes could be written to
  // the output file.
  AS_PRINTF(3, 4) virtual bool idaapi print(FILE *out, const char *format, ...) const = 0;
  // should a file be opened as binary, or should it rather be opened
  // in text mode? This will have an importance in how '\n' characters
  // are possibly converted into '\x0A\x0D' on windows, which is most
  // inappropriate when output'ing e.g., UTF-16, UTF-32..
  virtual bool idaapi requires_binary_mode() const = 0;
};
 
// Create the encoder with the given target encoding. If -1 is passed
// then the effective target encoding will be computed like so:
// if ( encidx < 0 )
// {
//   encidx = get_outfile_encoding_idx();
//   if ( encidx == STRENC_DEFAULT )
//     encidx = get_default_encoding_idx(BPU_1B);
// }
idaman encoder_t *ida_export create_encoding_helper(
        int encidx=-1,
        encoder_t::notify_recerr_t nr=encoder_t::nr_once);

typedef int idaapi html_header_cb_t(FILE *fp);
typedef int idaapi html_footer_cb_t(FILE *fp);
typedef int idaapi html_line_cb_t(
        FILE *fp,
        const qstring &line,
        bgcolor_t prefix_color,
        bgcolor_t bg_color);
#define gen_outline_t html_line_cb_t

 
 
#endif