range.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2025 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef _RANGE_HPP
#define _RANGE_HPP

 
#ifndef SWIG
struct range_t;
idaman size_t ida_export range_t_print(const range_t *, char *buf, size_t bufsize);
#endif
 
//--------------------------------------------------------------------------
struct range_t
{
  friend size_t ida_export range_t_print(const range_t *cb, char *buf, size_t bufsize);
  ea_t start_ea; 
  ea_t end_ea;   
  range_t(ea_t ea1=0, ea_t ea2=0) : start_ea(ea1), end_ea(ea2) {}

  DECLARE_COMPARISONS(range_t)
  {
    return start_ea > r.start_ea ? 1 : start_ea < r.start_ea ? -1 : end_ea > r.end_ea ? 1 : end_ea < r.end_ea ? -1 : 0;
  }

  bool contains(ea_t ea) const { return start_ea <= ea && end_ea > ea; }

  bool contains(const range_t &r) const { return r.start_ea >= start_ea && r.end_ea <= end_ea; }

  bool overlaps(const range_t &r) const { return r.start_ea < end_ea && start_ea < r.end_ea; }

  void clear() { start_ea = end_ea = 0; }

  bool empty() const { return start_ea >= end_ea; }

  asize_t size() const { return end_ea - start_ea; }

  void intersect(const range_t &r)
  {
    if ( start_ea < r.start_ea )
      start_ea = r.start_ea;
    if ( end_ea > r.end_ea )
      end_ea = r.end_ea;
    if ( end_ea < start_ea )
      end_ea = start_ea;
  }

  void extend(ea_t ea)
  {
    if ( start_ea > ea )
      start_ea = ea;
    if ( end_ea < ea )
      end_ea = ea;
  }

  size_t print(char *buf, size_t bufsize) const { return range_t_print(this, buf, bufsize); }
};
DECLARE_TYPE_AS_MOVABLE(range_t);
typedef qvector<range_t> rangevec_base_t;
struct rangevec_t : public rangevec_base_t 
{
};
 
//--------------------------------------------------------------------------
// Various kinds of ranges, see
// \ref idb_event::changing_range_cmt
// \ref idb_event::range_cmt_changed
enum range_kind_t
{
  RANGE_KIND_UNKNOWN,
  RANGE_KIND_FUNC,          
  RANGE_KIND_SEGMENT,       
  RANGE_KIND_HIDDEN_RANGE,  
};
 
//--------------------------------------------------------------------------
#ifndef SWIG
#define RANGESET_HELPER_DEFINITIONS(decl) \
decl bool ida_export rangeset_t_add(rangeset_t *, const range_t &range);\
decl bool ida_export rangeset_t_sub(rangeset_t *, const range_t &range);\
decl bool ida_export rangeset_t_add2(rangeset_t *, const rangeset_t &aset);\
decl bool ida_export rangeset_t_sub2(rangeset_t *, const rangeset_t &aset);\
decl bool ida_export rangeset_t_has_common(const rangeset_t *, const range_t &range, bool strict);\
decl bool ida_export rangeset_t_has_common2(const rangeset_t *, const rangeset_t &aset);\
decl bool ida_export rangeset_t_contains(const rangeset_t *, const rangeset_t &aset);\
decl size_t ida_export rangeset_t_print(const rangeset_t *, char *buf, size_t bufsize);\
decl bool ida_export rangeset_t_intersect(rangeset_t *, const rangeset_t &aset);\
decl const range_t *ida_export rangeset_t_find_range(const rangeset_t *, ea_t ea);\
decl ea_t ida_export rangeset_t_next_addr(const rangeset_t *, ea_t ea);\
decl ea_t ida_export rangeset_t_prev_addr(const rangeset_t *, ea_t ea);\
decl ea_t ida_export rangeset_t_next_range(const rangeset_t *, ea_t ea);\
decl ea_t ida_export rangeset_t_prev_range(const rangeset_t *, ea_t ea);\
decl rangevec_t::const_iterator ida_export rangeset_t_lower_bound(const rangeset_t *, ea_t ea);\
decl rangevec_t::const_iterator ida_export rangeset_t_upper_bound(const rangeset_t *, ea_t ea);\
decl void ida_export rangeset_t_swap(rangeset_t *, rangeset_t &r);
#else
#define RANGESET_HELPER_DEFINITIONS(decl)
#endif // SWIG
 
class rangeset_t;
 
RANGESET_HELPER_DEFINITIONS(idaman)
 

class rangeset_t
{
  rangevec_t bag;
  mutable const range_t *cache;
  int undo_code = -1;
 
  RANGESET_HELPER_DEFINITIONS(friend)
  bool verify(void) const;
public:
  DEFINE_MEMORY_ALLOCATION_FUNCS()
  rangeset_t(void) : cache(nullptr) {}
  rangeset_t(const range_t &range): cache(nullptr) { if ( !range.empty() ) bag.push_back(range); }
  rangeset_t(const rangeset_t &ivs) : bag(ivs.bag), cache(nullptr) {}
  rangeset_t &operator=(const rangeset_t &ivs) { bag = ivs.bag; cache = nullptr; return *this; }
  void swap(rangeset_t &r) { rangeset_t_swap(this, r); }

  bool add(const range_t &range)    { return rangeset_t_add(this, range); }

  bool add(ea_t start, ea_t _end) { return add(range_t(start, _end)); }

  bool add(const rangeset_t &aset) { return rangeset_t_add2(this, aset); }

  bool sub(const range_t &range)    { return rangeset_t_sub(this, range); }

  bool sub(ea_t ea)               { return sub(range_t(ea, ea+1)); }

  bool sub(const rangeset_t &aset) { return rangeset_t_sub2(this, aset); }

  bool has_common(const range_t &range) const
    { return rangeset_t_has_common(this, range, false); }

  bool includes(const range_t &range) const
    { return rangeset_t_has_common(this, range, true); }

  size_t print(char *buf, size_t bufsize) const
    { return rangeset_t_print(this, buf, bufsize); }

  asize_t count(void) const;

  const range_t &getrange(int idx) const { return bag[idx]; }

  const range_t &lastrange(void) const { return bag.back(); }

  size_t nranges(void) const { return bag.size(); }

  bool empty(void) const { return bag.empty(); }

  void clear(void) { bag.clear(); cache = nullptr; }

  bool has_common(const rangeset_t &aset) const
    { return rangeset_t_has_common2(this, aset); }

  bool contains(ea_t ea) const { return !empty() && find_range(ea) != nullptr; }

  bool contains(const rangeset_t &aset) const
     { return rangeset_t_contains(this, aset); }

  bool intersect(const rangeset_t &aset)
     { return rangeset_t_intersect(this, aset); }

  bool is_subset_of(const rangeset_t &aset) const { return aset.contains(*this); }

  bool is_equal(const rangeset_t &aset)   const { return bag == aset.bag; }
 
  bool operator==(const rangeset_t &aset) const { return is_equal(aset); }   
  bool operator!=(const rangeset_t &aset) const { return !is_equal(aset); }  
 
  typedef rangevec_t::iterator iterator;                     
  typedef rangevec_t::const_iterator const_iterator;         
  const_iterator begin(void) const { return bag.begin(); }  
  const_iterator end(void)   const { return bag.end(); }    
  iterator begin(void) { return bag.begin(); }              
  iterator end(void)   { return bag.end(); }                

  const_iterator lower_bound(ea_t ea) const { return rangeset_t_lower_bound(this, ea); }

  const_iterator upper_bound(ea_t ea) const { return rangeset_t_upper_bound(this, ea); }

  const range_t *find_range(ea_t ea) const
     { return rangeset_t_find_range(this, ea); }

  const range_t *cached_range(void) const { return cache; }

  ea_t next_addr(ea_t ea) const { return rangeset_t_next_addr(this, ea); }

  ea_t prev_addr(ea_t ea) const { return rangeset_t_prev_addr(this, ea); }

  ea_t next_range(ea_t ea) const { return rangeset_t_next_range(this, ea); }

  ea_t prev_range(ea_t ea) const { return rangeset_t_prev_range(this, ea); }

  int move_chunk(ea_t from, ea_t to, asize_t size);

  int check_move_args(ea_t from, ea_t to, asize_t size); // returns VAMOVE_...

  const rangevec_t &as_rangevec() const
    { return bag; }
};
DECLARE_TYPE_AS_MOVABLE(rangeset_t);
typedef qvector<rangeset_t> array_of_rangesets; 
typedef qvector<const rangeset_t*> rangeset_crefvec_t;
 
//--------------------------------------------------------------------------
struct range64_t
{
  uint64 start;
  uint64 end;
 
  range64_t(uint64 _start=0, uint64 _end=0) : start(_start), end(_end) {}
  DECLARE_COMPARISONS(range64_t) { return start > r.start ? 1 : start < r.start ? -1 : end > r.end ? 1 : end < r.end ? -1 : 0; }
  bool contains(uint64 x) const { return start <= x && end > x; }
  bool contains(const range64_t &r) const { return r.start >= start && r.end <= end; }
  bool overlaps(const range64_t &r) const { return r.start < end && start < r.end; }
  void clear() { start = end = 0; }
  bool empty() const { return start >= end; }
  uint64 size() const { return end - start; }
  void intersect(const range64_t &r)
  {
    if ( start < r.start )
      start = r.start;
    if ( end > r.end )
      end = r.end;
    if ( end < start )
      end = start;
  }
  void extend(uint64 ea)
  {
    if ( start > ea )
      start = ea;
    if ( end < ea )
      end = ea;
  }
};
DECLARE_TYPE_AS_MOVABLE(range64_t);
 
struct range64vec_t : public qvector<range64_t>
{
  const range64_t *find_range(uint64 off) const
  {
    for ( const range64_t &r : *this )
      if ( r.contains(off) )
        return &r;
    return nullptr;
  }
};
 
#endif  // _RANGE_HPP