Module index

Module ida_bytes

IDA Plugin SDK API wrapper: bytes

Global variables

var ALOPT_IGNCLT
if set, don't stop at codepoints that are not part of the current 'culture'; accept all those that are graphical (this is typically used used by user-initiated actions creating string literals.)
var ALOPT_IGNHEADS
don't stop if another data item is encountered. only the byte values will be used to determine the string length. if not set, a defined data item or instruction will truncate the string
var ALOPT_IGNPRINT
if set, don't stop at non-printable codepoints, but only at the terminating character (or not unicode-mapped character (e.g., 0x8f in CP1252))
var ALOPT_MAX4K
if string length is more than 4K, return the accumulated length
var BIN_SEARCH_BACKWARD
search backward for bytes
var BIN_SEARCH_CASE
case sensitive
var BIN_SEARCH_FORWARD
search forward for bytes
var BIN_SEARCH_INITED
find_byte, find_byter: any initilized value
var BIN_SEARCH_NOBREAK
don't check for Ctrl-Break
var BIN_SEARCH_NOCASE
case insensitive
var BIN_SEARCH_NOSHOW
don't show search progress or update screen
var DELIT_DELNAMES
delete any names at the specified address range (except for the starting address). this bit is valid if nbytes > 1
var DELIT_EXPAND
propagate undefined items; for example if removing an instruction removes all references to the next instruction, then plan to convert to unexplored the next instruction too.
var DELIT_KEEPFUNC
do not undefine the function start. Just delete xrefs, ops e.t.c.
var DELIT_NOCMT
reject to delete if a comment is in address range (except for the starting address). this bit is valid if nbytes > 1
var DELIT_NOTRUNC
don't truncate the current function even if 'AF_TRFUNC' is set
var DELIT_NOUNAME
reject to delete if a user name is in address range (except for the starting address). this bit is valid if nbytes > 1
var DELIT_SIMPLE
simply undefine the specified item(s)
var DTP_NODUP
do not use dup construct
var DT_TYPE
Mask for DATA typing.
var FF_0CHAR
Char ('x')?
var FF_0CUST
Custom representation?
var FF_0ENUM
Enumeration?
var FF_0FLT
Floating point number?
var FF_0FOP
Forced operand?
var FF_0NUMB
Binary number?
var FF_0NUMD
Decimal number?
var FF_0NUMH
Hexadecimal number?
var FF_0NUMO
Octal number?
var FF_0OFF
Offset?
var FF_0SEG
Segment?
var FF_0STK
Stack variable?
var FF_0STRO
Struct offset?
var FF_0VOID
Void (unknown)?
var FF_1CHAR
Char ('x')?
var FF_1CUST
Custom representation?
var FF_1ENUM
Enumeration?
var FF_1FLT
Floating point number?
var FF_1FOP
Forced operand?
var FF_1NUMB
Binary number?
var FF_1NUMD
Decimal number?
var FF_1NUMH
Hexadecimal number?
var FF_1NUMO
Octal number?
var FF_1OFF
Offset?
var FF_1SEG
Segment?
var FF_1STK
Stack variable?
var FF_1STRO
Struct offset?
var FF_1VOID
Void (unknown)?
var FF_ALIGN
alignment directive
var FF_ANYNAME
FF_ANYNAME = 49152
var FF_BNOT
Bitwise negation of operands.
var FF_BYTE
byte
var FF_CODE
Code ?
var FF_COMM
Has comment ?
var FF_CUSTOM
custom data type
var FF_DATA
Data ?
var FF_DOUBLE
double
var FF_DWORD
double word
var FF_FLOAT
float
var FF_FLOW
Exec flow from prev instruction.
var FF_FUNC
function start?
var FF_IMMD
Has Immediate value ?
var FF_IVL
Byte has value ?
var FF_JUMP
Has jump table or switch_info?
var FF_LABL
Has dummy name?
var FF_LINE
Has next or prev lines ?
var FF_NAME
Has name ?
var FF_OWORD
octaword/xmm word (16 bytes/128 bits)
var FF_PACKREAL
packed decimal real
var FF_QWORD
quadro word
var FF_REF
has references
var FF_SIGN
Inverted sign of operands.
var FF_STRLIT
string literal
var FF_STRUCT
struct variable
var FF_TAIL
Tail ?
var FF_TBYTE
tbyte
var FF_UNK
Unknown ?
var FF_UNUSED
unused bit (was used for variable bytes)
var FF_WORD
word
var FF_YWORD
ymm word (32 bytes/256 bits)
var FF_ZWORD
zmm word (64 bytes/512 bits)
var GFE_VALUE
get flags with 'FF_IVL' & 'MS_VAL' . It is much slower under remote debugging because the kernel needs to read the process memory.
var GMB_READALL
try to read all bytes if this bit is not set, fail at first uninited byte
var GMB_WAITBOX
show wait box (may return -1 in this case)
var ITEM_END_FIXUP
stop at the first fixup
var ITEM_END_INITED
stop when initialization changes i.e.if is_loaded(ea): stop if uninitialized byte is encounteredif !is_loaded(ea): stop if initialized byte is encountered
var ITEM_END_NAME
stop at the first named location
var ITEM_END_XREF
stop at the first referenced location
var MS_0TYPE
Mask for 1st arg typing.
var MS_1TYPE
Mask for the type of other operands.
var MS_CLS
Mask for typing.
var MS_CODE
Mask for code bits.
var MS_COMM
Mask of common bits.
var MS_VAL
Mask for byte value.
var OPND_ALL
all operands
var OPND_MASK
mask for operand number
var OPND_OUTER
outer offset base (combined with operand number). used only in set, get, del_offset() functions
var PBSENC_ALL
PBSENC_ALL = -1
var PBSENC_DEF1BPU
PBSENC_DEF1BPU = 0
var PSTF_ENC
if encoding is specified, append it
var PSTF_HOTKEY
have hotkey markers part of the name
var PSTF_TBRIEF
use brief name (e.g., in the 'Strings' window)
var PSTF_TINLIN
use 'inline' name (e.g., in the structures comments)
var PSTF_TMASK
type mask
var PSTF_TNORM
use normal name
var STRCONV_ESCAPE
convert non-printable characters to C escapes (, \xNN, \uNNNN)
var STRCONV_INCLLEN
for Pascal-style strings, include the prefixing length byte(s) as C-escaped sequence
var STRCONV_REPLCHAR
convert non-printable characters to the Unicode replacement character (U+FFFD)

Functions

def add_byte(*args) ‑> void
Add a value to one byte of the program. This function works for wide byte processors too.
add_byte(ea, value)
ea: linear address (C++: ea_t)
value: byte value (C++: uint32)
def add_dword(*args) ‑> void
Add a value to one dword of the program. This function works for wide byte processors too. This function takes into account order of bytes specified in \inf{is_be()} this function works incorrectly if
\ph{nbits}
> 16
add_dword(ea, value)
ea: linear address (C++: ea_t)
value: byte value (C++: uint64)
def add_hidden_range(*args) ‑> bool
Mark a range of addresses as hidden. The range will be created in the invisible state with the default color
add_hidden_range(ea1, ea2, description, header, footer, color) -> bool
ea1: linear address of start of the address range (C++: ea_t)
ea2: linear address of end of the address range (C++: ea_t)
description: range parameters (C++: const char *)
header: range parameters (C++: const char *)
footer: range parameters (C++: const char *)
color (C++: bgcolor_t)
return: success
def add_mapping(*args) ‑> bool
IDA supports memory mapping. References to the addresses from the mapped range use data and meta-data from the mapping range.You should set flag PR2_MAPPING in ph.flag2 to use memory mapping Add memory mapping range.
add_mapping(_from, to, size) -> bool
_from: start of the mapped range (nonexistent address) (C++:
ea_t)
to: start of the mapping range (existent address) (C++: ea_t)
size: size of the range (C++: asize_t)
return: success
def add_qword(*args) ‑> void
Add a value to one qword of the program. This function does not work for wide byte processors. This function takes into account order of bytes specified in \inf{is_be()}
add_qword(ea, value)
ea: linear address (C++: ea_t)
value: byte value (C++: uint64)
def add_word(*args) ‑> void
Add a value to one word of the program. This function works for wide byte processors too. This function takes into account order of bytes specified in \inf{is_be()}
add_word(ea, value)
ea: linear address (C++: ea_t)
value: byte value (C++: uint64)
def align_flag(*args) ‑> flags_t
Get a flags_t representing an alignment directive.
def append_cmt(*args) ‑> bool
Append to an indented comment. Creates a new comment if none exists. Appends a newline character and the specified string otherwise.
append_cmt(ea, str, rptble) -> bool
ea: linear address (C++: ea_t)
str: comment string to append (C++: const char *)
rptble: append to repeatable comment? (C++: bool)
return: success
def attach_custom_data_format(*args) ‑> bool
Attach the data format to the data type.
attach_custom_data_format(dtid, dfid) -> bool
dtid: data type id that can use the data format. 0 means all
standard data types. Such data formats can be applied to any data item or instruction operands. For instruction operands, the data_format_t::value_size check is not performed by the kernel. (C++: int)
dfid: data format id (C++: int)
retval: true - ok
retval: false - no such dtid , or no such dfid , or the data format
has already been attached to the data type
def bin_flag(*args) ‑> flags_t
Get number flag of the base, regardless of current processor - better to use 'num_flag()'
bin_search(start_ea, end_ea, data, flags) -> ea_t
Search for a set of bytes in the program
start_ea: linear address, start of range to search
end_ea: linear address, end of range to search (exclusive)
data: the prepared data to search for (see parse_binpat_str())
flags: combination of BIN_SEARCH_* flags
return: the address of a match, or ida_idaapi.BADADDR if not found
def byte_flag(*args) ‑> flags_t
Get a flags_t representing a byte.
def bytesize(*args) ‑> int
Get number of bytes required to store a byte at the given address.
bytesize(ea) -> int
ea (C++: ea_t)
def calc_def_align(*args) ‑> int
Calculate the default alignment exponent.
calc_def_align(ea, mina, maxa) -> int
ea: linear address (C++: ea_t)
mina: minimal possible alignment exponent. (C++: int)
maxa: minimal possible alignment exponent. (C++: int)
def calc_dflags(*args) ‑> flags_t
calc_dflags(f, force) -> flags_t
f (C++: flags_t)
force (C++: bool)
def calc_max_align(*args) ‑> int
Calculate the maximal possible alignment exponent.
calc_max_align(endea) -> int
endea: end address of the alignment item. (C++: ea_t)
return: a value in the 0..32 range
def calc_max_item_end(*args) ‑> ea_t
Calculate maximal reasonable end address of a new item. This function will limit the item with the current segment bounds.
calc_max_item_end(ea, how=15) -> ea_t
ea: linear address (C++: ea_t)
how: when to stop the search. A combination of Item end search
flags (C++: int)
return: end of new item. If it is not possible to create an item, it
will return 'ea'.
def calc_min_align(*args) ‑> int
Calculate the minimal possible alignment exponent.
calc_min_align(length) -> int
length: size of the item in bytes. (C++: asize_t)
return: a value in the 1..32 range
def can_define_item(*args) ‑> bool
Can define item (instruction/data) of the specified 'length', starting at 'ea'?if there is an item starting at 'ea', this function ignores itthis function converts to unexplored all encountered data items with fixup information. Should be fixed in the future.a new item would cross segment boundariesa new item would overlap with existing items (except items specified by 'flags')
can_define_item(ea, length, flags) -> bool
ea (C++: ea_t)
length (C++: asize_t)
flags: if not 0, then the kernel will ignore the data types
specified by the flags and destroy them. For example: 1000 dw 5 1002 db 5 ; undef 1003 db 5 ; undef 1004 dw 5 1006 dd 5 can_define_item(1000, 6, 0)
  • false because of dw at 1004 can_define_item(1000, 6, word_flag()) - true, word at 1004 is destroyed (C++: flags_t)
return: 1-yes, 0-no
def change_storage_type(*args) ‑> error_t
Change flag storage type for address range.
change_storage_type(start_ea, end_ea, stt) -> error_t
start_ea: should be lower than end_ea. (C++: ea_t)
end_ea: does not belong to the range. (C++: ea_t)
stt: storage_type_t (C++: storage_type_t)
return: error code
def char_flag(*args) ‑> flags_t
see 'Bits: instruction operand types'
def chunk_size(*args) ‑> asize_t
Get size of the contiguous address block containing 'ea'.
chunk_size(ea) -> asize_t
ea (C++: ea_t)
return: 0 if 'ea' doesn't belong to the program.
def chunk_start(*args) ‑> ea_t
Get start of the contiguous address block containing 'ea'.
chunk_start(ea) -> ea_t
ea (C++: ea_t)
return: BADADDR if 'ea' doesn't belong to the program.
def clr_lzero(*args) ‑> bool
Clear lzero bit.
clr_lzero(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def clr_op_type(*args) ‑> bool
Remove operand representation information. (set operand representation to be 'undefined')
clr_op_type(ea, n) -> bool
ea: linear address (C++: ea_t)
n: number of operand (0, 1, -1) (C++: int)
return: success
def code_flag(*args) ‑> flags_t
'FF_CODE'
def create_16bit_data(*args) ‑> bool
Convert to 16-bit quantity (take the byte size into account)
create_16bit_data(ea, length) -> bool
ea (C++: ea_t)
length (C++: asize_t)
def create_32bit_data(*args) ‑> bool
Convert to 32-bit quantity (take the byte size into account)
create_32bit_data(ea, length) -> bool
ea (C++: ea_t)
length (C++: asize_t)
def create_align(*args) ‑> bool
Create an alignment item.
create_align(ea, length, alignment) -> bool
ea: linear address (C++: ea_t)
length: size of the item in bytes. 0 means to infer from
ALIGNMENT (C++: asize_t)
alignment: alignment exponent. Example: 3 means align to 8
bytes. 0 means to infer from LENGTH It is forbidden to specify both LENGTH and ALIGNMENT as 0. (C++: int)
return: success
def create_byte(*args) ‑> bool
Convert to byte.
create_byte(ea, length, force=False) -> bool
ea (C++: ea_t)
length (C++: asize_t)
force (C++: bool)
def create_custdata(*args) ‑> bool
Convert to custom data type.
create_custdata(ea, length, dtid, fid, force=False) -> bool
ea (C++: ea_t)
length (C++: asize_t)
dtid (C++: int)
fid (C++: int)
force (C++: bool)
def create_data(*args) ‑> bool
Convert to data (byte, word, dword, etc). This function may be used to create arrays.
create_data(ea, dataflag, size, tid) -> bool
ea: linear address (C++: ea_t)
dataflag: type of data. Value of function byte_flag() ,
word_flag() , etc. (C++: flags_t)
size: size of array in bytes. should be divisible by the size
of one item of the specified type. for variable sized items it can be specified as 0, and the kernel will try to calculate the size. (C++: asize_t)
tid: type id. If the specified type is a structure, then tid is
structure id. Otherwise should be BADNODE . (C++: tid_t)
return: success
def create_double(*args) ‑> bool
Convert to double.
create_double(ea, length, force=False) -> bool
ea (C++: ea_t)
length (C++: asize_t)
force (C++: bool)
def create_dword(*args) ‑> bool
Convert to dword.
create_dword(ea, length, force=False) -> bool
ea (C++: ea_t)
length (C++: asize_t)
force (C++: bool)
def create_float(*args) ‑> bool
Convert to float.
create_float(ea, length, force=False) -> bool
ea (C++: ea_t)
length (C++: asize_t)
force (C++: bool)
def create_oword(*args) ‑> bool
Convert to octaword/xmm word.
create_oword(ea, length, force=False) -> bool
ea (C++: ea_t)
length (C++: asize_t)
force (C++: bool)
def create_packed_real(*args) ‑> bool
Convert to packed decimal real.
create_packed_real(ea, length, force=False) -> bool
ea (C++: ea_t)
length (C++: asize_t)
force (C++: bool)
def create_qword(*args) ‑> bool
Convert to quadword.
create_qword(ea, length, force=False) -> bool
ea (C++: ea_t)
length (C++: asize_t)
force (C++: bool)
def create_strlit(*args) ‑> bool
Convert to string literal and give a meaningful name. 'start' may be higher than 'end', the kernel will swap them in this case
create_strlit(start, len, strtype) -> bool
start: starting address (C++: ea_t)
len: length of the string in bytes. if 0, then
get_max_strlit_length() will be used to determine the length (C++: size_t)
strtype: string type. one of String type codes (C++: int32)
return: success
def create_struct(*args) ‑> bool
Convert to struct.
create_struct(ea, length, tid, force=False) -> bool
ea (C++: ea_t)
length (C++: asize_t)
tid (C++: tid_t)
force (C++: bool)
def create_tbyte(*args) ‑> bool
Convert to tbyte.
create_tbyte(ea, length, force=False) -> bool
ea (C++: ea_t)
length (C++: asize_t)
force (C++: bool)
def create_word(*args) ‑> bool
Convert to word.
create_word(ea, length, force=False) -> bool
ea (C++: ea_t)
length (C++: asize_t)
force (C++: bool)
def create_yword(*args) ‑> bool
Convert to ymm word.
create_yword(ea, length, force=False) -> bool
ea (C++: ea_t)
length (C++: asize_t)
force (C++: bool)
def create_zword(*args) ‑> bool
Convert to zmm word.
create_zword(ea, length, force=False) -> bool
ea (C++: ea_t)
length (C++: asize_t)
force (C++: bool)
def cust_flag(*args) ‑> flags_t
Get a flags_t representing custom type data.
def custfmt_flag(*args) ‑> flags_t
see 'Bits: instruction operand types'
def dec_flag(*args) ‑> flags_t
Get number flag of the base, regardless of current processor - better to use 'num_flag()'
def del_hidden_range(*args) ‑> bool
Delete hidden range.
del_hidden_range(ea) -> bool
ea: any address in the hidden range (C++: ea_t)
return: success
def del_items(*args) ‑> bool
Convert item (instruction/data) to unexplored bytes. The whole item (including the head and tail bytes) will be destroyed. It is allowed to pass any address in the item to this function
del_items(ea, flags=0, nbytes=1, may_destroy=None) -> bool
ea: any address within the first item to delete (C++: ea_t)
flags: combination of Unexplored byte conversion flags (C++:
int)
nbytes: number of bytes in the range to be undefined (C++:
asize_t)
may_destroy: optional routine invoked before deleting a head
item. If callback returns false then item has not to be deleted and operation fails (C++: may_destroy_cb_t *)
return: true on sucessful operation, otherwise false
def del_mapping(*args) ‑> void
Delete memory mapping range.
del_mapping(ea)
ea: any address in the mapped range (C++: ea_t)
def del_value(*args) ‑> void
Delete byte value from flags. The corresponding byte becomes uninitialized.
del_value(ea)
ea (C++: ea_t)
def detach_custom_data_format(*args) ‑> bool
Detach the data format from the data type. Unregistering a custom data type detaches all attached data formats, no need to detach them explicitly. You still need unregister them. Unregistering a custom data format detaches it from all attached data types.
detach_custom_data_format(dtid, dfid) -> bool
dtid: data type id to detach data format from (C++: int)
dfid: data format id to detach (C++: int)
retval: true - ok
retval: false - no such dtid , or no such dfid , or the data format
was not attached to the data type
def disable_flags(*args) ‑> error_t
Deallocate flags for address range. Exit with an error message if not enough disk space (this may occur too).
disable_flags(start_ea, end_ea) -> error_t
start_ea: should be lower than end_ea. (C++: ea_t)
end_ea: does not belong to the range. (C++: ea_t)
return: 0 if ok, otherwise return error code
def double_flag(*args) ‑> flags_t
Get a flags_t representing a double.
def dword_flag(*args) ‑> flags_t
Get a flags_t representing a double word.
def enable_flags(*args) ‑> error_t
Allocate flags for address range. This function does not change the storage type of existing ranges. Exit with an error message if not enough disk space.
enable_flags(start_ea, end_ea, stt) -> error_t
start_ea: should be lower than end_ea. (C++: ea_t)
end_ea: does not belong to the range. (C++: ea_t)
stt: storage_type_t (C++: storage_type_t)
return: 0 if ok, otherwise an error code
def enum_flag(*args) ‑> flags_t
see 'Bits: instruction operand types'
def equal_bytes(*args) ‑> bool
Compare 'len' bytes of the program starting from 'ea' with 'image'.
equal_bytes(ea, image, mask, len, sense_case) -> bool
ea: linear address (C++: ea_t)
image: bytes to compare with (C++: const uchar *)
mask: array of 1/0 bytes, it's length is 'len'. 1 means to
perform the comparison of the corresponding byte. 0 means not to perform. if mask == nullptr, then all bytes of 'image' will be compared. if mask == SKIP_FF_MASK then 0xFF bytes will be skipped (C++: const uchar *)
len: length of block to compare in bytes. (C++: size_t)
sense_case: case-sensitive comparison? (C++: bool)
retval: 1 - equal
retval: 0 - not equal
def f_has_cmt(*args) ‑> bool
f_has_cmt(f, arg2) -> bool
f (C++: flags_t) arg2: void *
def f_has_dummy_name(*args) ‑> bool
Does the current byte have dummy (auto-generated, with special prefix) name?
f_has_dummy_name(f, arg2) -> bool
f (C++: flags_t) arg2: void *
def f_has_extra_cmts(*args) ‑> bool
f_has_extra_cmts(f, arg2) -> bool
f (C++: flags_t) arg2: void *
def f_has_name(*args) ‑> bool
Does the current byte have non-trivial (non-dummy) name?
f_has_name(f, arg2) -> bool
f (C++: flags_t) arg2: void *
def f_has_user_name(*args) ‑> bool
Does the current byte have user-specified name?
f_has_user_name(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_has_xref(*args) ‑> bool
Does the current byte have cross-references to it?
f_has_xref(f, arg2) -> bool
f (C++: flags_t) arg2: void *
def f_is_align(*args) ‑> bool
See 'is_align()'
f_is_align(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_byte(*args) ‑> bool
See 'is_byte()'
f_is_byte(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_code(*args) ‑> bool
Does flag denote start of an instruction?
f_is_code(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_custom(*args) ‑> bool
See 'is_custom()'
f_is_custom(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_data(*args) ‑> bool
Does flag denote start of data?
f_is_data(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_double(*args) ‑> bool
See 'is_double()'
f_is_double(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_dword(*args) ‑> bool
See 'is_dword()'
f_is_dword(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_float(*args) ‑> bool
See 'is_float()'
f_is_float(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_head(*args) ‑> bool
Does flag denote start of instruction OR data?
f_is_head(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_not_tail(*args) ‑> bool
Does flag denote tail byte?
f_is_not_tail(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_oword(*args) ‑> bool
See 'is_oword()'
f_is_oword(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_pack_real(*args) ‑> bool
See 'is_pack_real()'
f_is_pack_real(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_qword(*args) ‑> bool
See 'is_qword()'
f_is_qword(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_strlit(*args) ‑> bool
See 'is_strlit()'
f_is_strlit(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_struct(*args) ‑> bool
See 'is_struct()'
f_is_struct(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_tail(*args) ‑> bool
Does flag denote tail byte?
f_is_tail(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_tbyte(*args) ‑> bool
See 'is_tbyte()'
f_is_tbyte(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_word(*args) ‑> bool
See 'is_word()'
f_is_word(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def f_is_yword(*args) ‑> bool
See 'is_yword()'
f_is_yword(F, arg2) -> bool
F (C++: flags_t) arg2: void *
def find_byte(*args) ‑> ea_t
Find forward a byte with the specified value (only 8-bit value from the database). example: ea=4 size=3 will inspect addresses 4, 5, and 6
find_byte(sEA, size, value, bin_search_flags) -> ea_t
sEA: linear address (C++: ea_t)
size: number of bytes to inspect (C++: asize_t)
value: value to find (C++: uchar)
bin_search_flags: combination of Search flags (C++: int)
return: address of byte or BADADDR
def find_byter(*args) ‑> ea_t
Find reverse a byte with the specified value (only 8-bit value from the database). example: ea=4 size=3 will inspect addresses 6, 5, and 4
find_byter(sEA, size, value, bin_search_flags) -> ea_t
sEA: the lower address of the search range (C++: ea_t)
size: number of bytes to inspect (C++: asize_t)
value: value to find (C++: uchar)
bin_search_flags: combination of Search flags (C++: int)
return: address of byte or BADADDR
def find_custom_data_format(*args) ‑> int
Get id of a custom data format.
find_custom_data_format(name) -> int
name: name of the custom data format (C++: const char *)
return: id or -1
def find_custom_data_type(*args) ‑> int
Get id of a custom data type.
find_custom_data_type(name) -> int
name: name of the custom data type (C++: const char *)
return: id or -1
def float_flag(*args) ‑> flags_t
Get a flags_t representing a float.
def flt_flag(*args) ‑> flags_t
see 'Bits: instruction operand types'
def free_chunk(*args) ‑> ea_t
Search for a hole in the addressing space of the program.
free_chunk(bottom, size, step) -> ea_t
bottom: address to start searching (C++: ea_t)
size: size of desired block (C++: asize_t)
step: bit mask for the start of hole (0xF would align hole to a
paragraph). if 'step' is negative, the bottom address with be aligned. otherwise the kernel will try to use it as is and align it only when the hole is too small. (C++: int32)
return: start of the hole or BADADDR
def get_16bit(*args) ‑> uint32
Get 16bits of the program at 'ea'.
get_16bit(ea) -> uint32
ea (C++: ea_t)
return: 1 byte (getFullByte()) if the current processor has 16-bit
byte, otherwise return get_word()
def get_32bit(*args) ‑> uint32
Get not more than 32bits of the program at 'ea'.
get_32bit(ea) -> uint32
ea (C++: ea_t)
return: 32 bit value, depending on \ph{nbits} : if ( nbits <= 8 )
return get_dword(ea); if ( nbits <= 16) return get_wide_word(ea); return get_wide_byte(ea);
def get_64bit(*args) ‑> uint64
Get not more than 64bits of the program at 'ea'.
get_64bit(ea) -> uint64
ea (C++: ea_t)
return: 64 bit value, depending on \ph{nbits} : if ( nbits <= 8 )
return get_qword(ea); if ( nbits <= 16) return get_wide_dword(ea); return get_wide_byte(ea);
def get_8bit(*args) ‑> PyObject *
get_8bit(ea, v, nbit) -> PyObject *
ea (C++: ea_t *)
v (C++: uint32 *)
nbit (C++: int *)
def get_byte(*args) ‑> uchar
Get one byte (8-bit) of the program at 'ea'. This function works only for 8bit byte processors.
get_byte(ea) -> uchar
ea (C++: ea_t)
def get_bytes(*args) ‑> PyObject *
get_bytes(ea, size, gmb_flags=0x01) -> PyObject *
Get the specified number of bytes of the program.
ea: program address
size: number of bytes to return
return: the bytes (as a str), or None in case of failure
def get_bytes_and_mask(*args) ‑> PyObject *
get_bytes_and_mask(ea, size, gmb_flags=0x01) -> PyObject *
Get the specified number of bytes of the program, and a bitmask specifying what bytes are defined and what bytes are not.
ea: program address
size: number of bytes to return
return: a tuple (bytes, mask), or None in case of failure.
Both 'bytes' and 'mask' are 'str' instances.
def get_cmt(*args) ‑> qstring *
Get an indented comment.
get_cmt(ea, rptble) -> str
ea: linear address. may point to tail byte, the function will
find start of the item (C++: ea_t)
rptble: get repeatable comment? (C++: bool)
return: size of comment or -1
def get_custom_data_format(*args) ‑> data_format_t const *
Get definition of a registered custom data format.
get_custom_data_format(dfid) -> data_format_t
dfid: data format id (C++: int)
return: data format definition or nullptr
def get_custom_data_formats(*args) ‑> int
Get list of attached custom data formats for the specified data type.
get_custom_data_formats(out, dtid) -> int
out: buffer for the output. may be nullptr (C++: intvec_t *)
dtid: data type id (C++: int)
return: number of returned custom data formats. if error, returns -1
def get_custom_data_type(*args) ‑> data_type_t const *
Get definition of a registered custom data type.
get_custom_data_type(dtid) -> data_type_t
dtid: data type id (C++: int)
return: data type definition or nullptr
def get_custom_data_types(*args) ‑> int
Get list of registered custom data type ids.
get_custom_data_types(out, min_size=0, max_size=BADADDR) -> int
out: buffer for the output. may be nullptr (C++: intvec_t *)
min_size: minimum value size (C++: asize_t)
max_size: maximum value size (C++: asize_t)
return: number of custom data types with the specified size limits
def get_data_elsize(*args) ‑> asize_t
Get size of data type specified in flags 'F'.
get_data_elsize(ea, F, ti=None) -> asize_t
ea: linear address of the item (C++: ea_t)
F: flags (C++: flags_t)
ti: additional information about the data type. For example, if
the current item is a structure instance, then ti->tid is structure id. Otherwise is ignored (may be nullptr). If specified as nullptr, will be automatically retrieved from the database (C++: const opinfo_t *)
return: byte : 1 word : 2 etc...
def get_data_value(*args) ‑> bool
Get the value at of the item at 'ea'. This function works with entities up to sizeof(ea_t) (bytes, word, etc)
get_data_value(v, ea, size) -> bool
v: pointer to the result. may be nullptr (C++: uval_t *)
ea: linear address (C++: ea_t)
size: size of data to read. If 0, then the item type at 'ea'
will be used (C++: asize_t)
return: success
def get_db_byte(*args) ‑> uchar
Get one byte (8-bit) of the program at 'ea' from the database. Works even if the debugger is active. See also 'get_dbg_byte()' to read the process memory directly. This function works only for 8bit byte processors.
get_db_byte(ea) -> uchar
ea (C++: ea_t)
def get_default_radix(*args) ‑> int
Get default base of number for the current processor.
def get_dword(*args) ‑> uint32
Get one dword (32-bit) of the program at 'ea'. This function takes into account order of bytes specified in \inf{is_be()} This function works only for 8bit byte processors.
get_dword(ea) -> uint32
ea (C++: ea_t)
def get_enum_id(*args) ‑> uchar *
Get enum id of 'enum' operand.
get_enum_id(ea, n) -> enum_t
ea: linear address (C++: ea_t)
n: number of operand (0, 1, -1) (C++: int)
return: id of enum or BADNODE
def get_first_hidden_range(*args) ‑> hidden_range_t *
Get pointer to the first hidden range.
def get_flags(*args) ‑> flags_t
get flags with 'FF_IVL' & 'MS_VAL' . It is much slower under remote debugging because the kernel needs to read the process memory.
get_flags(ea) -> flags_t
ea (C++: ea_t)
def get_flags_by_size(*args) ‑> flags_t
Get flags from size (in bytes). Supported sizes: 1, 2, 4, 8, 16, 32. For other sizes returns 0
get_flags_by_size(size) -> flags_t
size (C++: size_t)
def get_flags_ex(*args) ‑> flags_t
Get flags for the specified address, extended form.
get_flags_ex(ea, how) -> flags_t
ea (C++: ea_t)
how (C++: int)
def get_forced_operand(*args) ‑> qstring *
Get forced operand.
get_forced_operand(ea, n) -> str
ea: linear address (C++: ea_t)
n: number of operand (0, 1, 2) (C++: int)
return: size of forced operand or -1
def get_full_data_elsize(*args) ‑> asize_t
Get full size of data type specified in flags 'F'. takes into account processors with wide bytes e.g. returns 2 for a byte element with 16-bit bytes
get_full_data_elsize(ea, F, ti=None) -> asize_t
ea (C++: ea_t)
F (C++: flags_t)
ti (C++: const opinfo_t *)
def get_full_flags(*args) ‑> flags_t
Get flags value for address 'ea'.
get_full_flags(ea) -> flags_t
ea (C++: ea_t)
return: 0 if address is not present in the program
def get_hidden_range(*args) ‑> hidden_range_t *
Get pointer to hidden range structure, in: linear address.
get_hidden_range(ea) -> hidden_range_t
ea: any address in the hidden range (C++: ea_t)
def get_hidden_range_num(*args) ‑> int
Get number of a hidden range.
get_hidden_range_num(ea) -> int
ea: any address in the hidden range (C++: ea_t)
return: number of hidden range (0.. get_hidden_range_qty() -1)
def get_hidden_range_qty(*args) ‑> int
Get number of hidden ranges.
def get_item_end(*args) ‑> ea_t
Get the end address of the item at 'ea'. The returned address doesn't belong to the current item. Unexplored bytes are counted as 1 byte entities.
get_item_end(ea) -> ea_t
ea (C++: ea_t)
def get_item_flag(*args) ‑> flags_t
Get flag of the item at 'ea' even if it is a tail byte of some array or structure. This function is used to get flags of structure members or array elements.
get_item_flag(_from, n, ea, appzero) -> flags_t
_from: linear address of the instruction which refers to 'ea'
(C++: ea_t)
n: number of operand which refers to 'ea' (C++: int)
ea: the referenced address (C++: ea_t)
appzero: append a struct field name if the field offset is
zero? meaningful only if the name refers to a structure. (C++: bool)
return: flags or 0 (if failed)
def get_item_head(*args) ‑> ea_t
Get the start address of the item at 'ea'. If there is no current item, then 'ea' will be returned (see definition at the end of 'bytes.hpp' source)
get_item_head(ea) -> ea_t
ea (C++: ea_t)
def get_item_size(*args) ‑> asize_t
Get size of item (instruction/data) in bytes. Unexplored bytes have length of 1 byte. This function never returns 0.
get_item_size(ea) -> asize_t
ea (C++: ea_t)
def get_last_hidden_range(*args) ‑> hidden_range_t *
Get pointer to the last hidden range.
def get_manual_insn(*args) ‑> qstring *
Retrieve the user-specified string for the manual instruction.
get_manual_insn(ea) -> str
ea: linear address of the instruction or data item (C++: ea_t)
return: size of manual instruction or -1
def get_mapping(*args) ‑> ea_t *, ea_t *, asize_t *
Get memory mapping range by its number.
get_mapping(n) -> bool
n: number of mapping range (0.. get_mappings_qty() -1) (C++:
size_t)
return: false if the specified range doesn't exist, otherwise returns
from , to , size
def get_mappings_qty(*args) ‑> size_t
Get number of mappings.
def get_max_strlit_length(*args) ‑> size_t
Determine maximum length of string literal.If the string literal has a length prefix (e.g., STRTYPE_LEN2 has a two-byte length prefix), the length of that prefix (i.e., 2) will be part of the returned value.
get_max_strlit_length(ea, strtype, options=0) -> size_t
ea: starting address (C++: ea_t)
strtype: string type. one of String type codes (C++: int32)
options: combination of string literal length options (C++:
int)
return: length of the string in octets (octet==8bit)
def get_next_hidden_range(*args) ‑> hidden_range_t *
Get pointer to next hidden range.
get_next_hidden_range(ea) -> hidden_range_t
ea: any address in the program (C++: ea_t)
return: ptr to hidden range or nullptr if next hidden range doesn't
exist
def get_octet(*args) ‑> PyObject *
Get 8 bits of the program at 'ea'. The main usage of this function is to iterate range of bytes. Here is an example:
uint64 v; int nbit = 0; for ( ... ) {
uchar byte = get_octet(&ea, &v, &nbit); ...
}
'ea' is incremented each time when a new byte is read. In the above example, it will be incremented in the first loop iteration.
get_octet(ea, v, nbit) -> PyObject *
ea (C++: ea_t *)
v (C++: uint64 *)
nbit (C++: int *)
def get_opinfo(*args) ‑> opinfo_t *
Get additional information about an operand representation.
get_opinfo(buf, ea, n, flags) -> opinfo_t
buf: buffer to receive the result. may not be nullptr (C++:
opinfo_t *)
ea: linear address of item (C++: ea_t)
n: number of operand, 0 or 1 (C++: int)
flags: flags of the item (C++: flags_t)
return: nullptr if no additional representation information
def get_optype_flags0(*args) ‑> flags_t
Get flags for first operand.
get_optype_flags0(F) -> flags_t
F (C++: flags_t)
def get_optype_flags1(*args) ‑> flags_t
Get flags for second operand.
get_optype_flags1(F) -> flags_t
F (C++: flags_t)
def get_original_byte(*args) ‑> uint64
Get original byte value (that was before patching). This function works for wide byte processors too.
get_original_byte(ea) -> uint64
ea (C++: ea_t)
def get_original_dword(*args) ‑> uint64
Get original dword (that was before patching) This function works for wide byte processors too. This function takes into account order of bytes specified in \inf{is_be()}
get_original_dword(ea) -> uint64
ea (C++: ea_t)
def get_original_qword(*args) ‑> uint64
Get original qword value (that was before patching) This function DOESN'T work for wide byte processors too. This function takes into account order of bytes specified in \inf{is_be()}
get_original_qword(ea) -> uint64
ea (C++: ea_t)
def get_original_word(*args) ‑> uint64
Get original word value (that was before patching). This function works for wide byte processors too. This function takes into account order of bytes specified in \inf{is_be()}
get_original_word(ea) -> uint64
ea (C++: ea_t)
def get_predef_insn_cmt(*args) ‑> qstring *
Get predefined comment.
get_predef_insn_cmt(ins) -> str
ins: current instruction information - an ida_ua.insn_t, or an
address (C++: const insn_t &)
return: size of comment or -1
def get_prev_hidden_range(*args) ‑> hidden_range_t *
Get pointer to previous hidden range.
get_prev_hidden_range(ea) -> hidden_range_t
ea: any address in the program (C++: ea_t)
return: ptr to hidden range or nullptr if previous hidden range
doesn't exist
def get_qword(*args) ‑> uint64
Get one qword (64-bit) of the program at 'ea'. This function takes into account order of bytes specified in \inf{is_be()} This function works only for 8bit byte processors.
get_qword(ea) -> uint64
ea (C++: ea_t)
def get_radix(*args) ‑> int
Get radix of the operand, in: flags. If the operand is not a number, returns 'get_default_radix()'
get_radix(F, n) -> int
F: flags (C++: flags_t)
n: number of operand (0, 1, -1) (C++: int)
return: 2, 8, 10, 16
def get_strlit_contents(*args) ‑> PyObject *
get_strlit_contents(ea, py_len, type, flags=0) -> PyObject *
Get bytes contents at location, possibly converted. It works even if the string has not been created in the database yet.
Note that this will <b>always</b> return a simple string of bytes (i.e., a 'str' instance), and not a string of unicode characters.
If you want auto-conversion to unicode strings (that is: real strings), you should probably be using the idautils.Strings class.
ea: linear address of the string
len: length of the string in bytes (including terminating 0)
type: type of the string. Represents both the character encoding,
<u>and</u> the 'type' of string at the given location.
flags: combination of STRCONV_..., to perform output conversion.
return: a bytes-filled str object.
def get_stroff_path(*args) ‑> int
Get struct path of operand.
get_stroff_path(path, delta, ea, n) -> int
path: buffer for structure path (strpath). see nalt.hpp for
more info. (C++: tid_t *)
delta: struct offset delta (C++: adiff_t *)
ea: linear address (C++: ea_t)
n: number of operand (0, 1, -1) (C++: int)
return: length of strpath
def get_wide_byte(*args) ‑> uint64
Get one wide byte of the program at 'ea'. Some processors may access more than 8bit quantity at an address. These processors have 32-bit byte organization from the IDA's point of view.
get_wide_byte(ea) -> uint64
ea (C++: ea_t)
def get_wide_dword(*args) ‑> uint64
Get two wide words (4 'bytes') of the program at 'ea'. Some processors may access more than 8bit quantity at an address. These processors have 32-bit byte organization from the IDA's point of view. This function takes into account order of bytes specified in
\inf{is_be()}
this function works incorrectly if \ph{nbits} > 16
get_wide_dword(ea) -> uint64
ea (C++: ea_t)
def get_wide_word(*args) ‑> uint64
Get one wide word (2 'byte') of the program at 'ea'. Some processors may access more than 8bit quantity at an address. These processors have 32-bit byte organization from the IDA's point of view. This function takes into account order of bytes specified in \inf{is_be()}
get_wide_word(ea) -> uint64
ea (C++: ea_t)
def get_word(*args) ‑> ushort
Get one word (16-bit) of the program at 'ea'. This function takes into account order of bytes specified in \inf{is_be()} This function works only for 8bit byte processors.
get_word(ea) -> ushort
ea (C++: ea_t)
def get_zero_ranges(*args) ‑> bool
Return set of ranges with zero initialized bytes. The returned set includes only big zero initialized ranges (at least >1KB). Some zero initialized byte ranges may be not included. Only zero bytes that use the sparse storage method (STT_MM) are reported.
get_zero_ranges(zranges, range) -> bool
zranges: pointer to the return value. cannot be nullptr (C++:
rangeset_t *)
range: the range of addresses to verify. can be nullptr - means
all ranges (C++: const range_t *)
return: true if the result is a non-empty set
def getn_hidden_range(*args) ‑> hidden_range_t *
Get pointer to hidden range structure, in: number of hidden range.
getn_hidden_range(n) -> hidden_range_t
n: number of hidden range, is in range 0..
get_hidden_range_qty() -1 (C++: int)
def has_any_name(*args) ‑> bool
Does the current byte have any name?
has_any_name(F) -> bool
F (C++: flags_t)
def has_auto_name(*args) ‑> bool
Does the current byte have auto-generated (no special prefix) name?
has_auto_name(F) -> bool
F (C++: flags_t)
def has_cmt(*args) ‑> bool
Does the current byte have an indented comment?
has_cmt(F) -> bool
F (C++: flags_t)
def has_dummy_name(*args) ‑> bool
Does the current byte have dummy (auto-generated, with special prefix) name?
has_dummy_name(F) -> bool
F (C++: flags_t)
def has_extra_cmts(*args) ‑> bool
Does the current byte have additional anterior or posterior lines?
has_extra_cmts(F) -> bool
F (C++: flags_t)
def has_immd(*args) ‑> bool
Has immediate value?
has_immd(F) -> bool
F (C++: flags_t)
def has_name(*args) ‑> bool
Does the current byte have non-trivial (non-dummy) name?
has_name(F) -> bool
F (C++: flags_t)
def has_user_name(*args) ‑> bool
Does the current byte have user-specified name?
has_user_name(F) -> bool
F (C++: flags_t)
def has_value(*args) ‑> bool
Do flags contain byte value?
has_value(F) -> bool
F (C++: flags_t)
def has_xref(*args) ‑> bool
Does the current byte have cross-references to it?
has_xref(F) -> bool
F (C++: flags_t)
def hex_flag(*args) ‑> flags_t
Get number flag of the base, regardless of current processor - better to use 'num_flag()'
def is_align(*args) ‑> bool
'FF_ALIGN'
is_align(F) -> bool
F (C++: flags_t)
def is_attached_custom_data_format(*args) ‑> bool
Is the custom data format attached to the custom data type?
is_attached_custom_data_format(dtid, dfid) -> bool
dtid: data type id (C++: int)
dfid: data format id (C++: int)
return: true or false
def is_bnot(*args) ‑> bool
Should we negate the operand?. \ash{a_bnot} should be defined in the idp module in order to work with this function
is_bnot(ea, F, n) -> bool
ea (C++: ea_t)
F (C++: flags_t)
n (C++: int)
def is_byte(*args) ‑> bool
'FF_BYTE'
is_byte(F) -> bool
F (C++: flags_t)
def is_char(*args) ‑> bool
is character constant?
is_char(F, n) -> bool
F (C++: flags_t)
n (C++: int)
def is_char0(*args) ‑> bool
Is the first operand character constant? (example: push 'a')
is_char0(F) -> bool
F (C++: flags_t)
def is_char1(*args) ‑> bool
Is the second operand character constant? (example: mov al, 'a')
is_char1(F) -> bool
F (C++: flags_t)
def is_code(*args) ‑> bool
Does flag denote start of an instruction?
is_code(F) -> bool
F (C++: flags_t)
def is_custfmt(*args) ‑> bool
is custom data format?
is_custfmt(F, n) -> bool
F (C++: flags_t)
n (C++: int)
def is_custfmt0(*args) ‑> bool
Does the first operand use a custom data representation?
is_custfmt0(F) -> bool
F (C++: flags_t)
def is_custfmt1(*args) ‑> bool
Does the second operand use a custom data representation?
is_custfmt1(F) -> bool
F (C++: flags_t)
def is_custom(*args) ‑> bool
'FF_CUSTOM'
is_custom(F) -> bool
F (C++: flags_t)
def is_data(*args) ‑> bool
Does flag denote start of data?
is_data(F) -> bool
F (C++: flags_t)
def is_defarg(*args) ‑> bool
is defined?
is_defarg(F, n) -> bool
F (C++: flags_t)
n (C++: int)
def is_defarg0(*args) ‑> bool
Is the first operand defined? Initially operand has no defined representation.
is_defarg0(F) -> bool
F (C++: flags_t)
def is_defarg1(*args) ‑> bool
Is the second operand defined? Initially operand has no defined representation.
is_defarg1(F) -> bool
F (C++: flags_t)
def is_double(*args) ‑> bool
'FF_DOUBLE'
is_double(F) -> bool
F (C++: flags_t)
def is_dword(*args) ‑> bool
'FF_DWORD'
is_dword(F) -> bool
F (C++: flags_t)
def is_enum(*args) ‑> bool
is enum?
is_enum(F, n) -> bool
F (C++: flags_t)
n (C++: int)
def is_enum0(*args) ‑> bool
Is the first operand a symbolic constant (enum member)?
is_enum0(F) -> bool
F (C++: flags_t)
def is_enum1(*args) ‑> bool
Is the second operand a symbolic constant (enum member)?
is_enum1(F) -> bool
F (C++: flags_t)
def is_float(*args) ‑> bool
'FF_FLOAT'
is_float(F) -> bool
F (C++: flags_t)
def is_float0(*args) ‑> bool
Is the first operand a floating point number?
is_float0(F) -> bool
F (C++: flags_t)
def is_float1(*args) ‑> bool
Is the second operand a floating point number?
is_float1(F) -> bool
F (C++: flags_t)
def is_flow(*args) ‑> bool
Does the previous instruction exist and pass execution flow to the current byte?
is_flow(F) -> bool
F (C++: flags_t)
def is_fltnum(*args) ‑> bool
is floating point number?
is_fltnum(F, n) -> bool
F (C++: flags_t)
n (C++: int)
def is_forced_operand(*args) ‑> bool
Is operand manually defined?.
is_forced_operand(ea, n) -> bool
ea: linear address (C++: ea_t)
n: number of operand (0, 1, 2) (C++: int)
def is_func(*args) ‑> bool
Is function start?
is_func(F) -> bool
F (C++: flags_t)
def is_head(*args) ‑> bool
Does flag denote start of instruction OR data?
is_head(F) -> bool
F (C++: flags_t)
def is_invsign(*args) ‑> bool
Should sign of n-th operand inverted during output?. allowed values of n: 0-first operand, 1-other operands
is_invsign(ea, F, n) -> bool
ea (C++: ea_t)
F (C++: flags_t)
n (C++: int)
def is_loaded(*args) ‑> bool
Does the specified address have a byte value (is initialized?)
is_loaded(ea) -> bool
ea (C++: ea_t)
def is_lzero(*args) ‑> bool
Display leading zeroes in operands. The global switch for the leading zeroes is in \inf{s_genflags} The leading zeroes doesn't work if the octal numbers start with 0 Display leading zeroes? (takes into account
\inf{s_genflags}
)
is_lzero(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def is_manual(*args) ‑> bool
is forced operand? (use 'is_forced_operand()' )
is_manual(F, n) -> bool
F (C++: flags_t)
n (C++: int)
def is_manual_insn(*args) ‑> bool
Is the instruction overridden?
is_manual_insn(ea) -> bool
ea: linear address of the instruction or data item (C++: ea_t)
def is_mapped(*args) ‑> bool
Is the specified address 'ea' present in the program?
is_mapped(ea) -> bool
ea (C++: ea_t)
def is_not_tail(*args) ‑> bool
Does flag denote tail byte?
is_not_tail(F) -> bool
F (C++: flags_t)
def is_numop(*args) ‑> bool
is number (bin, oct, dec, hex)?
is_numop(F, n) -> bool
F (C++: flags_t)
n (C++: int)
def is_numop0(*args) ‑> bool
Is the first operand a number (i.e. binary, octal, decimal or hex?)
is_numop0(F) -> bool
F (C++: flags_t)
def is_numop1(*args) ‑> bool
Is the second operand a number (i.e. binary, octal, decimal or hex?)
is_numop1(F) -> bool
F (C++: flags_t)
def is_off(*args) ‑> bool
is offset?
is_off(F, n) -> bool
F (C++: flags_t)
n (C++: int)
def is_off0(*args) ‑> bool
Is the first operand offset? (example: push offset xxx)
is_off0(F) -> bool
F (C++: flags_t)
def is_off1(*args) ‑> bool
Is the second operand offset? (example: mov ax, offset xxx)
is_off1(F) -> bool
F (C++: flags_t)
def is_oword(*args) ‑> bool
'FF_OWORD'
is_oword(F) -> bool
F (C++: flags_t)
def is_pack_real(*args) ‑> bool
'FF_PACKREAL'
is_pack_real(F) -> bool
F (C++: flags_t)
def is_qword(*args) ‑> bool
'FF_QWORD'
is_qword(F) -> bool
F (C++: flags_t)
def is_same_data_type(*args) ‑> bool
Do the given flags specify the same data type?
is_same_data_type(F1, F2) -> bool
F1 (C++: flags_t)
F2 (C++: flags_t)
def is_seg(*args) ‑> bool
is segment?
is_seg(F, n) -> bool
F (C++: flags_t)
n (C++: int)
def is_seg0(*args) ‑> bool
Is the first operand segment selector? (example: push seg seg001)
is_seg0(F) -> bool
F (C++: flags_t)
def is_seg1(*args) ‑> bool
Is the second operand segment selector? (example: mov dx, seg dseg)
is_seg1(F) -> bool
F (C++: flags_t)
def is_stkvar(*args) ‑> bool
is stack variable?
is_stkvar(F, n) -> bool
F (C++: flags_t)
n (C++: int)
def is_stkvar0(*args) ‑> bool
Is the first operand a stack variable?
is_stkvar0(F) -> bool
F (C++: flags_t)
def is_stkvar1(*args) ‑> bool
Is the second operand a stack variable?
is_stkvar1(F) -> bool
F (C++: flags_t)
def is_strlit(*args) ‑> bool
'FF_STRLIT'
is_strlit(F) -> bool
F (C++: flags_t)
def is_stroff(*args) ‑> bool
is struct offset?
is_stroff(F, n) -> bool
F (C++: flags_t)
n (C++: int)
def is_stroff0(*args) ‑> bool
Is the first operand an offset within a struct?
is_stroff0(F) -> bool
F (C++: flags_t)
def is_stroff1(*args) ‑> bool
Is the second operand an offset within a struct?
is_stroff1(F) -> bool
F (C++: flags_t)
def is_struct(*args) ‑> bool
'FF_STRUCT'
is_struct(F) -> bool
F (C++: flags_t)
def is_suspop(*args) ‑> bool
is suspicious operand?
is_suspop(ea, F, n) -> bool
ea (C++: ea_t)
F (C++: flags_t)
n (C++: int)
def is_tail(*args) ‑> bool
Does flag denote tail byte?
is_tail(F) -> bool
F (C++: flags_t)
def is_tbyte(*args) ‑> bool
'FF_TBYTE'
is_tbyte(F) -> bool
F (C++: flags_t)
def is_unknown(*args) ‑> bool
Does flag denote unexplored byte?
is_unknown(F) -> bool
F (C++: flags_t)
def is_varsize_item(*args) ‑> int
Is the item at 'ea' variable size?.
is_varsize_item(ea, F, ti=None, itemsize=None) -> int
ea: linear address of the item (C++: ea_t)
F: flags (C++: flags_t)
ti: additional information about the data type. For example, if
the current item is a structure instance, then ti->tid is structure id. Otherwise is ignored (may be nullptr). If specified as nullptr, will be automatically retrieved from the database (C++: const opinfo_t *)
itemsize: if not nullptr and the item is varsize, itemsize will
contain the calculated item size (for struct types, the minimal size is returned) (C++: asize_t *)
retval: 1 - varsize item
retval: 0 - fixed item
retval: -1 - error (bad data definition)
def is_word(*args) ‑> bool
'FF_WORD'
is_word(F) -> bool
F (C++: flags_t)
def is_yword(*args) ‑> bool
'FF_YWORD'
is_yword(F) -> bool
F (C++: flags_t)
def is_zword(*args) ‑> bool
'FF_ZWORD'
is_zword(F) -> bool
F (C++: flags_t)
def leading_zero_important(*args) ‑> bool
Check if leading zeroes are important.
leading_zero_important(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def nbits(*args) ‑> int
Get number of bits in a byte at the given address.
nbits(ea) -> int
ea (C++: ea_t)
return: \ph{dnbits()} if the address doesn't belong to a segment,
otherwise the result depends on the segment type
def next_addr(*args) ‑> ea_t
Get next address in the program (i.e. next address which has flags).
next_addr(ea) -> ea_t
ea (C++: ea_t)
return: BADADDR if no such address exist.
def next_chunk(*args) ‑> ea_t
Get the first address of next contiguous chunk in the program.
next_chunk(ea) -> ea_t
ea (C++: ea_t)
return: BADADDR if next chunk doesn't exist.
def next_head(*args) ‑> ea_t
Get start of next defined item.
next_head(ea, maxea) -> ea_t
ea: begin search at this address (C++: ea_t)
maxea: not included in the search range (C++: ea_t)
return: BADADDR if none exists.
def next_inited(*args) ‑> ea_t
Find the next initialized address.
next_inited(ea, maxea) -> ea_t
ea (C++: ea_t)
maxea (C++: ea_t)
def next_not_tail(*args) ‑> ea_t
Get address of next non-tail byte.
next_not_tail(ea) -> ea_t
ea (C++: ea_t)
return: BADADDR if none exists.
def next_that(*args) ‑> ea_t
next_that(ea, maxea, callable) -> ea_t
Find next address with a flag satisfying the function 'testf'. Start searching from address 'ea'+1 and inspect bytes up to 'maxea'. maxea is not included in the search range.
callable: a Python callable with the following prototype:
callable(flags). Return True to stop enumeration.
return: the found address or BADADDR.
def next_unknown(*args) ‑> ea_t
Similar to 'next_that()' , but will find the next address that is unexplored.
next_unknown(ea, maxea) -> ea_t
ea (C++: ea_t)
maxea (C++: ea_t)
def next_visea(*args) ‑> ea_t
Get next visible address.
next_visea(ea) -> ea_t
ea (C++: ea_t)
return: BADADDR if none exists.
def num_flag(*args) ‑> flags_t
Get number of default base (bin, oct, dec, hex)
def oct_flag(*args) ‑> flags_t
Get number flag of the base, regardless of current processor - better to use 'num_flag()'
def off_flag(*args) ‑> flags_t
see 'Bits: instruction operand types'
def op_adds_xrefs(*args) ‑> bool
Should processor module create xrefs from the operand?. Currently 'offset' and 'structure offset' operands create xrefs
op_adds_xrefs(F, n) -> bool
F (C++: flags_t)
n (C++: int)
def op_bin(*args) ‑> bool
set op type to 'bin_flag()'
op_bin(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def op_chr(*args) ‑> bool
set op type to 'char_flag()'
op_chr(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def op_custfmt(*args) ‑> bool
Set custom data format for operand (fid-custom data format id)
op_custfmt(ea, n, fid) -> bool
ea (C++: ea_t)
n (C++: int)
fid (C++: int)
def op_dec(*args) ‑> bool
set op type to 'dec_flag()'
op_dec(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def op_enum(*args) ‑> bool
Set operand representation to be 'enum_t'. If applied to unexplored bytes, converts them to 16/32bit word data
op_enum(ea, n, id, serial) -> bool
ea: linear address (C++: ea_t)
n: number of operand (0, 1, -1) (C++: int)
id: id of enum (C++: enum_t)
serial: the serial number of the constant in the enumeration,
usually 0. the serial numbers are used if the enumeration contains several constants with the same value (C++: uchar)
return: success
def op_flt(*args) ‑> bool
set op type to 'flt_flag()'
op_flt(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def op_hex(*args) ‑> bool
set op type to 'hex_flag()'
op_hex(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def op_num(*args) ‑> bool
set op type to 'num_flag()'
op_num(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def op_oct(*args) ‑> bool
set op type to 'oct_flag()'
op_oct(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def op_seg(*args) ‑> bool
Set operand representation to be 'segment'. If applied to unexplored bytes, converts them to 16/32bit word data
op_seg(ea, n) -> bool
ea: linear address (C++: ea_t)
n: number of operand (0, 1, -1) (C++: int)
return: success
def op_stkvar(*args) ‑> bool
Set operand representation to be 'stack variable'. Should be applied to an instruction within a function. Should be applied after creating a stack var using 'insn_t::create_stkvar()' .
op_stkvar(ea, n) -> bool
ea: linear address (C++: ea_t)
n: number of operand (0, 1, -1) (C++: int)
return: success
def op_stroff(*args) ‑> bool
Set operand representation to be 'struct offset'. If applied to unexplored bytes, converts them to 16/32bit word data
op_stroff(insn, n, path, path_len, delta) -> bool
insn: the instruction - an ida_ua.insn_t, or an address (C++:
const insn_t &)
n: number of operand (0, 1, -1) (C++: int)
path: structure path (strpath). see nalt.hpp for more info.
(C++: const tid_t *)
path_len: length of the structure path (C++: int)
delta: struct offset delta. usually 0. denotes the difference
between the structure base and the pointer into the structure. (C++: adiff_t)
return: success
Example: Python> Python> ins = ida_ua.insn_t() Python> if ida_ua.decode_insn(ins, some_address): Python> path_len = 1 Python> path = ida_pro.tid_array(path_len) Python> path[0] = ida_struct.get_struc_id("my_stucture_t") Python> ida_bytes.op_stroff(ins, 0, path.cast(), path_len, 0) Python>
def oword_flag(*args) ‑> flags_t
Get a flags_t representing a octaword.
def packreal_flag(*args) ‑> flags_t
Get a flags_t representing a packed decimal real.
def parse_binpat_str(*args) ‑> qstring *
Convert user-specified binary string to internal representation. The 'in' parameter contains space-separated tokens:
  • numbers (numeric base is determined by 'radix')
    • if value of number fits a byte, it is considered as a byte
    • if value of number fits a word, it is considered as 2 bytes
    • if value of number fits a dword,it is considered as 4 bytes
  • "..." string constants
  • 'x' single-character constants
  • ? variable bytes
Note that string constants are surrounded with double quotes.Here are a few examples (assuming base 16):
CD 21 - bytes 0xCD, 0x21 21CD - bytes 0xCD, 0x21 (little endian ) or 0x21, 0xCD (big-endian) "Hello", 0 - the null terminated string "Hello" L"Hello" - 'H', 0, 'e', 0, 'l', 0, 'l', 0, 'o', 0 B8 ? ? ? ? 90 - byte 0xB8, 4 bytes with any value, byte 0x90
parse_binpat_str(out, ea, _in, radix, strlits_encoding=0) -> str
out: a vector of compiled binary patterns, for use with
bin_search2() (C++: compiled_binpat_vec_t *)
ea: linear address to convert for (the conversion depends on
the address, because the number of bits in a byte depend on the segment type) (C++: ea_t)
in: char const *
radix: numeric base of numbers (8,10,16) (C++: int)
strlits_encoding: the target encoding into which the string
literals present in 'in', should be encoded. Can be any from [1, get_encoding_qty() ), or the special values PBSENC_* (C++: int)
return: false either in case of parsing error, or if at least one
requested target encoding couldn't encode the string literals present in "in".
def patch_byte(*args) ‑> bool
Patch a byte of the program. The original value of the byte is saved and can be obtained by 'get_original_byte()' . This function works for wide byte processors too.
patch_byte(ea, x) -> bool
ea (C++: ea_t)
x (C++: uint64)
retval: true - the database has been modified,
retval: false - the debugger is running and the process' memory has
value 'x' at address 'ea', or the debugger is not running, and the IDB has value 'x' at address 'ea already.
def patch_bytes(*args) ‑> void
Patch the specified number of bytes of the program. Original values of bytes are saved and are available with get_original...() functions. See also 'put_bytes()' .
patch_bytes(ea, buf)
ea: linear address (C++: ea_t)
buf: buffer with new values of bytes (C++: const void *)
def patch_dword(*args) ‑> bool
Patch a dword of the program. The original value of the dword is saved and can be obtained by 'get_original_dword()' . This function DOESN'T work for wide byte processors. This function takes into account order of bytes specified in \inf{is_be()}
patch_dword(ea, x) -> bool
ea (C++: ea_t)
x (C++: uint64)
retval: true - the database has been modified,
retval: false - the debugger is running and the process' memory has
value 'x' at address 'ea', or the debugger is not running, and the IDB has value 'x' at address 'ea already.
def patch_qword(*args) ‑> bool
Patch a qword of the program. The original value of the qword is saved and can be obtained by 'get_original_qword()' . This function DOESN'T work for wide byte processors. This function takes into account order of bytes specified in \inf{is_be()}
patch_qword(ea, x) -> bool
ea (C++: ea_t)
x (C++: uint64)
retval: true - the database has been modified,
retval: false - the debugger is running and the process' memory has
value 'x' at address 'ea', or the debugger is not running, and the IDB has value 'x' at address 'ea already.
def patch_word(*args) ‑> bool
Patch a word of the program. The original value of the word is saved and can be obtained by 'get_original_word()' . This function works for wide byte processors too. This function takes into account order of bytes specified in \inf{is_be()}
patch_word(ea, x) -> bool
ea (C++: ea_t)
x (C++: uint64)
retval: true - the database has been modified,
retval: false - the debugger is running and the process' memory has
value 'x' at address 'ea', or the debugger is not running, and the IDB has value 'x' at address 'ea already.
def prev_addr(*args) ‑> ea_t
Get previous address in the program.
prev_addr(ea) -> ea_t
ea (C++: ea_t)
return: BADADDR if no such address exist.
def prev_chunk(*args) ‑> ea_t
Get the last address of previous contiguous chunk in the program.
prev_chunk(ea) -> ea_t
ea (C++: ea_t)
return: BADADDR if previous chunk doesn't exist.
def prev_head(*args) ‑> ea_t
Get start of previous defined item.
prev_head(ea, minea) -> ea_t
ea: begin search at this address (C++: ea_t)
minea: included in the search range (C++: ea_t)
return: BADADDR if none exists.
def prev_inited(*args) ‑> ea_t
Find the previous initialized address.
prev_inited(ea, minea) -> ea_t
ea (C++: ea_t)
minea (C++: ea_t)
def prev_not_tail(*args) ‑> ea_t
Get address of previous non-tail byte.
prev_not_tail(ea) -> ea_t
ea (C++: ea_t)
return: BADADDR if none exists.
def prev_that(*args) ‑> ea_t
Find previous address with a flag satisfying the function 'testf'.do not pass 'is_unknown()' to this function to find unexplored bytes It will fail under the debugger. To find unexplored bytes, use 'prev_unknown()' .
prev_that(ea, minea, callable) -> ea_t
ea: start searching from this address - 1. (C++: ea_t)
minea: included in the search range. (C++: ea_t) callable: PyObject *
return: the found address or BADADDR .
def prev_unknown(*args) ‑> ea_t
Similar to 'prev_that()' , but will find the previous address that is unexplored.
prev_unknown(ea, minea) -> ea_t
ea (C++: ea_t)
minea (C++: ea_t)
def prev_visea(*args) ‑> ea_t
Get previous visible address.
prev_visea(ea) -> ea_t
ea (C++: ea_t)
return: BADADDR if none exists.
def print_strlit_type(*args) ‑> PyObject *
Get string type information: the string type name (possibly decorated with hotkey markers), and the tooltip.
print_strlit_type(strtype, flags=0) -> PyObject *
strtype: the string type (C++: int32)
flags: or'ed PSTF_* constants (C++: int)
return: length of generated text
def put_byte(*args) ‑> bool
Set value of one byte of the program. This function modifies the database. If the debugger is active then the debugged process memory is patched too.The original value of the byte is completely lost and can't be recovered by the 'get_original_byte()' function. See also 'put_dbg_byte()' to write to the process memory directly when the debugger is active. This function can handle wide byte processors.
put_byte(ea, x) -> bool
ea: linear address (C++: ea_t)
x: byte value (C++: uint64)
return: true if the database has been modified
def put_bytes(*args) ‑> void
Modify the specified number of bytes of the program. This function does not save the original values of bytes. See also 'patch_bytes()' .
put_bytes(ea, buf)
ea: linear address (C++: ea_t)
buf: buffer with new values of bytes (C++: const void *)
def put_dword(*args) ‑> void
Set value of one dword of the program. This function takes into account order of bytes specified in \inf{is_be()} This function works for wide byte processors too.the original value of the dword is completely lost and can't be recovered by the 'get_original_dword()' function.
put_dword(ea, x)
ea: linear address (C++: ea_t)
x: dword value (C++: uint64)
def put_qword(*args) ‑> void
Set value of one qword (8 bytes) of the program. This function takes into account order of bytes specified in \inf{is_be()} This function DOESN'T works for wide byte processors.
put_qword(ea, x)
ea: linear address (C++: ea_t)
x: qword value (C++: uint64)
def put_word(*args) ‑> void
Set value of one word of the program. This function takes into account order of bytes specified in \inf{is_be()} This function works for wide byte processors too.The original value of the word is completely lost and can't be recovered by the 'get_original_word()' function. ea - linear address x - word value
put_word(ea, x)
ea (C++: ea_t)
x (C++: uint64)
def qword_flag(*args) ‑> flags_t
Get a flags_t representing a quad word.
def register_custom_data_format(*args) ‑> int
register_custom_data_format(py_df) -> int
Registers a custom data format with a given data type.
df: an instance of data_format_t
return:
< 0 if failed to register > 0 data format id
def register_custom_data_type(*args) ‑> int
register_custom_data_type(py_dt) -> int
Registers a custom data type.
dt: an instance of the data_type_t class
return:
< 0 if failed to register > 0 data type id
def register_data_types_and_formats(formats)
Registers multiple data types and formats at once. To register one type/format at a time use register_custom_data_type/register_custom_data_format
It employs a special table of types and formats described below:
The 'formats' is a list of tuples. If a tuple has one element then it is the format to be registered with dtid=0 If the tuple has more than one element, then tuple[0] is the data type and tuple[1:] are the data formats. For example: many_formats = [
(pascal_data_type(), pascal_data_format()), (simplevm_data_type(), simplevm_data_format()), (makedword_data_format(),), (simplevm_data_format(),)
] The first two tuples describe data types and their associated formats. The last two tuples describe two data formats to be used with built-in data types. The data format may be attached to several data types. The id of the data format is stored in the first data_format_t object. For example: assert many_formats[1][1] != -1 assert many_formats[2][0] != -1 assert many_formats[3][0] == -1
def revert_byte(*args) ‑> bool
Revert patched byte
revert_byte(ea) -> bool
ea (C++: ea_t)
retval: true - byte was patched before and reverted now
def seg_flag(*args) ‑> flags_t
see 'Bits: instruction operand types'
def set_cmt(*args) ‑> bool
Set an indented comment.
set_cmt(ea, comm, rptble) -> bool
ea: linear address (C++: ea_t)
comm: comment string nullptr: do nothing (return 0) "" :
delete comment (C++: const char *)
rptble: is repeatable? (C++: bool)
return: success
def set_forced_operand(*args) ‑> bool
Set forced operand.
set_forced_operand(ea, n, op) -> bool
ea: linear address (C++: ea_t)
n: number of operand (0, 1, 2) (C++: int)
op: text of operand nullptr: do nothing (return 0) "" :
delete forced operand (C++: const char *)
return: success
def set_immd(*args) ‑> bool
Set 'has immediate operand' flag. Returns true if the 'FF_IMMD' bit was not set and now is set
set_immd(ea) -> bool
ea (C++: ea_t)
def set_lzero(*args) ‑> bool
Set toggle lzero bit.
set_lzero(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def set_manual_insn(*args) ‑> void
Set manual instruction string.
set_manual_insn(ea, manual_insn)
ea: linear address of the instruction or data item (C++: ea_t)
manual_insn: "" - delete manual string. nullptr - do nothing
(C++: const char *)
def set_op_type(*args) ‑> bool
(internal function) change representation of operand(s).
set_op_type(ea, type, n) -> bool
ea: linear address (C++: ea_t)
type: new flag value (should be obtained from char_flag() ,
num_flag() and similar functions) (C++: flags_t)
n: number of operand (0, 1, -1) (C++: int)
retval: 1 - ok
retval: 0 - failed (applied to a tail byte)
def set_opinfo(*args) ‑> bool
Set additional information about an operand representation. This function is a low level one. Only the kernel should use it.
set_opinfo(ea, n, flag, ti, suppress_events=False) -> bool
ea: linear address of the item (C++: ea_t)
n: number of operand, 0 or 1 (C++: int)
flag: flags of the item (C++: flags_t)
ti: additional representation information (C++: const opinfo_t
*)
suppress_events: do not generate changing_op_type and
op_type_changed events (C++: bool)
return: success
def stkvar_flag(*args) ‑> flags_t
see 'Bits: instruction operand types'
def strlit_flag(*args) ‑> flags_t
Get a flags_t representing a string literal.
def stroff_flag(*args) ‑> flags_t
see 'Bits: instruction operand types'
def stru_flag(*args) ‑> flags_t
Get a flags_t representing a struct.
def tbyte_flag(*args) ‑> flags_t
Get a flags_t representing a tbyte.
def toggle_bnot(*args) ‑> bool
Toggle binary negation of operand. also see 'is_bnot()'
toggle_bnot(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def toggle_lzero(*args) ‑> bool
toggle_lzero(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def toggle_sign(*args) ‑> bool
Toggle sign of n-th operand. allowed values of n: 0-first operand, 1-other operands
toggle_sign(ea, n) -> bool
ea (C++: ea_t)
n (C++: int)
def unregister_custom_data_format(*args) ‑> bool
unregister_custom_data_format(dfid) -> bool
Unregisters a custom data format
dfid: data format id
return: Boolean
def unregister_custom_data_type(*args) ‑> bool
unregister_custom_data_type(dtid) -> bool
Unregisters a custom data type.
dtid: the data type id
return: Boolean
def unregister_data_types_and_formats(formats)
As opposed to register_data_types_and_formats(), this function unregisters multiple data types and formats at once.
def update_hidden_range(*args) ‑> bool
Update hidden range information in the database. You cannot use this function to change the range boundaries
update_hidden_range(ha) -> bool
ha: range to update (C++: const hidden_range_t *)
return: success
def use_mapping(*args) ‑> ea_t
Translate address according to current mappings.
use_mapping(ea) -> ea_t
ea: address to translate (C++: ea_t)
return: translated address
def visit_patched_bytes(*args) ‑> int
visit_patched_bytes(ea1, ea2, py_callable) -> int
Enumerates patched bytes in the given range and invokes a callable
ea1: start address
ea2: end address
callable: a Python callable with the following prototype:
callable(ea, fpos, org_val, patch_val). If the callable returns non-zero then that value will be returned to the caller and the enumeration will be interrupted.
return: Zero if the enumeration was successful or the return
value of the callback if enumeration was interrupted.
def word_flag(*args) ‑> flags_t
Get a flags_t representing a word.
def yword_flag(*args) ‑> flags_t
Get a flags_t representing a ymm word.
def zword_flag(*args) ‑> flags_t
Get a flags_t representing a zmm word.

Classes

class compiled_binpat_t (*args)
Proxy of C++ compiled_binpat_t class.
__init__(self) -> compiled_binpat_t

Instance variables

var bytes
compiled_binpat_t_bytes_get(self) -> bytevec_t *
var encidx
compiled_binpat_t_encidx_get(self) -> int
var mask
compiled_binpat_t_mask_get(self) -> bytevec_t *
var strlits
compiled_binpat_t_strlits_get(self) -> rangevec_t

Methods

def all_bytes_defined(self, *args) ‑> bool
all_bytes_defined(self) -> bool
def qclear(self, *args) ‑> void
qclear(self)
class compiled_binpat_vec_t (*args)
Proxy of C++ qvector< compiled_binpat_t > class.
__init__(self) -> compiled_binpat_vec_t
x: qvector< compiled_binpat_t > const &

Methods

def add_unique(self, *args) ‑> bool
add_unique(self, x) -> bool
x: compiled_binpat_t const &
def at(self, *args) ‑> compiled_binpat_t const &
at(self, _idx) -> compiled_binpat_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< compiled_binpat_t >::const_iterator
begin(self) -> compiled_binpat_t
begin(self) -> compiled_binpat_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< compiled_binpat_t >::const_iterator
end(self) -> compiled_binpat_t
end(self) -> compiled_binpat_t
def erase(self, *args) ‑> qvector< compiled_binpat_t >::iterator
erase(self, it) -> compiled_binpat_t
it: qvector< compiled_binpat_t >::iterator
erase(self, first, last) -> compiled_binpat_t
first: qvector< compiled_binpat_t >::iterator last: qvector< compiled_binpat_t >::iterator
def extract(self, *args) ‑> compiled_binpat_t *
extract(self) -> compiled_binpat_t
def find(self, *args) ‑> qvector< compiled_binpat_t >::const_iterator
find(self, x) -> compiled_binpat_t
x: compiled_binpat_t const &
find(self, x) -> compiled_binpat_t
x: compiled_binpat_t const &
def front(self)
def grow(self, *args) ‑> void
grow(self, x=compiled_binpat_t())
x: compiled_binpat_t const &
def has(self, *args) ‑> bool
has(self, x) -> bool
x: compiled_binpat_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: compiled_binpat_t * len: size_t
def insert(self, *args) ‑> qvector< compiled_binpat_t >::iterator
insert(self, it, x) -> compiled_binpat_t
it: qvector< compiled_binpat_t >::iterator x: compiled_binpat_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> compiled_binpat_t &
push_back(self, x)
x: compiled_binpat_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: compiled_binpat_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< compiled_binpat_t > &
def truncate(self, *args) ‑> void
truncate(self)
class data_format_t (*args)
Proxy of C++ data_format_t class.

Instance variables

var hotkey
data_format_t_hotkey_get(self) -> char const *
var id : int
__get_id(self) -> int
var menu_name
data_format_t_menu_name_get(self) -> char const *
var name
data_format_t_name_get(self) -> char const *
var props
data_format_t_props_get(self) -> int
var text_width
data_format_t_text_width_get(self) -> int32
var value_size
data_format_t_value_size_get(self) -> asize_t

Methods

def is_present_in_menus(self, *args) ‑> bool
Should this format be shown in UI menus
class data_type_t (*args)
Proxy of C++ data_type_t class.

Instance variables

var asm_keyword
data_type_t_asm_keyword_get(self) -> char const *
var hotkey
data_type_t_hotkey_get(self) -> char const *
var id : int
__get_id(self) -> int
var menu_name
data_type_t_menu_name_get(self) -> char const *
var name
data_type_t_name_get(self) -> char const *
var props
data_type_t_props_get(self) -> int
var value_size
data_type_t_value_size_get(self) -> asize_t

Methods

def is_present_in_menus(self, *args) ‑> bool
Should this type be shown in UI menus
class hidden_range_t (*args)
Proxy of C++ hidden_range_t class.
__init__(self) -> hidden_range_t

Ancestors

Instance variables

var color
hidden_range_t_color_get(self) -> bgcolor_t
var description
hidden_range_t_description_get(self) -> char *
var footer
hidden_range_t_footer_get(self) -> char *
var header
hidden_range_t_header_get(self) -> char *
var visible
hidden_range_t_visible_get(self) -> bool

Inherited members