lex.hpp

Go to the documentation of this file.

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

 
typedef ushort lxtype;  
typedef uint32 callcnv_t;

const lxtype
  lx_end      = 1,      
  lx_ident    = 2,      
  lx_number   = 3,      
  lx_string   = 4,      
  lx_char     = 5,      
  lx_typename = 6,      
  lx_float    = 7,      
  lx_int64    = 8,      
  lx_callcnv  = 9,      
  lx_key      = 128;    
 

struct token_t
{
  qstring str;          
  lxtype type = 0;      
  sval_t num = 0;       
  union
  {
    bool unicode = false; 
    bool is_unsigned;     
  };
  union
  {
    fpvalue_t fnum;     
    int64 i64;          
    callcnv_t callcnv;  
  };
  token_t() : fnum() {}
};
DECLARE_TYPE_AS_MOVABLE(token_t);
 
class lexer_t;          // lexical analyzer, opaque structure
 

 
typedef error_t lx_resolver_t(lexer_t *lx, void *ud, token_t *curtok, sval_t *res);
 
// Conversion from 'type1 ' to 'type_2' is sign-extended. This may cause unexpected runtime behavior.
// We want this sign-extension to happen, since it comes mostly from HANDLEs.
// (see https://msdn.microsoft.com/en-us/library/ms235307.aspx )
MSC_DIAG_OFF(4826)
 

struct cast_t
{
  bool is_unsigned;
  int size;
 
  cast_t()
  {
    reset();
  }
  void reset(void)
  {
    is_unsigned = false;
    size = 0;
  }
};
 
struct lex_value_t
{
  bool is_unsigned;
  union
  {
    int64 val;
    uint64 uval;
  };
 
  lex_value_t()
  {
    reset();
  }
  void set(const lex_value_t &v)
  {
    set_val(v.val, v.is_unsigned);
  }
  void reset(void)
  {
    set_val(0, true);
  }
  void set_val(int64 v, bool _is_unsigned)
  {
    is_unsigned = _is_unsigned;
    val = v;
  }
 
  uint64 get_uval(void) const
  {
    return val;
  }
  int64 get_val(void) const
  {
    return val;
  }
 
  bool is_zero(void) const
  {
    return get_val() == 0;
  }
 
  void perform_cast(const cast_t &cast);
 
  void unary_minus(const lex_value_t &v);
  void unary_plus(const lex_value_t &v);
  void unary_not(const lex_value_t &v);
  void bitwise_not(const lex_value_t &v);
 
  void mul(const lex_value_t &v);
  void div(const lex_value_t &v);
  void mod(const lex_value_t &v);
  void add(const lex_value_t &v);
  void sub(const lex_value_t &v);
 
  void shift_right(const lex_value_t &v);
  void shift_left(const lex_value_t &v);
  void bitwise_and(const lex_value_t &v);
  void bitwise_xor(const lex_value_t &v);
  void bitwise_or(const lex_value_t &v);
  void logical_and(const lex_value_t &v);
  void logical_or(const lex_value_t &v);
 
  void cmpge(const lex_value_t &v);
  void cmple(const lex_value_t &v);
  void cmplt(const lex_value_t &v);
  void cmpgt(const lex_value_t &v);
  void cmpeq(const lex_value_t &v);
  void cmpneq(const lex_value_t &v);
};
 
MSC_DIAG_ON(4826)
 

 
typedef error_t lx_parse_cast_t(lexer_t *lx, cast_t *cast, token_t *ct);

 
typedef int idaapi lx_preprocessor_cb(void *ud, const char *fname, int nl, const char *line);
 

 
typedef int idaapi lx_pragma_cb(void *ud, const char *line);
 

 
typedef int idaapi lx_warning_cb(void *ud, const char *line);
 

 
typedef int idaapi lx_macro_cb(
        void *ud,
        const char *name,
        const char *body,
        int nargs,
        bool isfunc,
        bool is_new_macro);
 

 
typedef int idaapi lx_undef_cb(void *ud, const char *name);
 
#define LEX_MACRO_SYSTEM 1 

 
idaman lexer_t *ida_export create_lexer(
        const char *const *keys,
        size_t size,
        void *ud=nullptr,
        uint32 macro_flags=0);
 

 
idaman void ida_export destroy_lexer(lexer_t *lx);
 

struct lexer_deleter_t
{
  void operator()(lexer_t *lx) { destroy_lexer(lx); }
};
using lexer_janitor_t = std::unique_ptr<lexer_t, lexer_deleter_t>;
 

 
idaman error_t ida_export lex_define_macro(
        lexer_t *lx,
        const char *macro,
        const char *body,
        int nargs=0,
        bool isfunc=false);

 
idaman void ida_export lex_undefine_macro(
        lexer_t *lx,
        const char *macro);

 
idaman int ida_export lex_set_options(lexer_t *lx, int options);

#define LXOPT_PARSE_FLOATS             0x0001 
#define LXOPT_REQ_SEPARATOR            0x0002 
#define LXOPT_NOCASE_FILES             0x0004 
#define LXOPT_C99_CONSTANTS            0x0008 
#define LXOPT_STR_INCLUDE_BACKSLASHES  0x0010 
 

 
idaman error_t ida_export lex_get_token(lexer_t *lx, token_t *t, int32 *p_lnnum=nullptr);
 

 
idaman int ida_export lex_enum_macros(
        const lexer_t *lx,
        int idaapi cb(const char *name, const char *body, int nargs, bool isfunc, void *ud),
        void *ud=nullptr);
 

 
idaman const char *ida_export lex_print_token(qstring *buf, const token_t *t);
 
 
//-------------------------------------------------------------------------

 
idaman error_t ida_export lex_init_string(
        lexer_t *lx,
        const char *line,
        void *macros=nullptr);
 
//-------------------------------------------------------------------------

 
idaman error_t ida_export lex_init_file(lexer_t *lx, const char *file);
 

 
idaman const char *ida_export lex_get_file_line(
        lexer_t *lx,
        int32 *linenum,
        const char **lineptr,
        int level=0);
 

 
idaman void ida_export lex_term_file(lexer_t *lx, bool del_macros);
 
//-------------------------------------------------------------------------
typedef qstack<token_t> tokenstack_t; 
 

 
inline bool get_token(token_t *t, lexer_t *lx, tokenstack_t &buf)
{
  if ( !buf.empty() )
    *t = buf.pop();
  else if ( lex_get_token(lx, t) != eOk )
    return false;
  return true;
}
 

 
inline void unget_token(const token_t &t, tokenstack_t &buf)
{
  buf.push(t);
}

 

 
idaman bool ida_export is_c_keyword(const char *name);
 
 
 
#endif  //  LEX_HPP