|
| "error_t" | enable_flags ("ea_t" start_ea, "ea_t" end_ea, "storage_type_t" stt) |
| | enable_flags(start_ea, end_ea, stt) -> error_t Allocate flags for address range.
|
| |
| "error_t" | disable_flags ("ea_t" start_ea, "ea_t" end_ea) |
| | disable_flags(start_ea, end_ea) -> error_t Deallocate flags for address range.
|
| |
| "error_t" | change_storage_type ("ea_t" start_ea, "ea_t" end_ea, "storage_type_t" stt) |
| | change_storage_type(start_ea, end_ea, stt) -> error_t Change flag storage type for address range.
|
| |
| "ea_t" | next_addr ("ea_t" ea) |
| | next_addr(ea) -> ea_t Get next address in the program (i.e.
|
| |
| "ea_t" | prev_addr ("ea_t" ea) |
| | prev_addr(ea) -> ea_t Get previous address in the program.
|
| |
| "ea_t" | next_chunk ("ea_t" ea) |
| | next_chunk(ea) -> ea_t Get the first address of next contiguous chunk in the program.
|
| |
| "ea_t" | prev_chunk ("ea_t" ea) |
| | prev_chunk(ea) -> ea_t Get the last address of previous contiguous chunk in the program.
|
| |
| "ea_t" | chunk_start ("ea_t" ea) |
| | chunk_start(ea) -> ea_t Get start of the contiguous address block containing 'ea'.
|
| |
| "asize_t" | chunk_size ("ea_t" ea) |
| | chunk_size(ea) -> asize_t Get size of the contiguous address block containing 'ea'.
|
| |
| "ea_t" | find_free_chunk ("ea_t" start, "asize_t" size, "asize_t" alignment) |
| | find_free_chunk(start, size, alignment) -> ea_t Search for a hole in the addressing space of the program.
|
| |
| "ea_t" | next_that ("ea_t" ea, "ea_t" maxea, "testf_t *" testf) |
| | next_that(ea, maxea, testf) -> ea_t Find next address with a flag satisfying the function 'testf'.
|
| |
| "ea_t" | next_unknown ("ea_t" ea, "ea_t" maxea) |
| | next_unknown(ea, maxea) -> ea_t Similar to next_that(), but will find the next address that is unexplored.
|
| |
| "ea_t" | prev_that ("ea_t" ea, "ea_t" minea, "testf_t *" testf) |
| | prev_that(ea, minea, testf) -> ea_t Find previous address with a flag satisfying the function 'testf'.
|
| |
| "ea_t" | prev_unknown ("ea_t" ea, "ea_t" minea) |
| | prev_unknown(ea, minea) -> ea_t Similar to prev_that(), but will find the previous address that is unexplored.
|
| |
| "ea_t" | prev_head ("ea_t" ea, "ea_t" minea) |
| | prev_head(ea, minea) -> ea_t Get start of previous defined item.
|
| |
| "ea_t" | next_head ("ea_t" ea, "ea_t" maxea) |
| | next_head(ea, maxea) -> ea_t Get start of next defined item.
|
| |
| "ea_t" | prev_not_tail ("ea_t" ea) |
| | prev_not_tail(ea) -> ea_t Get address of previous non-tail byte.
|
| |
| "ea_t" | next_not_tail ("ea_t" ea) |
| | next_not_tail(ea) -> ea_t Get address of next non-tail byte.
|
| |
| "ea_t" | prev_visea ("ea_t" ea) |
| | prev_visea(ea) -> ea_t Get previous visible address.
|
| |
| "ea_t" | next_visea ("ea_t" ea) |
| | next_visea(ea) -> ea_t Get next visible address.
|
| |
| "ea_t" | get_item_head ("ea_t" ea) |
| | get_item_head(ea) -> ea_t Get the start address of the item at 'ea'.
|
| |
| "ea_t" | get_item_end ("ea_t" ea) |
| | get_item_end(ea) -> ea_t Get the end address of the item at 'ea'.
|
| |
| "ea_t" | calc_max_item_end ("ea_t" ea, "int" how=15) |
| | calc_max_item_end(ea, how=15) -> ea_t Calculate maximal reasonable end address of a new item.
|
| |
| "asize_t" | get_item_size ("ea_t" ea) |
| | get_item_size(ea) -> asize_t Get size of item (instruction/data) in bytes.
|
| |
| "bool" | is_mapped ("ea_t" ea) |
| | is_mapped(ea) -> bool Is the specified address 'ea' present in the program?
|
| |
| "flags64_t" | get_flags_ex ("ea_t" ea, "int" how) |
| | get_flags_ex(ea, how) -> flags64_t Get flags for the specified address, extended form.
|
| |
| "flags64_t" | get_flags ("ea_t" ea) |
| | get_flags(ea) -> flags64_t get flags with FF_IVL & MS_VAL.
|
| |
| "flags64_t" | get_full_flags ("ea_t" ea) |
| | get_full_flags(ea) -> flags64_t Get flags value for address 'ea'.
|
| |
| "flags64_t" | get_item_flag ("ea_t" _from, "int" n, "ea_t" ea, "bool" appzero) |
| | get_item_flag(_from, n, ea, appzero) -> flags64_t Get flag of the item at 'ea' even if it is a tail byte of some array or structure.
|
| |
| "bool" | get_item_refinfo ("refinfo_t" ri, "ea_t" ea, "int" n) |
| | get_item_refinfo(ri, ea, n) -> bool Get refinfo of the item at 'ea'.
|
| |
| "bool" | has_value ("flags64_t" F) |
| | has_value(F) -> bool Do flags contain byte value?
|
| |
| "void" | del_value ("ea_t" ea) |
| | del_value(ea) Delete byte value from flags.
|
| |
| "bool" | is_loaded ("ea_t" ea) |
| | is_loaded(ea) -> bool Does the specified address have a byte value (is initialized?)
|
| |
| "int" | nbits ("ea_t" ea) |
| | nbits(ea) -> int Get number of bits in a byte at the given address.
|
| |
| "int" | bytesize ("ea_t" ea) |
| | bytesize(ea) -> int Get number of bytes required to store a byte at the given address.
|
| |
| "uchar" | get_byte ("ea_t" ea) |
| | get_byte(ea) -> uchar Get one byte (8-bit) of the program at 'ea'.
|
| |
| "uchar" | get_db_byte ("ea_t" ea) |
| | get_db_byte(ea) -> uchar Get one byte (8-bit) of the program at 'ea' from the database.
|
| |
| "ushort" | get_word ("ea_t" ea) |
| | get_word(ea) -> ushort Get one word (16-bit) of the program at 'ea'.
|
| |
| "uint32" | get_dword ("ea_t" ea) |
| | get_dword(ea) -> uint32 Get one dword (32-bit) of the program at 'ea'.
|
| |
| "uint64" | get_qword ("ea_t" ea) |
| | get_qword(ea) -> uint64 Get one qword (64-bit) of the program at 'ea'.
|
| |
| "uint64" | get_wide_byte ("ea_t" ea) |
| | get_wide_byte(ea) -> uint64 Get one wide byte of the program at 'ea'.
|
| |
| "uint64" | get_wide_word ("ea_t" ea) |
| | get_wide_word(ea) -> uint64 Get one wide word (2 'byte') of the program at 'ea'.
|
| |
| "uint64" | get_wide_dword ("ea_t" ea) |
| | get_wide_dword(ea) -> uint64 Get two wide words (4 'bytes') of the program at 'ea'.
|
| |
| "uchar *" | get_octet ("octet_generator_t" ogen) |
| | get_octet(ogen) -> bool
|
| |
| "uint32" | get_16bit ("ea_t" ea) |
| | get_16bit(ea) -> uint32 Get 16bits of the program at 'ea'.
|
| |
| "uint32" | get_32bit ("ea_t" ea) |
| | get_32bit(ea) -> uint32 Get not more than 32bits of the program at 'ea'.
|
| |
| "uint64" | get_64bit ("ea_t" ea) |
| | get_64bit(ea) -> uint64 Get not more than 64bits of the program at 'ea'.
|
| |
| "bool" | get_data_value ("uval_t *" v, "ea_t" ea, "asize_t" size) |
| | get_data_value(v, ea, size) -> bool Get the value at of the item at 'ea'.
|
| |
| "uint64" | get_original_byte ("ea_t" ea) |
| | get_original_byte(ea) -> uint64 Get original byte value (that was before patching).
|
| |
| "uint64" | get_original_word ("ea_t" ea) |
| | get_original_word(ea) -> uint64 Get original word value (that was before patching).
|
| |
| "uint64" | get_original_dword ("ea_t" ea) |
| | get_original_dword(ea) -> uint64 Get original dword (that was before patching) This function works for wide byte processors too.
|
| |
| "uint64" | get_original_qword ("ea_t" ea) |
| | get_original_qword(ea) -> uint64 Get original qword value (that was before patching) This function DOESN'T work for wide byte processors too.
|
| |
| "bool" | put_byte ("ea_t" ea, "uint64" x) |
| | put_byte(ea, x) -> bool Set value of one byte of the program.
|
| |
| "void" | put_word ("ea_t" ea, "uint64" x) |
| | put_word(ea, x) Set value of one word of the program.
|
| |
| "void" | put_dword ("ea_t" ea, "uint64" x) |
| | put_dword(ea, x) Set value of one dword of the program.
|
| |
| "void" | put_qword ("ea_t" ea, "uint64" x) |
| | put_qword(ea, x) Set value of one qword (8 bytes) of the program.
|
| |
| "bool" | patch_byte ("ea_t" ea, "uint64" x) |
| | patch_byte(ea, x) -> bool Patch a byte of the program.
|
| |
| "bool" | patch_word ("ea_t" ea, "uint64" x) |
| | patch_word(ea, x) -> bool Patch a word of the program.
|
| |
| "bool" | patch_dword ("ea_t" ea, "uint64" x) |
| | patch_dword(ea, x) -> bool Patch a dword of the program.
|
| |
| "bool" | patch_qword ("ea_t" ea, "uint64" x) |
| | patch_qword(ea, x) -> bool Patch a qword of the program.
|
| |
| "bool" | revert_byte ("ea_t" ea) |
| | revert_byte(ea) -> bool Revert patched byte
|
| |
| "void" | add_byte ("ea_t" ea, "uint32" value) |
| | add_byte(ea, value) Add a value to one byte of the program.
|
| |
| "void" | add_word ("ea_t" ea, "uint64" value) |
| | add_word(ea, value) Add a value to one word of the program.
|
| |
| "void" | add_dword ("ea_t" ea, "uint64" value) |
| | add_dword(ea, value) Add a value to one dword of the program.
|
| |
| "void" | add_qword ("ea_t" ea, "uint64" value) |
| | add_qword(ea, value) Add a value to one qword of the program.
|
| |
| "bool" | get_zero_ranges ("rangeset_t" zranges, "range_t" range) |
| | get_zero_ranges(zranges, range) -> bool Return set of ranges with zero initialized bytes.
|
| |
| "void" | put_bytes ("ea_t" ea, "void const *" buf) |
| | put_bytes(ea, buf) Modify the specified number of bytes of the program.
|
| |
| "void" | patch_bytes ("ea_t" ea, "void const *" buf) |
| | patch_bytes(ea, buf) Patch the specified number of bytes of the program.
|
| |
| "bool" | is_code ("flags64_t" F) |
| | is_code(F) -> bool Does flag denote start of an instruction?
|
| |
| "bool" | f_is_code ("flags64_t" F, "void *" arg2) |
| | f_is_code(F, arg2) -> bool Does flag denote start of an instruction?
|
| |
| "bool" | is_data ("flags64_t" F) |
| | is_data(F) -> bool Does flag denote start of data?
|
| |
| "bool" | f_is_data ("flags64_t" F, "void *" arg2) |
| | f_is_data(F, arg2) -> bool Does flag denote start of data?
|
| |
| "bool" | is_tail ("flags64_t" F) |
| | is_tail(F) -> bool Does flag denote tail byte?
|
| |
| "bool" | f_is_tail ("flags64_t" F, "void *" arg2) |
| | f_is_tail(F, arg2) -> bool Does flag denote tail byte?
|
| |
| "bool" | is_not_tail ("flags64_t" F) |
| | is_not_tail(F) -> bool Does flag denote tail byte?
|
| |
| "bool" | f_is_not_tail ("flags64_t" F, "void *" arg2) |
| | f_is_not_tail(F, arg2) -> bool Does flag denote tail byte?
|
| |
| "bool" | is_unknown ("flags64_t" F) |
| | is_unknown(F) -> bool Does flag denote unexplored byte?
|
| |
| "bool" | is_head ("flags64_t" F) |
| | is_head(F) -> bool Does flag denote start of instruction OR data?
|
| |
| "bool" | f_is_head ("flags64_t" F, "void *" arg2) |
| | f_is_head(F, arg2) -> bool Does flag denote start of instruction OR data?
|
| |
| "bool" | del_items ("ea_t" ea, "int" flags=0, "asize_t" nbytes=1, "may_destroy_cb_t *" may_destroy=None) |
| | del_items(ea, flags=0, nbytes=1, may_destroy=None) -> bool Convert item (instruction/data) to unexplored bytes.
|
| |
| "bool" | is_manual_insn ("ea_t" ea) |
| | is_manual_insn(ea) -> bool Is the instruction overridden?
|
| |
| "qstring *" | get_manual_insn ("ea_t" ea) |
| | get_manual_insn(ea) -> str Retrieve the user-specified string for the manual instruction.
|
| |
| "void" | set_manual_insn ("ea_t" ea, "char const *" manual_insn) |
| | set_manual_insn(ea, manual_insn) Set manual instruction string.
|
| |
| "bool" | is_flow ("flags64_t" F) |
| | is_flow(F) -> bool Does the previous instruction exist and pass execution flow to the current byte?
|
| |
| "bool" | has_extra_cmts ("flags64_t" F) |
| | has_extra_cmts(F) -> bool Does the current byte have additional anterior or posterior lines?
|
| |
| "bool" | f_has_extra_cmts ("flags64_t" f, "void *" arg2) |
| | f_has_extra_cmts(f, arg2) -> bool
|
| |
| "bool" | has_cmt ("flags64_t" F) |
| | has_cmt(F) -> bool Does the current byte have an indented comment?
|
| |
| "bool" | f_has_cmt ("flags64_t" f, "void *" arg2) |
| | f_has_cmt(f, arg2) -> bool
|
| |
| "bool" | has_xref ("flags64_t" F) |
| | has_xref(F) -> bool Does the current byte have cross-references to it?
|
| |
| "bool" | f_has_xref ("flags64_t" f, "void *" arg2) |
| | f_has_xref(f, arg2) -> bool Does the current byte have cross-references to it?
|
| |
| "bool" | has_name ("flags64_t" F) |
| | has_name(F) -> bool Does the current byte have non-trivial (non-dummy) name?
|
| |
| "bool" | f_has_name ("flags64_t" f, "void *" arg2) |
| | f_has_name(f, arg2) -> bool Does the current byte have non-trivial (non-dummy) name?
|
| |
| "bool" | has_dummy_name ("flags64_t" F) |
| | has_dummy_name(F) -> bool Does the current byte have dummy (auto-generated, with special prefix) name?
|
| |
| "bool" | f_has_dummy_name ("flags64_t" f, "void *" arg2) |
| | f_has_dummy_name(f, arg2) -> bool Does the current byte have dummy (auto-generated, with special prefix) name?
|
| |
| "bool" | has_auto_name ("flags64_t" F) |
| | has_auto_name(F) -> bool Does the current byte have auto-generated (no special prefix) name?
|
| |
| "bool" | has_any_name ("flags64_t" F) |
| | has_any_name(F) -> bool Does the current byte have any name?
|
| |
| "bool" | has_user_name ("flags64_t" F) |
| | has_user_name(F) -> bool Does the current byte have user-specified name?
|
| |
| "bool" | f_has_user_name ("flags64_t" F, "void *" arg2) |
| | f_has_user_name(F, arg2) -> bool Does the current byte have user-specified name?
|
| |
| "bool" | is_invsign ("ea_t" ea, "flags64_t" F, "int" n) |
| | is_invsign(ea, F, n) -> bool Should sign of n-th operand inverted during output?.
|
| |
| "bool" | toggle_sign ("ea_t" ea, "int" n) |
| | toggle_sign(ea, n) -> bool Toggle sign of n-th operand.
|
| |
| "bool" | is_bnot ("ea_t" ea, "flags64_t" F, "int" n) |
| | is_bnot(ea, F, n) -> bool Should we negate the operand?.
|
| |
| "bool" | toggle_bnot ("ea_t" ea, "int" n) |
| | toggle_bnot(ea, n) -> bool Toggle binary negation of operand.
|
| |
| "bool" | is_lzero ("ea_t" ea, "int" n) |
| | is_lzero(ea, n) -> bool Display leading zeroes? Display leading zeroes in operands.
|
| |
| "bool" | set_lzero ("ea_t" ea, "int" n) |
| | set_lzero(ea, n) -> bool Set toggle lzero bit.
|
| |
| "bool" | clr_lzero ("ea_t" ea, "int" n) |
| | clr_lzero(ea, n) -> bool Clear toggle lzero bit.
|
| |
| "bool" | toggle_lzero ("ea_t" ea, "int" n) |
| | toggle_lzero(ea, n) -> bool Toggle lzero bit.
|
| |
| "bool" | leading_zero_important ("ea_t" ea, "int" n) |
| | leading_zero_important(ea, n) -> bool Check if leading zeroes are important.
|
| |
| "int" | get_operand_type_shift ("uint32" n) |
| | get_operand_type_shift(n) -> int Get the shift in flags64_t for the nibble representing operand n's type
|
| |
| "flags64_t" | get_operand_flag ("uint8" typebits, "int" n) |
| | get_operand_flag(typebits, n) -> flags64_t Place operand n's type flag in the right nibble of a 64-bit flags set.
|
| |
| "bool" | is_flag_for_operand ("flags64_t" F, "uint8" typebits, "int" n) |
| | is_flag_for_operand(F, typebits, n) -> bool Check that the 64-bit flags set has the expected type for operand n.
|
| |
| "bool" | is_defarg0 ("flags64_t" F) |
| | is_defarg0(F) -> bool Is the first operand defined? Initially operand has no defined representation.
|
| |
| "bool" | is_defarg1 ("flags64_t" F) |
| | is_defarg1(F) -> bool Is the second operand defined? Initially operand has no defined representation.
|
| |
| "bool" | is_off0 ("flags64_t" F) |
| | is_off0(F) -> bool Is the first operand offset? (example: push offset xxx)
|
| |
| "bool" | is_off1 ("flags64_t" F) |
| | is_off1(F) -> bool Is the second operand offset? (example: mov ax, offset xxx)
|
| |
| "bool" | is_char0 ("flags64_t" F) |
| | is_char0(F) -> bool Is the first operand character constant? (example: push 'a')
|
| |
| "bool" | is_char1 ("flags64_t" F) |
| | is_char1(F) -> bool Is the second operand character constant? (example: mov al, 'a')
|
| |
| "bool" | is_seg0 ("flags64_t" F) |
| | is_seg0(F) -> bool Is the first operand segment selector? (example: push seg seg001)
|
| |
| "bool" | is_seg1 ("flags64_t" F) |
| | is_seg1(F) -> bool Is the second operand segment selector? (example: mov dx, seg dseg)
|
| |
| "bool" | is_enum0 ("flags64_t" F) |
| | is_enum0(F) -> bool Is the first operand a symbolic constant (enum member)?
|
| |
| "bool" | is_enum1 ("flags64_t" F) |
| | is_enum1(F) -> bool Is the second operand a symbolic constant (enum member)?
|
| |
| "bool" | is_stroff0 ("flags64_t" F) |
| | is_stroff0(F) -> bool Is the first operand an offset within a struct?
|
| |
| "bool" | is_stroff1 ("flags64_t" F) |
| | is_stroff1(F) -> bool Is the second operand an offset within a struct?
|
| |
| "bool" | is_stkvar0 ("flags64_t" F) |
| | is_stkvar0(F) -> bool Is the first operand a stack variable?
|
| |
| "bool" | is_stkvar1 ("flags64_t" F) |
| | is_stkvar1(F) -> bool Is the second operand a stack variable?
|
| |
| "bool" | is_float0 ("flags64_t" F) |
| | is_float0(F) -> bool Is the first operand a floating point number?
|
| |
| "bool" | is_float1 ("flags64_t" F) |
| | is_float1(F) -> bool Is the second operand a floating point number?
|
| |
| "bool" | is_custfmt0 ("flags64_t" F) |
| | is_custfmt0(F) -> bool Does the first operand use a custom data representation?
|
| |
| "bool" | is_custfmt1 ("flags64_t" F) |
| | is_custfmt1(F) -> bool Does the second operand use a custom data representation?
|
| |
| "bool" | is_numop0 ("flags64_t" F) |
| | is_numop0(F) -> bool Is the first operand a number (i.e.
|
| |
| "bool" | is_numop1 ("flags64_t" F) |
| | is_numop1(F) -> bool Is the second operand a number (i.e.
|
| |
| "flags64_t" | get_optype_flags0 ("flags64_t" F) |
| | get_optype_flags0(F) -> flags64_t Get flags for first operand.
|
| |
| "flags64_t" | get_optype_flags1 ("flags64_t" F) |
| | get_optype_flags1(F) -> flags64_t Get flags for second operand.
|
| |
| "bool" | is_defarg ("flags64_t" F, "int" n) |
| | is_defarg(F, n) -> bool is defined?
|
| |
| "bool" | is_off ("flags64_t" F, "int" n) |
| | is_off(F, n) -> bool is offset?
|
| |
| "bool" | is_char ("flags64_t" F, "int" n) |
| | is_char(F, n) -> bool is character constant?
|
| |
| "bool" | is_seg ("flags64_t" F, "int" n) |
| | is_seg(F, n) -> bool is segment?
|
| |
| "bool" | is_enum ("flags64_t" F, "int" n) |
| | is_enum(F, n) -> bool is enum?
|
| |
| "bool" | is_manual ("flags64_t" F, "int" n) |
| | is_manual(F, n) -> bool is forced operand? (use is_forced_operand())
|
| |
| "bool" | is_stroff ("flags64_t" F, "int" n) |
| | is_stroff(F, n) -> bool is struct offset?
|
| |
| "bool" | is_stkvar ("flags64_t" F, "int" n) |
| | is_stkvar(F, n) -> bool is stack variable?
|
| |
| "bool" | is_fltnum ("flags64_t" F, "int" n) |
| | is_fltnum(F, n) -> bool is floating point number?
|
| |
| "bool" | is_custfmt ("flags64_t" F, "int" n) |
| | is_custfmt(F, n) -> bool is custom data format?
|
| |
| "bool" | is_numop ("flags64_t" F, "int" n) |
| | is_numop(F, n) -> bool is number (bin, oct, dec, hex)?
|
| |
| "bool" | is_suspop ("ea_t" ea, "flags64_t" F, "int" n) |
| | is_suspop(ea, F, n) -> bool is suspicious operand?
|
| |
| "bool" | op_adds_xrefs ("flags64_t" F, "int" n) |
| | op_adds_xrefs(F, n) -> bool Should processor module create xrefs from the operand?.
|
| |
| "bool" | set_op_type ("ea_t" ea, "flags64_t" type, "int" n) |
| | set_op_type(ea, type, n) -> bool (internal function) change representation of operand(s).
|
| |
| "bool" | op_seg ("ea_t" ea, "int" n) |
| | op_seg(ea, n) -> bool Set operand representation to be 'segment'.
|
| |
| "bool" | op_enum ("ea_t" ea, "int" n, "tid_t" id, "uchar" serial=0) |
| | op_enum(ea, n, id, serial=0) -> bool Set operand representation to be enum type If applied to unexplored bytes, converts them to 16/32bit word data
|
| |
| "uchar *" | get_enum_id ("ea_t" ea, "int" n) |
| | get_enum_id(ea, n) -> tid_t Get enum id of 'enum' operand.
|
| |
| "bool" | op_based_stroff ("insn_t const &" insn, "int" n, "adiff_t" opval, "ea_t" base) |
| | op_based_stroff(insn, n, opval, base) -> bool Set operand representation to be 'struct offset' if the operand likely points to a structure member.
|
| |
| "bool" | op_stkvar ("ea_t" ea, "int" n) |
| | op_stkvar(ea, n) -> bool Set operand representation to be 'stack variable'.
|
| |
| "bool" | set_forced_operand ("ea_t" ea, "int" n, "char const *" op) |
| | set_forced_operand(ea, n, op) -> bool Set forced operand.
|
| |
| "qstring *" | get_forced_operand ("ea_t" ea, "int" n) |
| | get_forced_operand(ea, n) -> str Get forced operand.
|
| |
| "bool" | is_forced_operand ("ea_t" ea, "int" n) |
| | is_forced_operand(ea, n) -> bool Is operand manually defined?.
|
| |
| "flags64_t" | combine_flags ("flags64_t" F) |
| | combine_flags(F) -> flags64_t
|
| |
| "flags64_t" | char_flag () |
| | char_flag() -> flags64_t see FF_opbits
|
| |
| "flags64_t" | off_flag () |
| | off_flag() -> flags64_t see FF_opbits
|
| |
| "flags64_t" | enum_flag () |
| | enum_flag() -> flags64_t see FF_opbits
|
| |
| "flags64_t" | stroff_flag () |
| | stroff_flag() -> flags64_t see FF_opbits
|
| |
| "flags64_t" | stkvar_flag () |
| | stkvar_flag() -> flags64_t see FF_opbits
|
| |
| "flags64_t" | flt_flag () |
| | flt_flag() -> flags64_t see FF_opbits
|
| |
| "flags64_t" | custfmt_flag () |
| | custfmt_flag() -> flags64_t see FF_opbits
|
| |
| "flags64_t" | seg_flag () |
| | seg_flag() -> flags64_t see FF_opbits
|
| |
| "flags64_t" | num_flag () |
| | num_flag() -> flags64_t Get number of default base (bin, oct, dec, hex)
|
| |
| "flags64_t" | hex_flag () |
| | hex_flag() -> flags64_t Get number flag of the base, regardless of current processor - better to use num_flag()
|
| |
| "flags64_t" | dec_flag () |
| | dec_flag() -> flags64_t Get number flag of the base, regardless of current processor - better to use num_flag()
|
| |
| "flags64_t" | oct_flag () |
| | oct_flag() -> flags64_t Get number flag of the base, regardless of current processor - better to use num_flag()
|
| |
| "flags64_t" | bin_flag () |
| | bin_flag() -> flags64_t Get number flag of the base, regardless of current processor - better to use num_flag()
|
| |
| "bool" | op_chr ("ea_t" ea, "int" n) |
| | op_chr(ea, n) -> bool set op type to char_flag()
|
| |
| "bool" | op_num ("ea_t" ea, "int" n) |
| | op_num(ea, n) -> bool set op type to num_flag()
|
| |
| "bool" | op_hex ("ea_t" ea, "int" n) |
| | op_hex(ea, n) -> bool set op type to hex_flag()
|
| |
| "bool" | op_dec ("ea_t" ea, "int" n) |
| | op_dec(ea, n) -> bool set op type to dec_flag()
|
| |
| "bool" | op_oct ("ea_t" ea, "int" n) |
| | op_oct(ea, n) -> bool set op type to oct_flag()
|
| |
| "bool" | op_bin ("ea_t" ea, "int" n) |
| | op_bin(ea, n) -> bool set op type to bin_flag()
|
| |
| "bool" | op_flt ("ea_t" ea, "int" n) |
| | op_flt(ea, n) -> bool set op type to flt_flag()
|
| |
| "bool" | op_custfmt ("ea_t" ea, "int" n, "int" fid) |
| | op_custfmt(ea, n, fid) -> bool Set custom data format for operand (fid-custom data format id)
|
| |
| "bool" | clr_op_type ("ea_t" ea, "int" n) |
| | clr_op_type(ea, n) -> bool Remove operand representation information.
|
| |
| "int" | get_default_radix () |
| | get_default_radix() -> int Get default base of number for the current processor.
|
| |
| "int" | get_radix ("flags64_t" F, "int" n) |
| | get_radix(F, n) -> int Get radix of the operand, in: flags.
|
| |
| "flags64_t" | code_flag () |
| | code_flag() -> flags64_t FF_CODE
|
| |
| "flags64_t" | byte_flag () |
| | byte_flag() -> flags64_t Get a flags64_t representing a byte.
|
| |
| "flags64_t" | word_flag () |
| | word_flag() -> flags64_t Get a flags64_t representing a word.
|
| |
| "flags64_t" | dword_flag () |
| | dword_flag() -> flags64_t Get a flags64_t representing a double word.
|
| |
| "flags64_t" | qword_flag () |
| | qword_flag() -> flags64_t Get a flags64_t representing a quad word.
|
| |
| "flags64_t" | oword_flag () |
| | oword_flag() -> flags64_t Get a flags64_t representing a octaword.
|
| |
| "flags64_t" | yword_flag () |
| | yword_flag() -> flags64_t Get a flags64_t representing a ymm word.
|
| |
| "flags64_t" | zword_flag () |
| | zword_flag() -> flags64_t Get a flags64_t representing a zmm word.
|
| |
| "flags64_t" | tbyte_flag () |
| | tbyte_flag() -> flags64_t Get a flags64_t representing a tbyte.
|
| |
| "flags64_t" | strlit_flag () |
| | strlit_flag() -> flags64_t Get a flags64_t representing a string literal.
|
| |
| "flags64_t" | stru_flag () |
| | stru_flag() -> flags64_t Get a flags64_t representing a struct.
|
| |
| "flags64_t" | cust_flag () |
| | cust_flag() -> flags64_t Get a flags64_t representing custom type data.
|
| |
| "flags64_t" | align_flag () |
| | align_flag() -> flags64_t Get a flags64_t representing an alignment directive.
|
| |
| "flags64_t" | float_flag () |
| | float_flag() -> flags64_t Get a flags64_t representing a float.
|
| |
| "flags64_t" | double_flag () |
| | double_flag() -> flags64_t Get a flags64_t representing a double.
|
| |
| "flags64_t" | packreal_flag () |
| | packreal_flag() -> flags64_t Get a flags64_t representing a packed decimal real.
|
| |
| "bool" | is_byte ("flags64_t" F) |
| | is_byte(F) -> bool FF_BYTE
|
| |
| "bool" | is_word ("flags64_t" F) |
| | is_word(F) -> bool FF_WORD
|
| |
| "bool" | is_dword ("flags64_t" F) |
| | is_dword(F) -> bool FF_DWORD
|
| |
| "bool" | is_qword ("flags64_t" F) |
| | is_qword(F) -> bool FF_QWORD
|
| |
| "bool" | is_oword ("flags64_t" F) |
| | is_oword(F) -> bool FF_OWORD
|
| |
| "bool" | is_yword ("flags64_t" F) |
| | is_yword(F) -> bool FF_YWORD
|
| |
| "bool" | is_zword ("flags64_t" F) |
| | is_zword(F) -> bool FF_ZWORD
|
| |
| "bool" | is_tbyte ("flags64_t" F) |
| | is_tbyte(F) -> bool FF_TBYTE
|
| |
| "bool" | is_float ("flags64_t" F) |
| | is_float(F) -> bool FF_FLOAT
|
| |
| "bool" | is_double ("flags64_t" F) |
| | is_double(F) -> bool FF_DOUBLE
|
| |
| "bool" | is_pack_real ("flags64_t" F) |
| | is_pack_real(F) -> bool FF_PACKREAL
|
| |
| "bool" | is_strlit ("flags64_t" F) |
| | is_strlit(F) -> bool FF_STRLIT
|
| |
| "bool" | is_struct ("flags64_t" F) |
| | is_struct(F) -> bool FF_STRUCT
|
| |
| "bool" | is_align ("flags64_t" F) |
| | is_align(F) -> bool FF_ALIGN
|
| |
| "bool" | is_custom ("flags64_t" F) |
| | is_custom(F) -> bool FF_CUSTOM
|
| |
| "bool" | f_is_byte ("flags64_t" F, "void *" arg2) |
| | f_is_byte(F, arg2) -> bool See is_byte()
|
| |
| "bool" | f_is_word ("flags64_t" F, "void *" arg2) |
| | f_is_word(F, arg2) -> bool See is_word()
|
| |
| "bool" | f_is_dword ("flags64_t" F, "void *" arg2) |
| | f_is_dword(F, arg2) -> bool See is_dword()
|
| |
| "bool" | f_is_qword ("flags64_t" F, "void *" arg2) |
| | f_is_qword(F, arg2) -> bool See is_qword()
|
| |
| "bool" | f_is_oword ("flags64_t" F, "void *" arg2) |
| | f_is_oword(F, arg2) -> bool See is_oword()
|
| |
| "bool" | f_is_yword ("flags64_t" F, "void *" arg2) |
| | f_is_yword(F, arg2) -> bool See is_yword()
|
| |
| "bool" | f_is_tbyte ("flags64_t" F, "void *" arg2) |
| | f_is_tbyte(F, arg2) -> bool See is_tbyte()
|
| |
| "bool" | f_is_float ("flags64_t" F, "void *" arg2) |
| | f_is_float(F, arg2) -> bool See is_float()
|
| |
| "bool" | f_is_double ("flags64_t" F, "void *" arg2) |
| | f_is_double(F, arg2) -> bool See is_double()
|
| |
| "bool" | f_is_pack_real ("flags64_t" F, "void *" arg2) |
| | f_is_pack_real(F, arg2) -> bool See is_pack_real()
|
| |
| "bool" | f_is_strlit ("flags64_t" F, "void *" arg2) |
| | f_is_strlit(F, arg2) -> bool See is_strlit()
|
| |
| "bool" | f_is_struct ("flags64_t" F, "void *" arg2) |
| | f_is_struct(F, arg2) -> bool See is_struct()
|
| |
| "bool" | f_is_align ("flags64_t" F, "void *" arg2) |
| | f_is_align(F, arg2) -> bool See is_align()
|
| |
| "bool" | f_is_custom ("flags64_t" F, "void *" arg2) |
| | f_is_custom(F, arg2) -> bool See is_custom()
|
| |
| "bool" | is_same_data_type ("flags64_t" F1, "flags64_t" F2) |
| | is_same_data_type(F1, F2) -> bool Do the given flags specify the same data type?
|
| |
| "flags64_t" | get_flags_by_size ("size_t" size) |
| | get_flags_by_size(size) -> flags64_t Get flags from size (in bytes).
|
| |
| "bool" | create_data ("ea_t" ea, "flags64_t" dataflag, "asize_t" size, "tid_t" tid) |
| | create_data(ea, dataflag, size, tid) -> bool Convert to data (byte, word, dword, etc).
|
| |
| "flags64_t" | calc_dflags ("flags64_t" f, "bool" force) |
| | calc_dflags(f, force) -> flags64_t
|
| |
| "bool" | create_byte ("ea_t" ea, "asize_t" length, "bool" force=False) |
| | create_byte(ea, length, force=False) -> bool Convert to byte.
|
| |
| "bool" | create_word ("ea_t" ea, "asize_t" length, "bool" force=False) |
| | create_word(ea, length, force=False) -> bool Convert to word.
|
| |
| "bool" | create_dword ("ea_t" ea, "asize_t" length, "bool" force=False) |
| | create_dword(ea, length, force=False) -> bool Convert to dword.
|
| |
| "bool" | create_qword ("ea_t" ea, "asize_t" length, "bool" force=False) |
| | create_qword(ea, length, force=False) -> bool Convert to quadword.
|
| |
| "bool" | create_oword ("ea_t" ea, "asize_t" length, "bool" force=False) |
| | create_oword(ea, length, force=False) -> bool Convert to octaword/xmm word.
|
| |
| "bool" | create_yword ("ea_t" ea, "asize_t" length, "bool" force=False) |
| | create_yword(ea, length, force=False) -> bool Convert to ymm word.
|
| |
| "bool" | create_zword ("ea_t" ea, "asize_t" length, "bool" force=False) |
| | create_zword(ea, length, force=False) -> bool Convert to zmm word.
|
| |
| "bool" | create_tbyte ("ea_t" ea, "asize_t" length, "bool" force=False) |
| | create_tbyte(ea, length, force=False) -> bool Convert to tbyte.
|
| |
| "bool" | create_float ("ea_t" ea, "asize_t" length, "bool" force=False) |
| | create_float(ea, length, force=False) -> bool Convert to float.
|
| |
| "bool" | create_double ("ea_t" ea, "asize_t" length, "bool" force=False) |
| | create_double(ea, length, force=False) -> bool Convert to double.
|
| |
| "bool" | create_packed_real ("ea_t" ea, "asize_t" length, "bool" force=False) |
| | create_packed_real(ea, length, force=False) -> bool Convert to packed decimal real.
|
| |
| "bool" | create_struct ("ea_t" ea, "asize_t" length, "tid_t" tid, "bool" force=False) |
| | create_struct(ea, length, tid, force=False) -> bool Convert to struct.
|
| |
| "bool" | create_custdata ("ea_t" ea, "asize_t" length, "int" dtid, "int" fid, "bool" force=False) |
| | create_custdata(ea, length, dtid, fid, force=False) -> bool Convert to custom data type.
|
| |
| "bool" | create_align ("ea_t" ea, "asize_t" length, "int" alignment) |
| | create_align(ea, length, alignment) -> bool Create an alignment item.
|
| |
| "int" | calc_min_align ("asize_t" length) |
| | calc_min_align(length) -> int Calculate the minimal possible alignment exponent.
|
| |
| "int" | calc_max_align ("ea_t" endea) |
| | calc_max_align(endea) -> int Calculate the maximal possible alignment exponent.
|
| |
| "int" | calc_def_align ("ea_t" ea, "int" mina, "int" maxa) |
| | calc_def_align(ea, mina, maxa) -> int Calculate the default alignment exponent.
|
| |
| "bool" | create_16bit_data ("ea_t" ea, "asize_t" length) |
| | create_16bit_data(ea, length) -> bool Convert to 16-bit quantity (take the byte size into account)
|
| |
| "bool" | create_32bit_data ("ea_t" ea, "asize_t" length) |
| | create_32bit_data(ea, length) -> bool Convert to 32-bit quantity (take the byte size into account)
|
| |
| "size_t" | get_max_strlit_length ("ea_t" ea, "int32" strtype, "int" options=0) |
| | get_max_strlit_length(ea, strtype, options=0) -> size_t Determine maximum length of string literal.
|
| |
| "bool" | create_strlit ("ea_t" start, "size_t" len, "int32" strtype) |
| | create_strlit(start, len, strtype) -> bool Convert to string literal and give a meaningful name.
|
| |
| "opinfo_t *" | get_opinfo ("opinfo_t" buf, "ea_t" ea, "int" n, "flags64_t" flags) |
| | get_opinfo(buf, ea, n, flags) -> opinfo_t Get additional information about an operand representation.
|
| |
| "bool" | set_opinfo ("ea_t" ea, "int" n, "flags64_t" flag, "opinfo_t" ti, "bool" suppress_events=False) |
| | set_opinfo(ea, n, flag, ti, suppress_events=False) -> bool Set additional information about an operand representation.
|
| |
| "asize_t" | get_data_elsize ("ea_t" ea, "flags64_t" F, "opinfo_t" ti=None) |
| | get_data_elsize(ea, F, ti=None) -> asize_t Get size of data type specified in flags 'F'.
|
| |
| "asize_t" | get_full_data_elsize ("ea_t" ea, "flags64_t" F, "opinfo_t" ti=None) |
| | get_full_data_elsize(ea, F, ti=None) -> asize_t Get full size of data type specified in flags 'F'.
|
| |
| "int" | is_varsize_item ("ea_t" ea, "flags64_t" F, "opinfo_t" ti=None, "asize_t *" itemsize=None) |
| | is_varsize_item(ea, F, ti=None, itemsize=None) -> int Is the item at 'ea' variable size?.
|
| |
| "asize_t" | get_possible_item_varsize ("ea_t" ea, "tinfo_t" tif) |
| | get_possible_item_varsize(ea, tif) -> asize_t Return the possible size of the item at EA of type TIF if TIF is the variable structure.
|
| |
| "bool" | can_define_item ("ea_t" ea, "asize_t" length, "flags64_t" flags) |
| | can_define_item(ea, length, flags) -> bool Can define item (instruction/data) of the specified 'length', starting at 'ea'?
|
| |
| "bool" | has_immd ("flags64_t" F) |
| | has_immd(F) -> bool Has immediate value?
|
| |
| "bool" | is_func ("flags64_t" F) |
| | is_func(F) -> bool Is function start?
|
| |
| "bool" | set_immd ("ea_t" ea) |
| | set_immd(ea) -> bool Set 'has immediate operand' flag.
|
| |
| "data_type_t const *" | get_custom_data_type ("int" dtid) |
| | get_custom_data_type(dtid) -> data_type_t Get definition of a registered custom data type.
|
| |
| "data_format_t const *" | get_custom_data_format ("int" dfid) |
| | get_custom_data_format(dfid) -> data_format_t Get definition of a registered custom data format.
|
| |
| "bool" | attach_custom_data_format ("int" dtid, "int" dfid) |
| | attach_custom_data_format(dtid, dfid) -> bool Attach the data format to the data type.
|
| |
| "bool" | detach_custom_data_format ("int" dtid, "int" dfid) |
| | detach_custom_data_format(dtid, dfid) -> bool Detach the data format from the data type.
|
| |
| "bool" | is_attached_custom_data_format ("int" dtid, "int" dfid) |
| | is_attached_custom_data_format(dtid, dfid) -> bool Is the custom data format attached to the custom data type?
|
| |
| "int" | get_custom_data_types (*args) |
| | get_custom_data_types(out, min_size=0, max_size=BADADDR) -> int Get list of registered custom data type ids.
|
| |
| "int" | get_custom_data_formats ("intvec_t *" out, "int" dtid) |
| | get_custom_data_formats(out, dtid) -> int Get list of attached custom data formats for the specified data type.
|
| |
| "int" | find_custom_data_type ("char const *" name) |
| | find_custom_data_type(name) -> int Get id of a custom data type.
|
| |
| "int" | find_custom_data_format ("char const *" name) |
| | find_custom_data_format(name) -> int Get id of a custom data format.
|
| |
| "bool" | set_cmt ("ea_t" ea, "char const *" comm, "bool" rptble) |
| | set_cmt(ea, comm, rptble) -> bool Set an indented comment.
|
| |
| "qstring *" | get_cmt ("ea_t" ea, "bool" rptble) |
| | get_cmt(ea, rptble) -> str Get an indented comment.
|
| |
| "bool" | append_cmt ("ea_t" ea, "char const *" str, "bool" rptble) |
| | append_cmt(ea, str, rptble) -> bool Append to an indented comment.
|
| |
| "qstring *" | get_predef_insn_cmt ("insn_t const &" ins) |
| | get_predef_insn_cmt(ins) -> str Get predefined comment.
|
| |
| "ea_t" | find_byte ("ea_t" sEA, "asize_t" size, "uchar" value, "int" bin_search_flags) |
| | find_byte(sEA, size, value, bin_search_flags) -> ea_t Find forward a byte with the specified value (only 8-bit value from the database).
|
| |
| "ea_t" | find_byter ("ea_t" sEA, "asize_t" size, "uchar" value, "int" bin_search_flags) |
| | find_byter(sEA, size, value, bin_search_flags) -> ea_t Find reverse a byte with the specified value (only 8-bit value from the database).
|
| |
| "bool" | parse_binpat_str ("compiled_binpat_vec_t" out, "ea_t" ea, "char const *" _in, "int" radix, "int" strlits_encoding=0) |
| | parse_binpat_str(out, ea, _in, radix, strlits_encoding=0) -> bool Convert user-specified binary string to internal representation.
|
| |
| "ea_t" | bin_search (*args) |
| | Search for a set of bytes in the program.
|
| |
| "ea_t" | next_inited ("ea_t" ea, "ea_t" maxea) |
| | next_inited(ea, maxea) -> ea_t Find the next initialized address.
|
| |
| "ea_t" | prev_inited ("ea_t" ea, "ea_t" minea) |
| | prev_inited(ea, minea) -> ea_t Find the previous initialized address.
|
| |
| "bool" | equal_bytes ("ea_t" ea, "uchar const *" image, "uchar const *" mask, "size_t" len, "int" bin_search_flags) |
| | equal_bytes(ea, image, mask, len, bin_search_flags) -> bool Compare 'len' bytes of the program starting from 'ea' with 'image'.
|
| |
| "bool" | update_hidden_range ("hidden_range_t" ha) |
| | update_hidden_range(ha) -> bool Update hidden range information in the database.
|
| |
| "bool" | add_hidden_range (*args) |
| | add_hidden_range(ea1, ea2, description, header, footer, color=bgcolor_t(-1)) -> bool Mark a range of addresses as hidden.
|
| |
| "hidden_range_t *" | get_hidden_range ("ea_t" ea) |
| | get_hidden_range(ea) -> hidden_range_t Get pointer to hidden range structure, in: linear address.
|
| |
| "hidden_range_t *" | getn_hidden_range ("int" n) |
| | getn_hidden_range(n) -> hidden_range_t Get pointer to hidden range structure, in: number of hidden range.
|
| |
| "int" | get_hidden_range_qty () |
| | get_hidden_range_qty() -> int Get number of hidden ranges.
|
| |
| "int" | get_hidden_range_num ("ea_t" ea) |
| | get_hidden_range_num(ea) -> int Get number of a hidden range.
|
| |
| "hidden_range_t *" | get_prev_hidden_range ("ea_t" ea) |
| | get_prev_hidden_range(ea) -> hidden_range_t Get pointer to previous hidden range.
|
| |
| "hidden_range_t *" | get_next_hidden_range ("ea_t" ea) |
| | get_next_hidden_range(ea) -> hidden_range_t Get pointer to next hidden range.
|
| |
| "hidden_range_t *" | get_first_hidden_range () |
| | get_first_hidden_range() -> hidden_range_t Get pointer to the first hidden range.
|
| |
| "hidden_range_t *" | get_last_hidden_range () |
| | get_last_hidden_range() -> hidden_range_t Get pointer to the last hidden range.
|
| |
| "bool" | del_hidden_range ("ea_t" ea) |
| | del_hidden_range(ea) -> bool Delete hidden range.
|
| |
| "bool" | add_mapping ("ea_t" _from, "ea_t" to, "asize_t" size) |
| | add_mapping(_from, to, size) -> bool IDA supports memory mapping.
|
| |
| "void" | del_mapping ("ea_t" ea) |
| | del_mapping(ea) Delete memory mapping range.
|
| |
| "ea_t" | use_mapping ("ea_t" ea) |
| | use_mapping(ea) -> ea_t Translate address according to current mappings.
|
| |
| "size_t" | get_mappings_qty () |
| | get_mappings_qty() -> size_t Get number of mappings.
|
| |
| "ea_t *, ea_t *, asize_t *" | get_mapping ("size_t" n) |
| | get_mapping(n) -> bool Get memory mapping range by its number.
|
| |
| "int" | visit_patched_bytes ("ea_t" ea1, "ea_t" ea2, "PyObject *" py_callable) |
| | Enumerates patched bytes in the given range and invokes a callable.
|
| |
| "PyObject *" | get_bytes ("ea_t" ea, "unsigned int" size, "int" gmb_flags=0x01) |
| | Get the specified number of bytes of the program.
|
| |
| "PyObject *" | get_bytes_and_mask ("ea_t" ea, "unsigned int" size, "int" gmb_flags=0x01) |
| | Get the specified number of bytes of the program, and a bitmask specifying what bytes are defined and what bytes are not.
|
| |
| "PyObject *" | get_strlit_contents ("ea_t" ea, "PyObject *" py_len, "int32" type, "int" flags=0) |
| | Get contents of string literal, as UTF-8-encoded codepoints.
|
| |
| "PyObject *" | print_strlit_type ("int32" strtype, "int" flags=0) |
| | print_strlit_type(strtype, flags=0) -> PyObject Get string type information: the string type name (possibly decorated with hotkey markers), and the tooltip.
|
| |
| "bool" | op_stroff (*args) |
| | op_stroff(insn, n, path, path_len, delta) -> bool Set operand representation to be 'struct offset'.
|
| |
| "qvector< tid_t > *, adiff_t *" | get_stroff_path (*args) |
| | Get the structure offset path for operand n, at the specified address.
|
| |
| "int" | register_custom_data_type ("PyObject *" py_dt) |
| | Registers a custom data type.
|
| |
| "bool" | unregister_custom_data_type ("int" dtid) |
| | Unregisters a custom data type.
|
| |
| "int" | register_custom_data_format ("PyObject *" py_df) |
| | Registers a custom data format with a given data type.
|
| |
| "bool" | unregister_custom_data_format ("int" dfid) |
| | Unregisters a custom data format.
|
| |
| | register_data_types_and_formats (formats) |
| | Registers multiple data types and formats at once.
|
| |
| | unregister_data_types_and_formats (formats) |
| | As opposed to register_data_types_and_formats(), this function unregisters multiple data types and formats at once.
|
| |
| int | find_bytes (typing.Union[bytes, bytearray, str] bs, int range_start, typing.Optional[int] range_size=None, typing.Optional[int] range_end=ida_idaapi.BADADDR, typing.Optional[typing.Union[bytes, bytearray]] mask=None, typing.Optional[int] flags=BIN_SEARCH_FORWARD|BIN_SEARCH_NOSHOW, typing.Optional[int] radix=16, typing.Optional[typing.Union[int, str]] strlit_encoding=PBSENC_DEF1BPU) |
| |
| int | find_string (str _str, int range_start, typing.Optional[int] range_end=ida_idaapi.BADADDR, typing.Optional[int] range_size=None, typing.Optional[typing.Union[int, str]] strlit_encoding=PBSENC_DEF1BPU, typing.Optional[int] flags=BIN_SEARCH_FORWARD|BIN_SEARCH_NOSHOW) |
| |
1.12.0