Module `ida_nalt`

Definitions of various information kept in netnodes.

Each address in the program has a corresponding netnode: netnode(ea).

If we have no information about an address, the corresponding netnode is not created. Otherwise we will create a netnode and save information in it. All variable length information (names, comments, offset information, etc) is stored in the netnode.

Don't forget that some information is already stored in the flags (bytes.hpp)

warning: Many of the functions in this file are very low level (they are marked

as low level functions). Use them only if you can't find higher level function to set/get/del information.netnode.

Global variables

var AFL_ALIGNFLOW

the previous insn was created for alignment purposes only

var AFL_BNOT0

the 1st operand is bitwise negated

var AFL_BNOT1

the 2nd operand is bitwise negated

var AFL_COLORED

has user defined instruction color?

var AFL_FIXEDSPD

sp delta value is fixed by analysis. should not be modified by modules

var AFL_HIDDEN

the item is hidden completely

var AFL_HR_DETERMINED

the type is definitely guessed by the decompiler

var AFL_HR_GUESSED_DATA

the data type is guessed by the decompiler

var AFL_HR_GUESSED_FUNC

the function type is guessed by the decompiler

var AFL_IDA_GUESSED

the type is guessed by IDA

var AFL_LIB

item from the standard library. low level flag, is used to set FUNC_LIB of func_t

var AFL_LINNUM

has line number info

var AFL_LNAME

has local name too (FF_NAME should be set)

var AFL_LZERO0

toggle leading zeroes for the 1st operand

var AFL_LZERO1

toggle leading zeroes for the 2nd operand

var AFL_MANUAL

the instruction/data is specified by the user

var AFL_NOBRD

the code/data border is hidden

var AFL_NORET

for imported function pointers: doesn't return. this flag can also be used for any instruction which halts or finishes the program execution

var AFL_NOTCODE

autoanalysis should not create code here

var AFL_NOTPROC

autoanalysis should not create proc here

var AFL_PUBNAM

name is public (inter-file linkage)

var AFL_RETFP

function returns a floating point value

var AFL_SIGN0

AFL_SIGN0 = 1048576

var AFL_SIGN1

AFL_SIGN1 = 2097152

var AFL_TERSESTR

terse structure variable display?

var AFL_TI

has typeinfo? (NSUP_TYPEINFO); used only for addresses, not for member_t

var AFL_TI0

has typeinfo for operand 0? (NSUP_OPTYPES)

var AFL_TI1

has typeinfo for operand 1? (NSUP_OPTYPES+1)

var AFL_TILCMT

has type comment? (such a comment may be changed by IDA)

var AFL_TYPE_GUESSED

who guessed the type information?

var AFL_USEMODSP

insn modifes SP and uses the modified value; example: pop [rsp+N]

var AFL_USERSP

user-defined SP value

var AFL_USERTI

the type information is definitive. (comes from the user or type library) if not set see AFL_TYPE_GUESSED

var AFL_WEAKNAM

name is weak

var AFL_ZSTROFF

display struct field name at 0 offset when displaying an offset. example: offset somestruct.field_0 if this flag is clear, then offset somestruct

var AP_ALLOWDUPS

use 'dup' construct

var AP_ARRAY

create as array (this flag is not stored in database)

var AP_IDXBASEMASK

mask for number base of the indexes

var AP_IDXBIN

display indexes in binary

var AP_IDXDEC

display indexes in decimal

var AP_IDXHEX

display indexes in hex

var AP_IDXOCT

display indexes in octal

var AP_INDEX

display array element indexes as comments

var AP_SIGNED

treats numbers as signed

var BPU_1B

BPU_1B = 1

var BPU_2B

BPU_2B = 2

var BPU_4B

BPU_4B = 4

var IDB_DESKTOPS_NODE_NAME

hash indexed by desktop name with dekstop netnode

var IDB_DESKTOPS_TAG

tag to store desktop blob & timestamp

var MAXSTRUCPATH

maximal inclusion depth of unions

var NALT_ABSBASE

absolute segment location

var NALT_AFLAGS

additional flags for an item

var NALT_ALIGN

alignment value if the item is FF_ALIGN (should by equal to power of 2)

var NALT_COLOR

instruction/data background color

var NALT_CREF_FROM

code xref from, idx: source address

var NALT_CREF_TO

code xref to, idx: target address

var NALT_DREF_FROM

data xref from, idx: source address

var NALT_DREF_TO

data xref to, idx: target address

var NALT_ENUM0

enum id for the first operand

var NALT_ENUM1

enum id for the second operand

var NALT_GR_LAYX

group layout ptrs, hash: md5 of 'belongs'

var NALT_LINNUM

source line number

var NALT_PURGE

number of bytes purged from the stack when a function is called indirectly

var NALT_STRTYPE

type of string item

var NALT_STRUCT

struct id

var NALT_SWITCH

switch idiom address (used at jump targets)

var NSUP_ARGEAS

instructions that initialize call arguments

var NSUP_ARRAY

array parameters

var NSUP_CMT

regular comment

var NSUP_CUSTDT

custom data type id

var NSUP_EX_FLAGS

Extended flags.

var NSUP_FOP1

forced operand 1

var NSUP_FOP2

forced operand 2

var NSUP_FOP3

forced operand 3

var NSUP_FOP4

forced operand 4

var NSUP_FOP5

forced operand 5

var NSUP_FOP6

forced operand 6

var NSUP_FOP7

forced operand 7

var NSUP_FOP8

forced operand 8

var NSUP_FTAILS

function tails or tail referers values NSUP_FTAILS..NSUP_FTAILS+0x1000 are reserved

var NSUP_GROUP

graph group information values NSUP_GROUP..NSUP_GROUP+0x1000 are reserved

var NSUP_GROUPS

NSUP_GROUPS = 29

var NSUP_GR_INFO

group node info: color, ea, text

var NSUP_GR_LAYT

group layouts, idx: layout pointer

var NSUP_JINFO

jump table info

var NSUP_LLABEL

local labels. values NSUP_LLABEL..NSUP_LLABEL+0x1000 are reserved

var NSUP_MANUAL

manual instruction. values NSUP_MANUAL..NSUP_MANUAL+0x1000 are reserved

var NSUP_OMFGRP

NSUP_OMFGRP = 6

var NSUP_OPTYPES

operand type information. values NSUP_OPTYPES..NSUP_OPTYPES+0x100000 are reserved

var NSUP_OREF0

outer complex reference information for operand 1

var NSUP_OREF1

outer complex reference information for operand 2

var NSUP_OREF2

outer complex reference information for operand 3

var NSUP_OREF3

outer complex reference information for operand 4

var NSUP_OREF4

outer complex reference information for operand 5

var NSUP_OREF5

outer complex reference information for operand 6

var NSUP_OREF6

outer complex reference information for operand 7

var NSUP_OREF7

outer complex reference information for operand 8

var NSUP_ORIGFMD

function metadata before lumina information was applied values NSUP_ORIGFMD..NSUP_ORIGFMD+0x1000 are reserved

var NSUP_POINTS

SP change points blob (see funcs.cpp). values NSUP_POINTS..NSUP_POINTS+0x1000 are reserved

var NSUP_REF0

complex reference information for operand 1

var NSUP_REF1

complex reference information for operand 2

var NSUP_REF2

complex reference information for operand 3

var NSUP_REF3

complex reference information for operand 4

var NSUP_REF4

complex reference information for operand 5

var NSUP_REF5

complex reference information for operand 6

var NSUP_REF6

complex reference information for operand 7

var NSUP_REF7

complex reference information for operand 8

var NSUP_REGARG

var NSUP_REGVAR

var NSUP_REPCMT

repeatable comment

var NSUP_SEGTRANS

segment translations

var NSUP_STROFF0

NSUP_STROFF0 = 15

var NSUP_STROFF1

NSUP_STROFF1 = 16

var NSUP_SWITCH

switch information

var NSUP_TYPEINFO

type information. values NSUP_TYPEINFO..NSUP_TYPEINFO+0x1000 are reserved

var NSUP_XREFPOS

saved xref address and type in the xrefs window

var PATCH_TAG

Patch netnode tag.

var POF_IS_F64

POF_IS_F64 = 4

var POF_VALID_AFLAGS

POF_VALID_AFLAGS = 2

var POF_VALID_TI

POF_VALID_TI = 1

var REFINFO_CUSTOM

a custom reference. see custom_refinfo_handler_t. the id of the custom refinfo is stored under the REFINFO_TYPE mask.

var REFINFO_NOBASE

don't create the base xref; implies that the base can be any value. nb: base xrefs are created only if the offset base points to the middle of a segment

var REFINFO_NO_ONES

an opval of ~0 will be considered invalid

var REFINFO_NO_ZEROS

an opval of 0 will be considered invalid

var REFINFO_PASTEND

reference past an item; it may point to an nonexistent address; do not destroy alignment dirs

var REFINFO_RVAOFF

based reference (rva); refinfo_t::base will be forced to get_imagebase(); such a reference is displayed with the asm_t::a_rva keyword

var REFINFO_SELFREF

the self-based reference; refinfo_t::base will be forced to the reference address

var REFINFO_SIGNEDOP

the operand value is sign-extended (only supported for REF_OFF8/16/32/64)

var REFINFO_SUBTRACT

the reference value is subtracted from the base value instead of (as usual) being added to it

var REFINFO_TYPE

reference type (reftype_t), or custom reference ID if REFINFO_CUSTOM set

var REF_HIGH16

high 16bits of 32bit offset

var REF_HIGH8

high 8bits of 16bit offset

var REF_LAST

REF_LAST = 10

var REF_LOW16

low 16bits of 32bit offset

var REF_LOW8

low 8bits of 16bit offset

var REF_OFF16

16bit full offset

var REF_OFF32

32bit full offset

var REF_OFF64

64bit full offset

var REF_OFF8

8bit full offset

var RIDX_ABINAME

ABI name (processor specific)

var RIDX_ARCHIVE_PATH

archive file path

var RIDX_C_MACROS

C predefined macros.

var RIDX_DBG_BINPATHS

unused (20 indexes)

var RIDX_DUALOP_GRAPH

Graph text representation options.

var RIDX_DUALOP_TEXT

Text text representation options.

var RIDX_FILE_FORMAT_NAME

file format name for loader modules

var RIDX_GROUPS

segment group information (see init_groups())

var RIDX_H_PATH

C header path.

var RIDX_IDA_VERSION

version of ida which created the database

var RIDX_INCLUDE

assembler include file name

var RIDX_MD5

MD5 of the input file.

var RIDX_NOTEPAD

notepad blob, occupies 1000 indexes (1MB of text)

var RIDX_PROBLEMS

problem lists

var RIDX_SELECTORS

2..63 are for selector_t blob (see init_selectors())

var RIDX_SHA256

SHA256 of the input file.

var RIDX_SMALL_IDC

Instant IDC statements, blob.

var RIDX_SMALL_IDC_OLD

Instant IDC statements (obsolete)

var RIDX_SRCDBG_PATHS

source debug paths, occupies 20 indexes

var RIDX_SRCDBG_UNDESIRED

user-closed source files, occupies 20 indexes

var RIDX_STR_ENCODINGS

a list of encodings for the program strings

var STRENC_DEFAULT

use default encoding for this type (see get_default_encoding_idx())

var STRENC_NONE

force no-conversion encoding

var STRLYT_MASK

STRLYT_MASK = 252

var STRLYT_PASCAL1

STRLYT_PASCAL1 = 1

var STRLYT_PASCAL2

STRLYT_PASCAL2 = 2

var STRLYT_PASCAL4

STRLYT_PASCAL4 = 3

var STRLYT_SHIFT

STRLYT_SHIFT = 2

var STRLYT_TERMCHR

STRLYT_TERMCHR = 0

var STRTYPE_C

Zero-terminated 16bit chars.

var STRTYPE_C_16

Zero-terminated 32bit chars.

var STRTYPE_C_32

Pascal-style, one-byte length prefix.

var STRTYPE_LEN2

Pascal-style, 16bit chars, two-byte length prefix.

var STRTYPE_LEN2_16

Pascal-style, 32bit chars, two-byte length prefix.

var STRTYPE_LEN2_32

Pascal-style, four-byte length prefix.

var STRTYPE_LEN4

Pascal-style, 16bit chars, four-byte length prefix.

var STRTYPE_LEN4_16

Pascal-style, 32bit chars, four-byte length prefix.

var STRTYPE_LEN4_32

STRTYPE_LEN4_32 = 14

var STRTYPE_PASCAL

Pascal-style, 16bit chars, one-byte length prefix.

var STRTYPE_PASCAL_16

Pascal-style, 32bit chars, one-byte length prefix.

var STRTYPE_PASCAL_32

Pascal-style, two-byte length prefix.

var STRTYPE_TERMCHR

C-style string.

var STRWIDTH_1B

STRWIDTH_1B = 0

var STRWIDTH_2B

STRWIDTH_2B = 1

var STRWIDTH_4B

STRWIDTH_4B = 2

var STRWIDTH_MASK

STRWIDTH_MASK = 3

var SWI_CUSTOM

custom jump table. processor_t::create_switch_xrefs will be called to create code xrefs for the table. Custom jump table must be created by the module (see also SWI_STDTBL)

var SWI_DEFRET

return in the default case (defjump==BADADDR)

var SWI_DEF_IN_TBL

default case is an entry in the jump table. This flag is applicable in 2 cases:

The sparse indirect switch (i.e. a switch with a values table) {jump table size} == {value table size} + 1. The default case entry is the last one in the table (or the first one in the case of an inversed jump table).
The switch with insns in the jump table. The default case entry is before the first entry of the table. See also the find_defjump_from_table() helper function.

var SWI_ELBASE

elbase is present (otherwise the base of the switch segment will be used)

var SWI_HXNOLOWCASE

lowcase value should not be used by the decompiler (internal flag)

var SWI_INDIRECT

value table elements are used as indexes into the jump table (for sparse switches)

var SWI_J32

32-bit jump offsets

var SWI_JMPINSN

jump table entries are insns. For such entries SHIFT has a different meaning. It denotes the number of insns in the entry. For example, 0 - the entry contains the jump to the case, 1 - the entry contains one insn like a 'mov' and jump to the end of case, and so on.

var SWI_JMP_INV

jumptable is inversed. (last entry is for first entry in values table)

var SWI_JSIZE

jump offset expansion bit

var SWI_SELFREL

jump address is relative to the element not to ELBASE

var SWI_SEPARATE

create an array of individual elements (otherwise separate items)

var SWI_SHIFT_MASK

use formula (element<<shift) + elbase to find jump targets

var SWI_SIGNED

jump table entries are signed

var SWI_SPARSE

sparse switch (value table present), otherwise lowcase present

var SWI_STDTBL

custom jump table with standard table formatting. ATM IDA doesn't use SWI_CUSTOM for switches with standard table formatting. So this flag can be considered as obsolete.

var SWI_SUBTRACT

table values are subtracted from the elbase instead of being added

var SWI_USER

user specified switch (starting from version 2)

var SWI_V32

32-bit values in table

var SWI_VERSION

the structure contains the VERSION member

var SWI_VSIZE

value table element size expansion bit

var SWI_VSPLIT

value table is split (only for 32-bit values)

var V695_REF_OFF8

reserved

var V695_REF_VHIGH

obsolete

var V695_REF_VLOW

obsolete

Functions

def add_encoding(*args) ‑> int: add_encoding(encname) -> int
Add a new encoding (e.g. "UTF-8"). If it's already in the list, return its index.

encname: (C++: const char *) the encoding name

return: its index (1-based); -1 means error
def clr__bnot0(*args) ‑> void: clr__bnot0(ea)
ea: ea_t
def clr__bnot1(*args) ‑> void: clr__bnot1(ea)
ea: ea_t
def clr__invsign0(*args) ‑> void: clr__invsign0(ea)
ea: ea_t
def clr__invsign1(*args) ‑> void: clr__invsign1(ea)
ea: ea_t
def clr_abits(*args) ‑> void: clr_abits(ea, bits)
ea: ea_t

bits: aflags_t
def clr_align_flow(*args) ‑> void: clr_align_flow(ea)
ea: ea_t
def clr_colored_item(*args) ‑> void: clr_colored_item(ea)
ea: ea_t
def clr_fixed_spd(*args) ‑> void: clr_fixed_spd(ea)
ea: ea_t
def clr_has_lname(*args) ‑> void: clr_has_lname(ea)
ea: ea_t
def clr_has_ti(*args) ‑> void: clr_has_ti(ea)
ea: ea_t
def clr_has_ti0(*args) ‑> void: clr_has_ti0(ea)
ea: ea_t
def clr_has_ti1(*args) ‑> void: clr_has_ti1(ea)
ea: ea_t
def clr_libitem(*args) ‑> void: clr_libitem(ea)
ea: ea_t
def clr_lzero0(*args) ‑> void: clr_lzero0(ea)
ea: ea_t
def clr_lzero1(*args) ‑> void: clr_lzero1(ea)
ea: ea_t
def clr_noret(*args) ‑> void: clr_noret(ea)
ea: ea_t
def clr_notcode(*args) ‑> void: clr_notcode(ea)
Clear not-code mark.

ea: (C++: ea_t)
def clr_notproc(*args) ‑> void: clr_notproc(ea)
ea: ea_t
def clr_retfp(*args) ‑> void: clr_retfp(ea)
ea: ea_t
def clr_terse_struc(*args) ‑> void: clr_terse_struc(ea)
ea: ea_t
def clr_tilcmt(*args) ‑> void: clr_tilcmt(ea)
ea: ea_t
def clr_usemodsp(*args) ‑> void: clr_usemodsp(ea)
ea: ea_t
def clr_usersp(*args) ‑> void: clr_usersp(ea)
ea: ea_t
def clr_userti(*args) ‑> void: clr_userti(ea)
ea: ea_t
def clr_zstroff(*args) ‑> void: clr_zstroff(ea)
ea: ea_t
def dbg_get_input_path(*args) ‑> size_t: dbg_get_input_path() -> str
Get debugger input file name/path (see LFLG_DBG_NOPATH)
def del_absbase(*args) ‑> void: del_absbase(ea)
ea: ea_t
def del_aflags(*args) ‑> void: del_aflags(ea)
ea: ea_t
def del_alignment(*args) ‑> void: del_alignment(ea)
ea: ea_t
def del_array_parameters(*args) ‑> void: del_array_parameters(ea)
ea: ea_t
def del_custom_data_type_ids(*args) ‑> void: del_custom_data_type_ids(ea)
ea: ea_t
def del_encoding(*args) ‑> bool: del_encoding(idx) -> bool
Delete an encoding The encoding is not actually removed because its index may be used in strtype. So the deletion just clears the encoding name. The default encoding cannot be deleted.

idx: (C++: int) the encoding index (1-based)
def del_ind_purged(*args) ‑> void: del_ind_purged(ea)
ea: ea_t
def del_item_color(*args) ‑> bool: del_item_color(ea) -> bool
ea: ea_t
def del_op_tinfo(*args) ‑> void: del_op_tinfo(ea, n)
ea: ea_t

n: int
def del_refinfo(*args) ‑> bool: del_refinfo(ea, n) -> bool
ea: ea_t

n: int
def del_source_linnum(*args) ‑> void: del_source_linnum(ea)
ea: ea_t
def del_str_type(*args) ‑> void: del_str_type(ea)
ea: ea_t
def del_switch_info(*args) ‑> void: del_switch_info(ea)
ea: ea_t
def del_switch_parent(*args) ‑> void: del_switch_parent(ea)
ea: ea_t
def del_tinfo(*args) ‑> void: del_tinfo(ea)
ea: ea_t
def delete_imports(*args) ‑> void: delete_imports()
Delete all imported modules information.
def ea2node(*args) ‑> nodeidx_t: ea2node(ea) -> nodeidx_t
Get netnode for the specified address.

ea: (C++: ea_t)
def encoding_from_strtype(*args) ‑> char const *: encoding_from_strtype(strtype) -> char const *
Get encoding name for this strtype

retval nullptr: if STRTYPE has an incorrent encoding index

retval empty: string if the encoding was deleted

strtype: (C++: int32)
def end_ea2node(*args) ‑> nodeidx_t: end_ea2node(ea) -> nodeidx_t
ea: ea_t
def enum_import_names(*args) ‑> int: enum_import_names(mod_index, py_cb) -> int
Enumerate imports from a specific module. Please refer to ex_imports.py example.

mod_index: The module index

callback: A callable object that will be invoked with an ea, name (could be None) and ordinal.

return: 1-finished ok, -1 on error, otherwise callback return value (<=0)
def find_custom_refinfo(*args) ‑> int: find_custom_refinfo(name) -> int
Get id of a custom refinfo type.

name: (C++: const char *) char const *
def get_abi_name()
def get_absbase(*args) ‑> ea_t: get_absbase(ea) -> ea_t
ea: ea_t
def get_aflags(*args) ‑> aflags_t: get_aflags(ea) -> aflags_t
ea: ea_t
def get_alignment(*args) ‑> uint32: get_alignment(ea) -> uint32
ea: ea_t
def get_archive_path(*args) ‑> qstring *: get_archive_path() -> str
Get archive file path from which input file was extracted.
def get_array_parameters(*args) ‑> ssize_t: get_array_parameters(out, ea) -> ssize_t
out: array_parameters_t *

ea: ea_t
def get_asm_inc_file(*args) ‑> qstring *: get_asm_inc_file() -> str
Get name of the include file.
def get_custom_data_type_ids(*args) ‑> int: get_custom_data_type_ids(cdis, ea) -> int
cdis: custom_data_type_ids_t *

ea: ea_t
def get_custom_refinfo(*args) ‑> custom_refinfo_handler_t const *: get_custom_refinfo(crid) -> custom_refinfo_handler_t const *
Get definition of a registered custom refinfo type.

crid: (C++: int)
def get_default_encoding_idx(*args) ‑> int: get_default_encoding_idx(bpu) -> int
Get default encoding index for a specific string type.

bpu: (C++: int) the amount of bytes per unit (e.g., 1 for ASCII, CP1252, UTF-8..., 2
for UTF-16, 4 for UTF-32)

retval 0: bad BPU argument
def get_elapsed_secs(*args) ‑> size_t: get_elapsed_secs() -> size_t
Get seconds database stayed open.
def get_encoding_bpu(*args) ‑> int: get_encoding_bpu(idx) -> int
Get the amount of bytes per unit (e.g., 2 for UTF-16, 4 for UTF-32) for the encoding with the given index.

idx: (C++: int) the encoding index (1-based)

return: the number of bytes per units (1/2/4); -1 means error
def get_encoding_bpu_by_name(*args) ‑> int: get_encoding_bpu_by_name(encname) -> int
Get the amount of bytes per unit for the given encoding

encname: (C++: const char *) the encoding name

return: the number of bytes per units (1/2/4); -1 means error
def get_encoding_name(*args) ‑> char const *: get_encoding_name(idx) -> char const *
Get encoding name for specific index (1-based).

idx: (C++: int) the encoding index (1-based)

retval nullptr: if IDX is out of bounds

retval empty: string if the encoding was deleted
def get_encoding_qty(*args) ‑> int: get_encoding_qty() -> int
Get total number of encodings (counted from 0)
def get_gotea(*args) ‑> ea_t: get_gotea() -> ea_t
def get_ida_notepad_text(*args) ‑> qstring *: get_ida_notepad_text() -> str
Get notepad text.
def get_idb_ctime(*args) ‑> time_t: get_idb_ctime() -> time_t
Get database creation timestamp.
def get_idb_nopens(*args) ‑> size_t: get_idb_nopens() -> size_t
Get number of times the database is opened.
def get_ids_modnode(*args) ‑> netnode: get_ids_modnode() -> netnode
Get ids modnode.
def get_imagebase(*args) ‑> ea_t: get_imagebase() -> ea_t
Get image base address.
def get_import_module_name(*args) ‑> PyObject *: get_import_module_name(mod_index) -> str
Returns the name of an imported module given its index

mod_index: int

return: None or the module name
def get_import_module_qty(*args) ‑> uint: get_import_module_qty() -> uint
Get number of import modules.
def get_ind_purged(*args) ‑> ea_t: get_ind_purged(ea) -> ea_t
ea: ea_t
def get_initial_ida_version(*args) ‑> qstring *: get_initial_ida_version() -> str
Get version of ida which created the database (string format like "7.5")
def get_initial_idb_version(*args) ‑> ushort: get_initial_idb_version() -> ushort
Get initial version of the database (numeric format like 700)
def get_initial_version(*args) ‑> ushort: get_initial_idb_version() -> ushort
Get initial version of the database (numeric format like 700)
def get_input_file_path(*args) ‑> size_t: get_input_file_path() -> str
Get full path of the input file.
def get_item_color(*args) ‑> bgcolor_t: get_item_color(ea) -> bgcolor_t
ea: ea_t
def get_loader_format_name(*args) ‑> qstring *: get_loader_format_name() -> str
Get file format name for loader modules.
def get_op_tinfo(*args) ‑> bool: get_op_tinfo(tif, ea, n) -> bool
tif: tinfo_t *

ea: ea_t

n: int
def get_outfile_encoding_idx(*args) ‑> int: get_outfile_encoding_idx() -> int
Get the index of the encoding used when producing files

retval 0: the IDB's default 1 byte-per-unit encoding is used
def get_refinfo(*args) ‑> bool: get_refinfo(ri, ea, n) -> bool
ri: refinfo_t *

ea: ea_t

n: int
def get_reftype_by_size(*args) ‑> reftype_t: get_reftype_by_size(size) -> reftype_t
Get REF_... constant from size Supported sizes: 1,2,4,8,16 For other sizes returns reftype_t(-1)

size: (C++: size_t)
def get_root_filename(*args) ‑> size_t: get_root_filename() -> str
Get file name only of the input file.
def get_source_linnum(*args) ‑> uval_t: get_source_linnum(ea) -> uval_t
ea: ea_t
def get_srcdbg_paths(*args) ‑> qstring *: get_srcdbg_paths() -> str
Get source debug paths.
def get_srcdbg_undesired_paths(*args) ‑> qstring *: get_srcdbg_undesired_paths() -> str
Get user-closed source files.
def get_str_encoding_idx(*args) ‑> uchar: get_str_encoding_idx(strtype) -> uchar
Get index of the string encoding for this string.

strtype: (C++: int32)
def get_str_term1(*args) ‑> char: get_str_term1(strtype) -> char
strtype: int32
def get_str_term2(*args) ‑> char: get_str_term2(strtype) -> char
strtype: int32
def get_str_type(*args) ‑> uint32: get_str_type(ea) -> uint32
ea: ea_t
def get_str_type_code(*args) ‑> uchar: get_str_type_code(strtype) -> uchar
strtype: int32
def get_str_type_prefix_length(*args) ‑> size_t: get_str_type_prefix_length(strtype) -> size_t
strtype: int32
def get_strid(*args) ‑> tid_t: get_strid(ea) -> tid_t
ea: ea_t
def get_strtype_bpu(*args) ‑> int: get_strtype_bpu(strtype) -> int
strtype: int32
def get_switch_info(*args)
def get_switch_parent(*args) ‑> ea_t: get_switch_parent(ea) -> ea_t
ea: ea_t
def get_tinfo(*args) ‑> bool: get_tinfo(tif, ea) -> bool
tif: tinfo_t *

ea: ea_t
def getnode(*args) ‑> netnode: getnode(ea) -> netnode
ea: ea_t
def has_aflag_linnum(*args) ‑> bool: has_aflag_linnum(flags) -> bool
flags: aflags_t
def has_aflag_lname(*args) ‑> bool: has_aflag_lname(flags) -> bool
flags: aflags_t
def has_aflag_ti(*args) ‑> bool: has_aflag_ti(flags) -> bool
flags: aflags_t
def has_aflag_ti0(*args) ‑> bool: has_aflag_ti0(flags) -> bool
flags: aflags_t
def has_aflag_ti1(*args) ‑> bool: has_aflag_ti1(flags) -> bool
flags: aflags_t
def has_lname(*args) ‑> bool: has_lname(ea) -> bool
ea: ea_t
def has_ti(*args) ‑> bool: has_ti(ea) -> bool
ea: ea_t
def has_ti0(*args) ‑> bool: has_ti0(ea) -> bool
ea: ea_t
def has_ti1(*args) ‑> bool: has_ti1(ea) -> bool
ea: ea_t
def hide_border(*args) ‑> void: hide_border(ea)
ea: ea_t
def hide_item(*args) ‑> void: hide_item(ea)
ea: ea_t
def is__bnot0(*args) ‑> bool: is__bnot0(ea) -> bool
ea: ea_t
def is__bnot1(*args) ‑> bool: is__bnot1(ea) -> bool
ea: ea_t
def is__invsign0(*args) ‑> bool: is__invsign0(ea) -> bool
ea: ea_t
def is__invsign1(*args) ‑> bool: is__invsign1(ea) -> bool
ea: ea_t
def is_aflag__bnot0(*args) ‑> bool: is_aflag__bnot0(flags) -> bool
flags: aflags_t
def is_aflag__bnot1(*args) ‑> bool: is_aflag__bnot1(flags) -> bool
flags: aflags_t
def is_aflag__invsign0(*args) ‑> bool: is_aflag__invsign0(flags) -> bool
flags: aflags_t
def is_aflag__invsign1(*args) ‑> bool: is_aflag__invsign1(flags) -> bool
flags: aflags_t
def is_aflag_align_flow(*args) ‑> bool: is_aflag_align_flow(flags) -> bool
flags: aflags_t
def is_aflag_colored_item(*args) ‑> bool: is_aflag_colored_item(flags) -> bool
flags: aflags_t
def is_aflag_data_guessed_by_hexrays(*args) ‑> bool: is_aflag_data_guessed_by_hexrays(flags) -> bool
flags: aflags_t
def is_aflag_fixed_spd(*args) ‑> bool: is_aflag_fixed_spd(flags) -> bool
flags: aflags_t
def is_aflag_func_guessed_by_hexrays(*args) ‑> bool: is_aflag_func_guessed_by_hexrays(flags) -> bool
flags: aflags_t
def is_aflag_hidden_border(*args) ‑> bool: is_aflag_hidden_border(flags) -> bool
flags: aflags_t
def is_aflag_hidden_item(*args) ‑> bool: is_aflag_hidden_item(flags) -> bool
flags: aflags_t
def is_aflag_libitem(*args) ‑> bool: is_aflag_libitem(flags) -> bool
flags: aflags_t
def is_aflag_lzero0(*args) ‑> bool: is_aflag_lzero0(flags) -> bool
flags: aflags_t
def is_aflag_lzero1(*args) ‑> bool: is_aflag_lzero1(flags) -> bool
flags: aflags_t
def is_aflag_manual_insn(*args) ‑> bool: is_aflag_manual_insn(flags) -> bool
flags: aflags_t
def is_aflag_noret(*args) ‑> bool: is_aflag_noret(flags) -> bool
flags: aflags_t
def is_aflag_notcode(*args) ‑> bool: is_aflag_notcode(flags) -> bool
flags: aflags_t
def is_aflag_notproc(*args) ‑> bool: is_aflag_notproc(flags) -> bool
flags: aflags_t
def is_aflag_public_name(*args) ‑> bool: is_aflag_public_name(flags) -> bool
flags: aflags_t
def is_aflag_retfp(*args) ‑> bool: is_aflag_retfp(flags) -> bool
flags: aflags_t
def is_aflag_terse_struc(*args) ‑> bool: is_aflag_terse_struc(flags) -> bool
flags: aflags_t
def is_aflag_tilcmt(*args) ‑> bool: is_aflag_tilcmt(flags) -> bool
flags: aflags_t
def is_aflag_type_determined_by_hexrays(*args) ‑> bool: is_aflag_type_determined_by_hexrays(flags) -> bool
flags: aflags_t
def is_aflag_type_guessed_by_hexrays(*args) ‑> bool: is_aflag_type_guessed_by_hexrays(flags) -> bool
flags: aflags_t
def is_aflag_type_guessed_by_ida(*args) ‑> bool: is_aflag_type_guessed_by_ida(flags) -> bool
flags: aflags_t
def is_aflag_usersp(*args) ‑> bool: is_aflag_usersp(flags) -> bool
flags: aflags_t
def is_aflag_userti(*args) ‑> bool: is_aflag_userti(flags) -> bool
flags: aflags_t
def is_aflag_weak_name(*args) ‑> bool: is_aflag_weak_name(flags) -> bool
flags: aflags_t
def is_aflag_zstroff(*args) ‑> bool: is_aflag_zstroff(flags) -> bool
flags: aflags_t
def is_align_flow(*args) ‑> bool: is_align_flow(ea) -> bool
ea: ea_t
def is_colored_item(*args) ‑> bool: is_colored_item(ea) -> bool
ea: ea_t
def is_data_guessed_by_hexrays(*args) ‑> bool: is_data_guessed_by_hexrays(ea) -> bool
ea: ea_t
def is_finally_visible_item(*args) ‑> bool: is_finally_visible_item(ea) -> bool
Is instruction visible?

ea: (C++: ea_t)
def is_fixed_spd(*args) ‑> bool: is_fixed_spd(ea) -> bool
ea: ea_t
def is_func_guessed_by_hexrays(*args) ‑> bool: is_func_guessed_by_hexrays(ea) -> bool
ea: ea_t
def is_hidden_border(*args) ‑> bool: is_hidden_border(ea) -> bool
ea: ea_t
def is_hidden_item(*args) ‑> bool: is_hidden_item(ea) -> bool
ea: ea_t
def is_libitem(*args) ‑> bool: is_libitem(ea) -> bool
ea: ea_t
def is_lzero0(*args) ‑> bool: is_lzero0(ea) -> bool
ea: ea_t
def is_lzero1(*args) ‑> bool: is_lzero1(ea) -> bool
ea: ea_t
def is_noret(*args) ‑> bool: is_noret(ea) -> bool
ea: ea_t
def is_notcode(*args) ‑> bool: is_notcode(ea) -> bool
Is the address marked as not-code?

ea: (C++: ea_t)
def is_notproc(*args) ‑> bool: is_notproc(ea) -> bool
ea: ea_t
def is_pascal(*args) ‑> bool: is_pascal(strtype) -> bool
strtype: int32
def is_reftype_target_optional(*args) ‑> bool: is_reftype_target_optional(type) -> bool
Can the target be calculated using operand value?

type: (C++: reftype_t)
def is_retfp(*args) ‑> bool: is_retfp(ea) -> bool
ea: ea_t
def is_terse_struc(*args) ‑> bool: is_terse_struc(ea) -> bool
ea: ea_t
def is_tilcmt(*args) ‑> bool: is_tilcmt(ea) -> bool
ea: ea_t
def is_type_determined_by_hexrays(*args) ‑> bool: is_type_determined_by_hexrays(ea) -> bool
ea: ea_t
def is_type_guessed_by_hexrays(*args) ‑> bool: is_type_guessed_by_hexrays(ea) -> bool
ea: ea_t
def is_type_guessed_by_ida(*args) ‑> bool: is_type_guessed_by_ida(ea) -> bool
ea: ea_t
def is_usersp(*args) ‑> bool: is_usersp(ea) -> bool
ea: ea_t
def is_userti(*args) ‑> bool: is_userti(ea) -> bool
ea: ea_t
def is_visible_item(*args) ‑> bool: is_visible_item(ea) -> bool
Test visibility of item at given ea.

ea: (C++: ea_t)
def is_zstroff(*args) ‑> bool: is_zstroff(ea) -> bool
ea: ea_t
def make_str_type(*args) ‑> int32: make_str_type(type_code, encoding_idx, term1=0, term2=0) -> int32
Get string type for a string in the given encoding.

type_code: (C++: uchar)

encoding_idx: (C++: int)

term1: (C++: uchar)

term2: (C++: uchar)
def node2ea(*args) ‑> ea_t: node2ea(ndx) -> ea_t
ndx: nodeidx_t
def rename_encoding(*args) ‑> bool: rename_encoding(idx, encname) -> bool
Change name for an encoding The number of bytes per unit (BPU) of the new encoding must match this number of the existing default encoding. Specifying the empty name simply deletes this encoding.

idx: (C++: int) the encoding index (1-based)

encname: (C++: const char *) the new encoding name
def retrieve_input_file_crc32(*args) ‑> uint32: retrieve_input_file_crc32() -> uint32
Get input file crc32 stored in the database. it can be used to check that the input file has not been changed.
def retrieve_input_file_md5(*args) ‑> uchar [ANY]: retrieve_input_file_md5() -> bytes
Get input file md5.
def retrieve_input_file_sha256(*args) ‑> uchar [ANY]: retrieve_input_file_sha256() -> bytes
Get input file sha256.
def retrieve_input_file_size(*args) ‑> size_t: retrieve_input_file_size() -> size_t
Get size of input file in bytes.
def set__bnot0(*args) ‑> void: set__bnot0(ea)
ea: ea_t
def set__bnot1(*args) ‑> void: set__bnot1(ea)
ea: ea_t
def set__invsign0(*args) ‑> void: set__invsign0(ea)
ea: ea_t
def set__invsign1(*args) ‑> void: set__invsign1(ea)
ea: ea_t
def set_abits(*args) ‑> void: set_abits(ea, bits)
ea: ea_t

bits: aflags_t
def set_absbase(*args) ‑> void: set_absbase(ea, x)
ea: ea_t

x: ea_t
def set_aflags(*args) ‑> void: set_aflags(ea, flags)
ea: ea_t

flags: aflags_t
def set_align_flow(*args) ‑> void: set_align_flow(ea)
ea: ea_t
def set_alignment(*args) ‑> void: set_alignment(ea, x)
ea: ea_t

x: uint32
def set_archive_path(*args) ‑> bool: set_archive_path(file) -> bool
Set archive file path from which input file was extracted.

file: (C++: const char *) char const *
def set_array_parameters(*args) ‑> void: set_array_parameters(ea, _in)
ea: ea_t

in: array_parameters_t const *
def set_asm_inc_file(*args) ‑> bool: set_asm_inc_file(file) -> bool
Set name of the include file.

file: (C++: const char *) char const *
def set_colored_item(*args) ‑> void: set_colored_item(ea)
ea: ea_t
def set_custom_data_type_ids(*args) ‑> void: set_custom_data_type_ids(ea, cdis)
ea: ea_t

cdis: custom_data_type_ids_t const *
def set_data_guessed_by_hexrays(*args) ‑> void: set_data_guessed_by_hexrays(ea)
ea: ea_t
def set_default_encoding_idx(*args) ‑> bool: set_default_encoding_idx(bpu, idx) -> bool
Set default encoding for a string type

bpu: (C++: int) the amount of bytes per unit

idx: (C++: int) the encoding index. It cannot be 0
def set_fixed_spd(*args) ‑> void: set_fixed_spd(ea)
ea: ea_t
def set_func_guessed_by_hexrays(*args) ‑> void: set_func_guessed_by_hexrays(ea)
ea: ea_t
def set_gotea(*args) ‑> void: set_gotea(gotea)
gotea: ea_t
def set_has_lname(*args) ‑> void: set_has_lname(ea)
ea: ea_t
def set_has_ti(*args) ‑> void: set_has_ti(ea)
ea: ea_t
def set_has_ti0(*args) ‑> void: set_has_ti0(ea)
ea: ea_t
def set_has_ti1(*args) ‑> void: set_has_ti1(ea)
ea: ea_t
def set_ida_notepad_text(*args) ‑> void: set_ida_notepad_text(text, size=0)
Set notepad text.

text: (C++: const char *) char const *

size: (C++: size_t)
def set_ids_modnode(*args) ‑> void: set_ids_modnode(id)
Set ids modnode.

id: (C++: netnode)
def set_imagebase(*args) ‑> void: set_imagebase(base)
Set image base address.

base: (C++: ea_t)
def set_item_color(*args) ‑> void: set_item_color(ea, color)
ea: ea_t

color: bgcolor_t
def set_libitem(*args) ‑> void: set_libitem(ea)
ea: ea_t
def set_loader_format_name(*args) ‑> void: set_loader_format_name(name)
Set file format name for loader modules.

name: (C++: const char *) char const *
def set_lzero0(*args) ‑> void: set_lzero0(ea)
ea: ea_t
def set_lzero1(*args) ‑> void: set_lzero1(ea)
ea: ea_t
def set_noret(*args) ‑> void: set_noret(ea)
ea: ea_t
def set_notcode(*args) ‑> void: set_notcode(ea)
Mark address so that it cannot be converted to instruction.

ea: (C++: ea_t)
def set_notproc(*args) ‑> void: set_notproc(ea)
ea: ea_t
def set_op_tinfo(*args) ‑> bool: set_op_tinfo(ea, n, tif) -> bool
ea: ea_t

n: int

tif: tinfo_t const *
def set_outfile_encoding_idx(*args) ‑> bool: set_outfile_encoding_idx(idx) -> bool
set encoding to be used when producing files

idx: (C++: int) the encoding index IDX can be 0 to use the IDB's default 1-byte-per-
unit encoding
def set_refinfo(*args) ‑> bool: set_refinfo(ea, n, type, target=BADADDR, base=0, tdelta=0) -> bool
ea: ea_t

n: int

type: reftype_t

target: ea_t

base: ea_t

tdelta: adiff_t
def set_refinfo_ex(*args) ‑> bool: set_refinfo_ex(ea, n, ri) -> bool
ea: ea_t

n: int

ri: refinfo_t const *
def set_retfp(*args) ‑> void: set_retfp(ea)
ea: ea_t
def set_root_filename(*args) ‑> void: set_root_filename(file)
Set full path of the input file.

file: (C++: const char *) char const *
def set_source_linnum(*args) ‑> void: set_source_linnum(ea, lnnum)
ea: ea_t

lnnum: uval_t
def set_srcdbg_paths(*args) ‑> void: set_srcdbg_paths(paths)
Set source debug paths.

paths: (C++: const char *) char const *
def set_srcdbg_undesired_paths(*args) ‑> void: set_srcdbg_undesired_paths(paths)
Set user-closed source files.

paths: (C++: const char *) char const *
def set_str_encoding_idx(*args) ‑> int32: set_str_encoding_idx(strtype, encoding_idx) -> int32
Set index of the string encoding in the string type.

strtype: (C++: int32)

encoding_idx: (C++: int)
def set_str_type(*args) ‑> void: set_str_type(ea, x)
ea: ea_t

x: uint32
def set_switch_info(*args) ‑> void: set_switch_info(ea, _in)
ea: ea_t

in: switch_info_t const &
def set_switch_parent(*args) ‑> void: set_switch_parent(ea, x)
ea: ea_t

x: ea_t
def set_terse_struc(*args) ‑> void: set_terse_struc(ea)
ea: ea_t
def set_tilcmt(*args) ‑> void: set_tilcmt(ea)
ea: ea_t
def set_tinfo(*args) ‑> bool: set_tinfo(ea, tif) -> bool
ea: ea_t

tif: tinfo_t const *
def set_type_determined_by_hexrays(*args) ‑> void: set_type_determined_by_hexrays(ea)
ea: ea_t
def set_type_guessed_by_ida(*args) ‑> void: set_type_guessed_by_ida(ea)
ea: ea_t
def set_usemodsp(*args) ‑> void: set_usemodsp(ea)
ea: ea_t
def set_usersp(*args) ‑> void: set_usersp(ea)
ea: ea_t
def set_userti(*args) ‑> void: set_userti(ea)
ea: ea_t
def set_visible_item(*args) ‑> void: set_visible_item(ea, visible)
Change visibility of item at given ea.

ea: (C++: ea_t)

visible: (C++: bool)
def set_zstroff(*args) ‑> void: set_zstroff(ea)
ea: ea_t
def switch_info_t__from_ptrval__(*args) ‑> switch_info_t *: switch_info_t__from_ptrval__(ptrval) -> switch_info_t
ptrval: size_t
def unhide_border(*args) ‑> void: unhide_border(ea)
ea: ea_t
def unhide_item(*args) ‑> void: unhide_item(ea)
ea: ea_t
def upd_abits(*args) ‑> void: upd_abits(ea, clr_bits, set_bits)
ea: ea_t

clr_bits: aflags_t

set_bits: aflags_t
def uses_aflag_modsp(*args) ‑> bool: uses_aflag_modsp(flags) -> bool
flags: aflags_t
def uses_modsp(*args) ‑> bool: uses_modsp(ea) -> bool
ea: ea_t
def validate_idb_names(*args) ‑> int: validate_idb_names(do_repair) -> int
do_repair: bool

Classes

class array_parameters_t (*args)

Proxy of C++ array_parameters_t class.

__init__(self, _f=0x00000001, _l=0, _a=-1) -> array_parameters_t

_f: int32

_l: int32

_a: int32

Instance variables

var alignment: -1 - don't align. 0 - align automatically. else item width
var flags: flags
var lineitems: number of items on a line

Methods

def is_default(self, *args) ‑> bool: is_default(self) -> bool

class custom_data_type_ids_fids_array (*args)

Proxy of C++ wrapped_array_t< int16,8 > class.

__init__(self, data) -> custom_data_type_ids_fids_array

data: short (&)[8]

Instance variables

var bytes : bytevec_t: _get_bytes(self) -> bytevec_t
var data: data

class custom_data_type_ids_t (*args)

Proxy of C++ custom_data_type_ids_t class.

__init__(self) -> custom_data_type_ids_t

Instance variables

var dtid: data type id
var fids : wrapped_array_t< int16,8 >: data format ids

Methods

def get_dtid(self, *args) ‑> tid_t: get_dtid(self) -> tid_t
def set(self, *args) ‑> void: set(self, tid)
tid: tid_t

class enum_const_t (*args)

Proxy of C++ enum_const_t class.

__init__(self) -> enum_const_t

Instance variables

var serial: serial
var tid: tid

class opinfo_t (*args)

Proxy of C++ opinfo_t class.

__init__(self) -> opinfo_t

Instance variables

var cd: for custom data
var ec: for enums
var path: for stroff
var ri: for offset members
var strtype: for strings (String type codes)
var tid: for struct, etc. members

class printop_t (*args)

Proxy of C++ printop_t class.

__init__(self) -> printop_t

Instance variables

var aflags: aflags
var features: features
var flags: flags
var is_ti_valid : bool: is_ti_initialized(self) -> bool
var suspop: suspop
var ti: ti

Methods

def get_ti(self, *args) ‑> opinfo_t const *: get_ti(self) -> opinfo_t
def is_aflags_initialized(self, *args) ‑> bool: is_aflags_initialized(self) -> bool
def is_f64(self, *args) ‑> bool: is_f64(self) -> bool
def is_ti_initialized(self, *args) ‑> bool: is_ti_initialized(self) -> bool
def set_aflags_initialized(self, *args) ‑> void: set_aflags_initialized(self, v=True)
v: bool
def set_ti_initialized(self, *args) ‑> void: set_ti_initialized(self, v=True)
v: bool

class refinfo_t (*args)

Proxy of C++ refinfo_t class.

__init__(self) -> refinfo_t

Instance variables

var base: base of reference (may be BADADDR)
var flags: Reference info flags
var target: reference target (BADADDR-none)
var tdelta: offset from the target

Methods

def init(self, *args) ‑> void: init(self, reft_and_flags, _base=0, _target=BADADDR, _tdelta=0)
reft_and_flags: uint32

_base: ea_t

_target: ea_t

_tdelta: adiff_t
def is_custom(self, *args) ‑> bool: is_custom(self) -> bool
def is_no_ones(self, *args) ‑> bool: is_no_ones(self) -> bool
def is_no_zeros(self, *args) ‑> bool: is_no_zeros(self) -> bool
def is_pastend(self, *args) ‑> bool: is_pastend(self) -> bool
def is_rvaoff(self, *args) ‑> bool: is_rvaoff(self) -> bool
def is_selfref(self, *args) ‑> bool: is_selfref(self) -> bool
def is_signed(self, *args) ‑> bool: is_signed(self) -> bool
def is_subtract(self, *args) ‑> bool: is_subtract(self) -> bool
def is_target_optional(self, *args) ‑> bool: is_target_optional(self) -> bool
< is_reftype_target_optional()
def no_base_xref(self, *args) ‑> bool: no_base_xref(self) -> bool
def set_type(self, *args) ‑> void: set_type(self, rt)
rt: reftype_t
def type(self, *args) ‑> reftype_t: type(self) -> reftype_t

class strpath_ids_array (*args)

Proxy of C++ wrapped_array_t< tid_t,32 > class.

__init__(self, data) -> strpath_ids_array

data: unsigned long long (&)[32]

Instance variables

var bytes : bytevec_t: _get_bytes(self) -> bytevec_t
var data: data

class strpath_t (*args)

Proxy of C++ strpath_t class.

__init__(self) -> strpath_t

Instance variables

var delta: delta
var ids : wrapped_array_t< tid_t,32 >: __getIds(self) -> strpath_ids_array
var len: len

class switch_info_t (*args)

Proxy of C++ switch_info_t class.

__init__(self) -> switch_info_t

Class variables

var SWITCH_INFO_VERSION

Instance variables

var custom: information for custom tables (filled and used by modules)
var defjump: default jump address (BADADDR if no default case)
var elbase: element base
var expr_ea: the address before that the switch expression is in REGNUM. If BADADDR, then the first insn marked as IM_SWITCH after STARTEA is used.
var flags: Switch info flags
var ind_lowcase: ind_lowcase
var jcases: number of entries in the jump table (SWI_INDIRECT)
var jumps: jump table start address
var lowcase : ea_t: the lowest value in cases
var marks: the insns marked as IM_SWITCH. They are used to delete the switch.
var ncases: number of cases (excluding default)
var regdtype: size of the switch expression register as dtype
var regnum: the switch expression as a value of the REGNUM register before the instruction at EXPR_EA. -1 means 'unknown'
var startea: start of the switch idiom
var values : ea_t: values table address (if SWI_SPARSE is set)

Methods

def assign(self, *args) ‑> void: assign(self, other)
other: switch_info_t const &
def clear(self, *args) ‑> void: clear(self)
def get_jrange_vrange(self, *args) ‑> bool: get_jrange_vrange(self, jrange=None, vrange=None) -> bool
get separate parts of the switch

jrange: (C++: range_t *)

vrange: (C++: range_t *)
def get_jtable_element_size(self, *args) ‑> int: get_jtable_element_size(self) -> int
def get_jtable_size(self, *args) ‑> int: get_jtable_size(self) -> int
def get_lowcase(self, *args) ‑> sval_t: get_lowcase(self) -> sval_t
def get_shift(self, *args) ‑> int: get_shift(self) -> int
See SWI_SHIFT_MASK. possible answers: 0..3.
def get_version(self, *args) ‑> int: get_version(self) -> int
def get_vtable_element_size(self, *args) ‑> int: get_vtable_element_size(self) -> int
def has_default(self, *args) ‑> bool: has_default(self) -> bool
def has_elbase(self, *args) ‑> bool: has_elbase(self) -> bool
def is_custom(self, *args) ‑> bool: is_custom(self) -> bool
def is_indirect(self, *args) ‑> bool: is_indirect(self) -> bool
def is_nolowcase(self, *args) ‑> bool: is_nolowcase(self) -> bool
def is_sparse(self, *args) ‑> bool: is_sparse(self) -> bool
def is_subtract(self, *args) ‑> bool: is_subtract(self) -> bool
def is_user_defined(self, *args) ‑> bool: is_user_defined(self) -> bool
def set_elbase(self, *args) ‑> void: set_elbase(self, base)
base: ea_t
def set_expr(self, *args) ‑> void: set_expr(self, r, dt)
r: int

dt: op_dtype_t
def set_jtable_element_size(self, *args) ‑> void: set_jtable_element_size(self, size)
size: int
def set_jtable_size(self, *args) ‑> void: set_jtable_size(self, size)
size: int
def set_shift(self, *args) ‑> void: set_shift(self, shift)
See SWI_SHIFT_MASK.

shift: (C++: int)
def set_vtable_element_size(self, *args) ‑> void: set_vtable_element_size(self, size)
size: int
def use_std_table(self, *args) ‑> bool: use_std_table(self) -> bool