Module ida_range

A range is a non-empty continuous range of addresses (specified by its start and end addresses, the end address is excluded from the range).

Ranges are stored in the Btree part of the IDA database. To learn more about Btrees (Balanced Trees): \link{http://www.bluerwhite.org/btree/}

Global Variables

RANGE_KIND_FUNC

RANGE_KIND_FUNC = 1

RANGE_KIND_HIDDEN_RANGE

RANGE_KIND_HIDDEN_RANGE = 3

RANGE_KIND_SEGMENT

RANGE_KIND_SEGMENT = 2

RANGE_KIND_UNKNOWN

RANGE_KIND_UNKNOWN = 0

Functions

range_t_print(cb: range_t) ‑> size_t

range_t_print(cb) -> str Helper function. Should not be called directly!

cb: range_t const *

Classes

array_of_rangesets(*args)

: Proxy of C++ qvector< rangeset_t > class.

__init__(self) -> array_of_rangesets
__init__(self, x) -> array_of_rangesets

 x: qvector< rangeset_t > const &

Methods

add_unique(self, x: rangeset_t) ‑> bool add_unique(self, x) -> bool
x: rangeset_t const &

at(self, _idx: size_t) ‑> rangeset_t const & at(self, _idx) -> rangeset_t
_idx: size_t

back(self)

begin(self, *args) ‑> qvector< rangeset_t >::const_iterator begin(self) -> rangeset_t

capacity(self) ‑> size_t capacity(self) -> size_t

clear(self) ‑> void clear(self)

empty(self) ‑> bool empty(self) -> bool

end(self, *args) ‑> qvector< rangeset_t >::const_iterator end(self) -> rangeset_t

erase(self, *args) ‑> qvector< rangeset_t >::iterator erase(self, it) -> rangeset_t
it: qvector< rangeset_t >::iterator
erase(self, first, last) -> rangeset_t
first: qvector< rangeset_t >::iterator last: qvector< rangeset_t >::iterator

extract(self) ‑> rangeset_t * extract(self) -> rangeset_t

find(self, *args) ‑> qvector< rangeset_t >::const_iterator find(self, x) -> rangeset_t
x: rangeset_t const &

front(self)

grow(self, *args) ‑> void grow(self, x=rangeset_t())
x: rangeset_t const &

has(self, x: rangeset_t) ‑> bool has(self, x) -> bool
x: rangeset_t const &

inject(self, s: rangeset_t, len: size_t) ‑> void inject(self, s, len)
s: rangeset_t * len: size_t

insert(self, it: rangeset_t, x: rangeset_t) ‑> qvector< rangeset_t >::iterator insert(self, it, x) -> rangeset_t
it: qvector< rangeset_t >::iterator x: rangeset_t const &

pop_back(self) ‑> void pop_back(self)

push_back(self, *args) ‑> rangeset_t & push_back(self, x)
x: rangeset_t const &
push_back(self) -> rangeset_t

qclear(self) ‑> void qclear(self)

reserve(self, cnt: size_t) ‑> void reserve(self, cnt)
cnt: size_t

resize(self, *args) ‑> void resize(self, _newsize, x)
_newsize: size_t x: rangeset_t const &
resize(self, _newsize)
_newsize: size_t

size(self) ‑> size_t size(self) -> size_t

swap(self, r: array_of_rangesets) ‑> void swap(self, r)
r: qvector< rangeset_t > &

truncate(self) ‑> void truncate(self)

range_t(ea1: ea_t = 0, ea2: ea_t = 0)

: Proxy of C++ range_t class.

__init__(self, ea1=0, ea2=0) -> range_t

 ea1: ea_t
 ea2: ea_t

Descendants

* ida_bytes.hidden_range_t
* ida_frame.regvar_t
* ida_funcs.func_t
* ida_gdl.qbasic_block_t
* ida_idd.memory_info_t
* ida_idd.scattered_segm_t
* ida_segment.segment_t
* ida_segregs.sreg_range_t

Instance variables

end_ea: ea_t end_ea

start_ea: ea_t start_ea

Methods

clear(self) ‑> void clear(self) Set start_ea, end_ea to 0.

compare(self, r: range_t) ‑> int compare(self, r) -> int
r: range_t const &

contains(self, *args) ‑> bool contains(self, ea) -> bool Is every ea in 'r' also in this range_t?
ea: ea_t
contains(self, r) -> bool
r: range_t const &

empty(self) ‑> bool empty(self) -> bool Is the size of the range_t <= 0?

extend(self, ea: ea_t) ‑> void extend(self, ea) Ensure that the range_t includes 'ea'.
ea: (C++: ea_t)

intersect(self, r: range_t) ‑> void intersect(self, r) Assign the range_t to the intersection between the range_t and 'r'.
r: (C++: const range_t &) range_t const &

overlaps(self, r: range_t) ‑> bool overlaps(self, r) -> bool Is there an ea in 'r' that is also in this range_t?
r: (C++: const range_t &) range_t const &

size(self) ‑> asize_t size(self) -> asize_t Get end_ea - start_ea.

rangeset_t(*args)

: Proxy of C++ rangeset_t class.

__init__(self) -> rangeset_t
__init__(self, range) -> rangeset_t

 range: range_t const &

__init__(self, ivs) -> rangeset_t

 ivs: rangeset_t const &

Methods

add(self, *args) ‑> bool add(self, range) -> bool Add each element of 'aset' to the set.
range: range_t const &
return: false if no elements were added (the set was unchanged) add(self, start, _end) -> bool
start: ea_t _end: ea_t
add(self, aset) -> bool
aset: rangeset_t const &

begin(self, *args) ‑> rangeset_t::iterator begin(self) -> range_t Get an iterator that points to the first element in the set.

cached_range(self) ‑> range_t const * cached_range(self) -> range_t When searching the rangeset, we keep a cached element to help speed up searches.
return: a pointer to the cached element

clear(self) ‑> void clear(self) Delete all elements from the set. See qvector::clear()

contains(self, *args) ‑> bool contains(self, ea) -> bool Is every element in 'aset' contained in an element of this rangeset?. See range_t::contains(range_t)
ea: ea_t
contains(self, aset) -> bool
aset: rangeset_t const &

empty(self) ‑> bool empty(self) -> bool Does the set have zero elements.

end(self, *args) ‑> rangeset_t::iterator end(self) -> range_t Get an iterator that points to the end of the set. (This is NOT the last element)

find_range(self, ea: ea_t) ‑> range_t const * find_range(self, ea) -> range_t Get the element from the set that contains 'ea'.
ea: (C++: ea_t) return: nullptr if there is no such element

getrange(self, idx: int) ‑> range_t const & getrange(self, idx) -> range_t Get the range_t at index 'idx'.
idx: (C++: int)

has_common(self, *args) ‑> bool has_common(self, range) -> bool Does any element of 'aset' overlap with an element in this rangeset?. See range_t::overlaps()
range: range_t const &
has_common(self, aset) -> bool
aset: rangeset_t const &

includes(self, range: range_t) ‑> bool includes(self, range) -> bool Is every ea in 'range' contained in the rangeset?
range: (C++: const range_t &) range_t const &

intersect(self, aset: rangeset_t) ‑> bool intersect(self, aset) -> bool Set the rangeset to its intersection with 'aset'.
aset: (C++: const rangeset_t &) rangeset_t const & return: false if the set was unchanged

is_equal(self, aset: rangeset_t) ‑> bool is_equal(self, aset) -> bool Do this rangeset and 'aset' have identical elements?
aset: (C++: const rangeset_t &) rangeset_t const &

is_subset_of(self, aset: rangeset_t) ‑> bool is_subset_of(self, aset) -> bool Is every element in the rangeset contained in an element of 'aset'?
aset: (C++: const rangeset_t &) rangeset_t const &

lastrange(self) ‑> range_t const & lastrange(self) -> range_t Get the last range_t in the set.

next_addr(self, ea: ea_t) ‑> ea_t next_addr(self, ea) -> ea_t Get the smallest ea_t value greater than 'ea' contained in the rangeset.
ea: (C++: ea_t)

next_range(self, ea: ea_t) ‑> ea_t next_range(self, ea) -> ea_t Get the smallest ea_t value greater than 'ea' that is not in the same range as 'ea'.
ea: (C++: ea_t)

nranges(self) ‑> size_t nranges(self) -> size_t Get the number of range_t elements in the set.

prev_addr(self, ea: ea_t) ‑> ea_t prev_addr(self, ea) -> ea_t Get the largest ea_t value less than 'ea' contained in the rangeset.
ea: (C++: ea_t)

prev_range(self, ea: ea_t) ‑> ea_t prev_range(self, ea) -> ea_t Get the largest ea_t value less than 'ea' that is not in the same range as 'ea'.
ea: (C++: ea_t)

sub(self, *args) ‑> bool sub(self, range) -> bool Subtract each range in 'aset' from the set
range: range_t const &
return: false if nothing was subtracted (the set was unchanged) sub(self, ea) -> bool
ea: ea_t
sub(self, aset) -> bool
aset: rangeset_t const &

swap(self, r: rangeset_t) ‑> void swap(self, r) Set this = 'r' and 'r' = this. See qvector::swap()
r: (C++: rangeset_t &)

rangevec_base_t(*args)

: Proxy of C++ qvector< range_t > class.

__init__(self) -> rangevec_base_t
__init__(self, x) -> rangevec_base_t

 x: qvector< range_t > const &

Descendants

* ida_range.rangevec_t

Methods

add_unique(self, x: range_t) ‑> bool add_unique(self, x) -> bool
x: range_t const &

at(self, _idx: size_t) ‑> range_t const & at(self, _idx) -> range_t
_idx: size_t

back(self)

begin(self, *args) ‑> qvector< range_t >::const_iterator begin(self) -> range_t

capacity(self) ‑> size_t capacity(self) -> size_t

clear(self) ‑> void clear(self)

empty(self) ‑> bool empty(self) -> bool

end(self, *args) ‑> qvector< range_t >::const_iterator end(self) -> range_t

erase(self, *args) ‑> qvector< range_t >::iterator erase(self, it) -> range_t
it: qvector< range_t >::iterator
erase(self, first, last) -> range_t
first: qvector< range_t >::iterator last: qvector< range_t >::iterator

extract(self) ‑> range_t * extract(self) -> range_t

find(self, *args) ‑> qvector< range_t >::const_iterator find(self, x) -> range_t
x: range_t const &

front(self)

grow(self, *args) ‑> void grow(self, x=range_t())
x: range_t const &

has(self, x: range_t) ‑> bool has(self, x) -> bool
x: range_t const &

inject(self, s: range_t, len: size_t) ‑> void inject(self, s, len)
s: range_t * len: size_t

insert(self, it: range_t, x: range_t) ‑> qvector< range_t >::iterator insert(self, it, x) -> range_t
it: qvector< range_t >::iterator x: range_t const &

pop_back(self) ‑> void pop_back(self)

push_back(self, *args) ‑> range_t & push_back(self, x)
x: range_t const &
push_back(self) -> range_t

qclear(self) ‑> void qclear(self)

reserve(self, cnt: size_t) ‑> void reserve(self, cnt)
cnt: size_t

resize(self, *args) ‑> void resize(self, _newsize, x)
_newsize: size_t x: range_t const &
resize(self, _newsize)
_newsize: size_t

size(self) ‑> size_t size(self) -> size_t

swap(self, r: rangevec_base_t) ‑> void swap(self, r)
r: qvector< range_t > &

truncate(self) ‑> void truncate(self)

rangevec_t()

: Proxy of C++ rangevec_t class.

__init__(self) -> rangevec_t

Ancestors (in MRO)

* ida_range.rangevec_base_t

Descendants

* ida_tryblks.try_handler_t
* ida_tryblks.tryblk_t

PreviousModule ida_problems NextModule ida_regfinder

Last updated 2 months ago