Module index

# 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`

  code: toggle sign of the 1st operand

`var AFL_SIGN1`

  code: toggle sign of the 2nd operand

`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 GOTEA_NODE_NAME`

  node containing address of .got section

`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_FRAME`

  function frame type values NSUP_FRAME..NSUP_FRAME+0x10000 are reserved

`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`

  SEG_GRP: pack_dd encoded list of selectors.

`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`

  OMF: group of segments (not used anymore)

`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`

  register argument type/name descriptions values NSUP_REGARG..NSUP_REGARG+0x1000 are reserved

`var NSUP_REGVAR`

  register variables. values NSUP_REGVAR..NSUP_REGVAR+0x1000 are reserved

`var NSUP_REPCMT`

  repeatable comment

`var NSUP_SEGTRANS`

  segment translations

`var NSUP_STROFF0`

  stroff: struct path for the first operand

`var NSUP_STROFF1`

  stroff: struct path for the second operand

`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 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_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 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_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 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(encname: char const *)`

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

  @param encname: (C++: const char *) the encoding name @return: its index (1-based); -1 means error

`def clr__bnot0(ea: ea_t)`

  clr__bnot0(ea)

  @param ea: ea_t

`def clr__bnot1(ea: ea_t)`

  clr__bnot1(ea)

  @param ea: ea_t

`def clr__invsign0(ea: ea_t)`

  clr__invsign0(ea)

  @param ea: ea_t

`def clr__invsign1(ea: ea_t)`

  clr__invsign1(ea)

  @param ea: ea_t

`def clr_abits(ea: ea_t, bits: aflags_t)`

  clr_abits(ea, bits)

  @param ea: ea_t @param bits: aflags_t

`def clr_align_flow(ea: ea_t)`

  clr_align_flow(ea)

  @param ea: ea_t

`def clr_colored_item(ea: ea_t)`

  clr_colored_item(ea)

  @param ea: ea_t

`def clr_fixed_spd(ea: ea_t)`

  clr_fixed_spd(ea)

  @param ea: ea_t

`def clr_has_lname(ea: ea_t)`

  clr_has_lname(ea)

  @param ea: ea_t

`def clr_has_ti(ea: ea_t)`

  clr_has_ti(ea)

  @param ea: ea_t

`def clr_has_ti0(ea: ea_t)`

  clr_has_ti0(ea)

  @param ea: ea_t

`def clr_has_ti1(ea: ea_t)`

  clr_has_ti1(ea)

  @param ea: ea_t

`def clr_libitem(ea: ea_t)`

  clr_libitem(ea)

  @param ea: ea_t

`def clr_lzero0(ea: ea_t)`

  clr_lzero0(ea)

  @param ea: ea_t

`def clr_lzero1(ea: ea_t)`

  clr_lzero1(ea)

  @param ea: ea_t

`def clr_noret(ea: ea_t)`

  clr_noret(ea)

  @param ea: ea_t

`def clr_notcode(ea: ea_t)`

  clr_notcode(ea) Clear not-code mark.

  @param ea: (C++: ea_t)

`def clr_notproc(ea: ea_t)`

  clr_notproc(ea)

  @param ea: ea_t

`def clr_retfp(ea: ea_t)`

  clr_retfp(ea)

  @param ea: ea_t

`def clr_terse_struc(ea: ea_t)`

  clr_terse_struc(ea)

  @param ea: ea_t

`def clr_tilcmt(ea: ea_t)`

  clr_tilcmt(ea)

  @param ea: ea_t

`def clr_usemodsp(ea: ea_t)`

  clr_usemodsp(ea)

  @param ea: ea_t

`def clr_usersp(ea: ea_t)`

  clr_usersp(ea)

  @param ea: ea_t

`def clr_userti(ea: ea_t)`

  clr_userti(ea)

  @param ea: ea_t

`def clr_zstroff(ea: ea_t)`

  clr_zstroff(ea)

  @param ea: ea_t

`def dbg_get_input_path()`

  dbg_get_input_path() -> str Get debugger input file name/path (see LFLG_DBG_NOPATH)

`def del_absbase(ea: ea_t)`

  del_absbase(ea)

  @param ea: ea_t

`def del_aflags(ea: ea_t)`

  del_aflags(ea)

  @param ea: ea_t

`def del_alignment(ea: ea_t)`

  del_alignment(ea)

  @param ea: ea_t

`def del_array_parameters(ea: ea_t)`

  del_array_parameters(ea)

  @param ea: ea_t

`def del_custom_data_type_ids(ea: ea_t)`

  del_custom_data_type_ids(ea)

  @param ea: ea_t

`def del_encoding(idx: int) ‑> 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.

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

`def del_ind_purged(ea: ea_t)`

  del_ind_purged(ea)

  @param ea: ea_t

`def del_item_color(ea: ea_t)`

  del_item_color(ea) -> bool

  @param ea: ea_t

`def del_op_tinfo(ea: ea_t, n: int)`

  del_op_tinfo(ea, n)

  @param ea: ea_t @param n: int

`def del_refinfo(ea: ea_t, n: int)`

  del_refinfo(ea, n) -> bool

  @param ea: ea_t @param n: int

`def del_source_linnum(ea: ea_t)`

  del_source_linnum(ea)

  @param ea: ea_t

`def del_str_type(ea: ea_t)`

  del_str_type(ea)

  @param ea: ea_t

`def del_switch_info(ea: ea_t)`

  del_switch_info(ea)

  @param ea: ea_t

`def del_switch_parent(ea: ea_t)`

  del_switch_parent(ea)

  @param ea: ea_t

`def del_tinfo(ea: ea_t)`

  del_tinfo(ea)

  @param ea: ea_t

`def delete_imports()`

  delete_imports() Delete all imported modules information.

`def ea2node(ea: ea_t)`

  ea2node(ea) -> nodeidx_t Get netnode for the specified address.

  @param ea: (C++: ea_t)

`def encoding_from_strtype(strtype: int32)`

  encoding_from_strtype(strtype) -> char const * Get encoding name for this strtype @retval nullptr: if STRTYPE has an incorrect encoding index @retval empty: string if the encoding was deleted

  @param strtype: (C++: int32)

`def end_ea2node(ea: ea_t)`

  end_ea2node(ea) -> nodeidx_t

  @param ea: ea_t

`def enum_import_names(mod_index: int, py_cb: PyObject *)`

  enum_import_names(mod_index, py_cb) -> int Enumerate imports from a specific module. Please refer to list_imports.py example.

  @param mod_index: The module index @param 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(name: char const *)`

  find_custom_refinfo(name) -> int Get id of a custom refinfo type.

  @param name: (C++: const char *) char const *

`def get_abi_name()`
`def get_absbase(ea: ea_t)`

  get_absbase(ea) -> ea_t

  @param ea: ea_t

`def get_aflags(ea: ea_t)`

  get_aflags(ea) -> aflags_t

  @param ea: ea_t

`def get_alignment(ea: ea_t)`

  get_alignment(ea) -> uint32

  @param ea: ea_t

`def get_archive_path()`

  get_archive_path() -> str Get archive file path from which input file was extracted.

`def get_array_parameters(out: array_parameters_t, ea: ea_t)`

  get_array_parameters(out, ea) -> ssize_t

  @param out: array_parameters_t * @param ea: ea_t

`def get_asm_inc_file()`

  get_asm_inc_file() -> str Get name of the include file.

`def get_custom_data_type_ids(cdis: custom_data_type_ids_t, ea: ea_t)`

  get_custom_data_type_ids(cdis, ea) -> int

  @param cdis: custom_data_type_ids_t * @param ea: ea_t

`def get_custom_refinfo(crid: int)`

  get_custom_refinfo(crid) -> custom_refinfo_handler_t const * Get definition of a registered custom refinfo type.

  @param crid: (C++: int)

`def get_default_encoding_idx(bpu: int) ‑> int`

  get_default_encoding_idx(bpu) -> int Get default encoding index for a specific string type.

  @param 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()`

  get_elapsed_secs() -> size_t Get seconds database stayed open.

`def get_encoding_bpu(idx: int) ‑> 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.

  @param 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(encname: char const *)`

  get_encoding_bpu_by_name(encname) -> int Get the amount of bytes per unit for the given encoding

  @param encname: (C++: const char *) the encoding name @return: the number of bytes per units (1/2/4); -1 means error

`def get_encoding_name(idx: int)`

  get_encoding_name(idx) -> char const * Get encoding name for specific index (1-based).

  @param 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() ‑> int`

  get_encoding_qty() -> int Get total number of encodings (counted from 0)

`def get_gotea()`

  get_gotea() -> ea_t

`def get_ida_notepad_text()`

  get_ida_notepad_text() -> str Get notepad text.

`def get_idb_ctime()`

  get_idb_ctime() -> time_t Get database creation timestamp.

`def get_idb_nopens()`

  get_idb_nopens() -> size_t Get number of times the database is opened.

`def get_ids_modnode()`

  get_ids_modnode() -> netnode Get ids modnode.

`def get_imagebase()`

  get_imagebase() -> ea_t Get image base address.

`def get_import_module_name(mod_index: int)`

  get_import_module_name(mod_index) -> str Returns the name of an imported module given its index

  @param mod_index: int @return: None or the module name

`def get_import_module_qty()`

  get_import_module_qty() -> uint Get number of import modules.

`def get_ind_purged(ea: ea_t)`

  get_ind_purged(ea) -> ea_t

  @param ea: ea_t

`def get_initial_ida_version()`

  get_initial_ida_version() -> str Get version of ida which created the database (string format like "7.5")

`def get_initial_idb_version()`

  get_initial_idb_version() -> ushort Get initial version of the database (numeric format like 700)

`def get_initial_version()`

  get_initial_idb_version() -> ushort Get initial version of the database (numeric format like 700)

`def get_input_file_path()`

  get_input_file_path() -> str Get full path of the input file.

`def get_item_color(ea: ea_t)`

  get_item_color(ea) -> bgcolor_t

  @param ea: ea_t

`def get_loader_format_name()`

  get_loader_format_name() -> str Get file format name for loader modules.

`def get_op_tinfo(tif: tinfo_t, ea: ea_t, n: int)`

  get_op_tinfo(tif, ea, n) -> bool

  @param tif: tinfo_t * @param ea: ea_t @param n: int

`def get_outfile_encoding_idx() ‑> 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(ri: refinfo_t, ea: ea_t, n: int)`

  get_refinfo(ri, ea, n) -> bool

  @param ri: refinfo_t * @param ea: ea_t @param n: int

`def get_reftype_by_size(size: size_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)

  @param size: (C++: size_t)

`def get_root_filename()`

  get_root_filename() -> str Get file name only of the input file.

`def get_source_linnum(ea: ea_t)`

  get_source_linnum(ea) -> uval_t

  @param ea: ea_t

`def get_srcdbg_paths()`

  get_srcdbg_paths() -> str Get source debug paths.

`def get_srcdbg_undesired_paths()`

  get_srcdbg_undesired_paths() -> str Get user-closed source files.

`def get_str_encoding_idx(strtype: int32)`

  get_str_encoding_idx(strtype) -> uchar Get index of the string encoding for this string.

  @param strtype: (C++: int32)

`def get_str_term1(strtype: int32)`

  get_str_term1(strtype) -> char

  @param strtype: int32

`def get_str_term2(strtype: int32)`

  get_str_term2(strtype) -> char

  @param strtype: int32

`def get_str_type(ea: ea_t)`

  get_str_type(ea) -> uint32

  @param ea: ea_t

`def get_str_type_code(strtype: int32)`

  get_str_type_code(strtype) -> uchar

  @param strtype: int32

`def get_str_type_prefix_length(strtype: int32)`

  get_str_type_prefix_length(strtype) -> size_t

  @param strtype: int32

`def get_strid(ea: ea_t)`

  get_strid(ea) -> tid_t

  @param ea: ea_t

`def get_strtype_bpu(strtype: int32)`

  get_strtype_bpu(strtype) -> int

  @param strtype: int32

`def get_switch_info(*args)`
`def get_switch_parent(ea: ea_t)`

  get_switch_parent(ea) -> ea_t

  @param ea: ea_t

`def get_tinfo(tif: tinfo_t, ea: ea_t)`

  get_tinfo(tif, ea) -> bool

  @param tif: tinfo_t * @param ea: ea_t

`def getnode(ea: ea_t)`

  getnode(ea) -> netnode

  @param ea: ea_t

`def has_aflag_linnum(flags: aflags_t)`

  has_aflag_linnum(flags) -> bool

  @param flags: aflags_t

`def has_aflag_lname(flags: aflags_t)`

  has_aflag_lname(flags) -> bool

  @param flags: aflags_t

`def has_aflag_ti(flags: aflags_t)`

  has_aflag_ti(flags) -> bool

  @param flags: aflags_t

`def has_aflag_ti0(flags: aflags_t)`

  has_aflag_ti0(flags) -> bool

  @param flags: aflags_t

`def has_aflag_ti1(flags: aflags_t)`

  has_aflag_ti1(flags) -> bool

  @param flags: aflags_t

`def has_lname(ea: ea_t)`

  has_lname(ea) -> bool

  @param ea: ea_t

`def has_ti(ea: ea_t)`

  has_ti(ea) -> bool

  @param ea: ea_t

`def has_ti0(ea: ea_t)`

  has_ti0(ea) -> bool

  @param ea: ea_t

`def has_ti1(ea: ea_t)`

  has_ti1(ea) -> bool

  @param ea: ea_t

`def hide_border(ea: ea_t)`

  hide_border(ea)

  @param ea: ea_t

`def hide_item(ea: ea_t)`

  hide_item(ea)

  @param ea: ea_t

`def is__bnot0(ea: ea_t)`

  is__bnot0(ea) -> bool

  @param ea: ea_t

`def is__bnot1(ea: ea_t)`

  is__bnot1(ea) -> bool

  @param ea: ea_t

`def is__invsign0(ea: ea_t)`

  is__invsign0(ea) -> bool

  @param ea: ea_t

`def is__invsign1(ea: ea_t)`

  is__invsign1(ea) -> bool

  @param ea: ea_t

`def is_aflag__bnot0(flags: aflags_t)`

  is_aflag__bnot0(flags) -> bool

  @param flags: aflags_t

`def is_aflag__bnot1(flags: aflags_t)`

  is_aflag__bnot1(flags) -> bool

  @param flags: aflags_t

`def is_aflag__invsign0(flags: aflags_t)`

  is_aflag__invsign0(flags) -> bool

  @param flags: aflags_t

`def is_aflag__invsign1(flags: aflags_t)`

  is_aflag__invsign1(flags) -> bool

  @param flags: aflags_t

`def is_aflag_align_flow(flags: aflags_t)`

  is_aflag_align_flow(flags) -> bool

  @param flags: aflags_t

`def is_aflag_colored_item(flags: aflags_t)`

  is_aflag_colored_item(flags) -> bool

  @param flags: aflags_t

`def is_aflag_data_guessed_by_hexrays(flags: aflags_t)`

  is_aflag_data_guessed_by_hexrays(flags) -> bool

  @param flags: aflags_t

`def is_aflag_fixed_spd(flags: aflags_t)`

  is_aflag_fixed_spd(flags) -> bool

  @param flags: aflags_t

`def is_aflag_func_guessed_by_hexrays(flags: aflags_t)`

  is_aflag_func_guessed_by_hexrays(flags) -> bool

  @param flags: aflags_t

`def is_aflag_hidden_border(flags: aflags_t)`

  is_aflag_hidden_border(flags) -> bool

  @param flags: aflags_t

`def is_aflag_hidden_item(flags: aflags_t)`

  is_aflag_hidden_item(flags) -> bool

  @param flags: aflags_t

`def is_aflag_libitem(flags: aflags_t)`

  is_aflag_libitem(flags) -> bool

  @param flags: aflags_t

`def is_aflag_lzero0(flags: aflags_t)`

  is_aflag_lzero0(flags) -> bool

  @param flags: aflags_t

`def is_aflag_lzero1(flags: aflags_t)`

  is_aflag_lzero1(flags) -> bool

  @param flags: aflags_t

`def is_aflag_manual_insn(flags: aflags_t)`

  is_aflag_manual_insn(flags) -> bool

  @param flags: aflags_t

`def is_aflag_noret(flags: aflags_t)`

  is_aflag_noret(flags) -> bool

  @param flags: aflags_t

`def is_aflag_notcode(flags: aflags_t)`

  is_aflag_notcode(flags) -> bool

  @param flags: aflags_t

`def is_aflag_notproc(flags: aflags_t)`

  is_aflag_notproc(flags) -> bool

  @param flags: aflags_t

`def is_aflag_public_name(flags: aflags_t)`

  is_aflag_public_name(flags) -> bool

  @param flags: aflags_t

`def is_aflag_retfp(flags: aflags_t)`

  is_aflag_retfp(flags) -> bool

  @param flags: aflags_t

`def is_aflag_terse_struc(flags: aflags_t)`

  is_aflag_terse_struc(flags) -> bool

  @param flags: aflags_t

`def is_aflag_tilcmt(flags: aflags_t)`

  is_aflag_tilcmt(flags) -> bool

  @param flags: aflags_t

`def is_aflag_type_determined_by_hexrays(flags: aflags_t)`

  is_aflag_type_determined_by_hexrays(flags) -> bool

  @param flags: aflags_t

`def is_aflag_type_guessed_by_hexrays(flags: aflags_t)`

  is_aflag_type_guessed_by_hexrays(flags) -> bool

  @param flags: aflags_t

`def is_aflag_type_guessed_by_ida(flags: aflags_t)`

  is_aflag_type_guessed_by_ida(flags) -> bool

  @param flags: aflags_t

`def is_aflag_usersp(flags: aflags_t)`

  is_aflag_usersp(flags) -> bool

  @param flags: aflags_t

`def is_aflag_userti(flags: aflags_t)`

  is_aflag_userti(flags) -> bool

  @param flags: aflags_t

`def is_aflag_weak_name(flags: aflags_t)`

  is_aflag_weak_name(flags) -> bool

  @param flags: aflags_t

`def is_aflag_zstroff(flags: aflags_t)`

  is_aflag_zstroff(flags) -> bool

  @param flags: aflags_t

`def is_align_flow(ea: ea_t)`

  is_align_flow(ea) -> bool

  @param ea: ea_t

`def is_colored_item(ea: ea_t)`

  is_colored_item(ea) -> bool

  @param ea: ea_t

`def is_data_guessed_by_hexrays(ea: ea_t)`

  is_data_guessed_by_hexrays(ea) -> bool

  @param ea: ea_t

`def is_finally_visible_item(ea: ea_t)`

  is_finally_visible_item(ea) -> bool Is instruction visible?

  @param ea: (C++: ea_t)

`def is_fixed_spd(ea: ea_t)`

  is_fixed_spd(ea) -> bool

  @param ea: ea_t

`def is_func_guessed_by_hexrays(ea: ea_t)`

  is_func_guessed_by_hexrays(ea) -> bool

  @param ea: ea_t

`def is_hidden_border(ea: ea_t)`

  is_hidden_border(ea) -> bool

  @param ea: ea_t

`def is_hidden_item(ea: ea_t)`

  is_hidden_item(ea) -> bool

  @param ea: ea_t

`def is_libitem(ea: ea_t)`

  is_libitem(ea) -> bool

  @param ea: ea_t

`def is_lzero0(ea: ea_t)`

  is_lzero0(ea) -> bool

  @param ea: ea_t

`def is_lzero1(ea: ea_t)`

  is_lzero1(ea) -> bool

  @param ea: ea_t

`def is_noret(ea: ea_t)`

  is_noret(ea) -> bool

  @param ea: ea_t

`def is_notcode(ea: ea_t)`

  is_notcode(ea) -> bool Is the address marked as not-code?

  @param ea: (C++: ea_t)

`def is_notproc(ea: ea_t)`

  is_notproc(ea) -> bool

  @param ea: ea_t

`def is_pascal(strtype: int32)`

  is_pascal(strtype) -> bool

  @param strtype: int32

`def is_reftype_target_optional(type: reftype_t)`

  is_reftype_target_optional(type) -> bool Can the target be calculated using operand value?

  @param type: (C++: reftype_t)

`def is_retfp(ea: ea_t)`

  is_retfp(ea) -> bool

  @param ea: ea_t

`def is_terse_struc(ea: ea_t)`

  is_terse_struc(ea) -> bool

  @param ea: ea_t

`def is_tilcmt(ea: ea_t)`

  is_tilcmt(ea) -> bool

  @param ea: ea_t

`def is_type_determined_by_hexrays(ea: ea_t)`

  is_type_determined_by_hexrays(ea) -> bool

  @param ea: ea_t

`def is_type_guessed_by_hexrays(ea: ea_t)`

  is_type_guessed_by_hexrays(ea) -> bool

  @param ea: ea_t

`def is_type_guessed_by_ida(ea: ea_t)`

  is_type_guessed_by_ida(ea) -> bool

  @param ea: ea_t

`def is_usersp(ea: ea_t)`

  is_usersp(ea) -> bool

  @param ea: ea_t

`def is_userti(ea: ea_t)`

  is_userti(ea) -> bool

  @param ea: ea_t

`def is_visible_item(ea: ea_t)`

  is_visible_item(ea) -> bool Test visibility of item at given ea.

  @param ea: (C++: ea_t)

`def is_zstroff(ea: ea_t)`

  is_zstroff(ea) -> bool

  @param ea: ea_t

`def make_str_type(type_code: uchar, encoding_idx: int, term1: uchar = 0, term2: uchar = 0)`

  make_str_type(type_code, encoding_idx, term1=0, term2=0) -> int32 Get string type for a string in the given encoding.

  @param type_code: (C++: uchar) @param encoding_idx: (C++: int) @param term1: (C++: uchar) @param term2: (C++: uchar)

`def node2ea(ndx: nodeidx_t)`

  node2ea(ndx) -> ea_t

  @param ndx: nodeidx_t

`def rename_encoding(idx: int, encname: char const *)`

  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.

  @param idx: (C++: int) the encoding index (1-based) @param encname: (C++: const char *) the new encoding name

`def retrieve_input_file_crc32()`

  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()`

  retrieve_input_file_md5() -> bytes Get input file md5.

`def retrieve_input_file_sha256()`

  retrieve_input_file_sha256() -> bytes Get input file sha256.

`def retrieve_input_file_size()`

  retrieve_input_file_size() -> size_t Get size of input file in bytes.

`def set__bnot0(ea: ea_t)`

  set__bnot0(ea)

  @param ea: ea_t

`def set__bnot1(ea: ea_t)`

  set__bnot1(ea)

  @param ea: ea_t

`def set__invsign0(ea: ea_t)`

  set__invsign0(ea)

  @param ea: ea_t

`def set__invsign1(ea: ea_t)`

  set__invsign1(ea)

  @param ea: ea_t

`def set_abits(ea: ea_t, bits: aflags_t)`

  set_abits(ea, bits)

  @param ea: ea_t @param bits: aflags_t

`def set_absbase(ea: ea_t, x: ea_t)`

  set_absbase(ea, x)

  @param ea: ea_t @param x: ea_t

`def set_aflags(ea: ea_t, flags: aflags_t)`

  set_aflags(ea, flags)

  @param ea: ea_t @param flags: aflags_t

`def set_align_flow(ea: ea_t)`

  set_align_flow(ea)

  @param ea: ea_t

`def set_alignment(ea: ea_t, x: uint32)`

  set_alignment(ea, x)

  @param ea: ea_t @param x: uint32

`def set_archive_path(file: char const *)`

  set_archive_path(file) -> bool Set archive file path from which input file was extracted.

  @param file: (C++: const char *) char const *

`def set_array_parameters(ea: ea_t, _in: array_parameters_t)`

  set_array_parameters(ea, _in)

  @param ea: ea_t @param in: array_parameters_t const *

`def set_asm_inc_file(file: char const *)`

  set_asm_inc_file(file) -> bool Set name of the include file.

  @param file: (C++: const char *) char const *

`def set_colored_item(ea: ea_t)`

  set_colored_item(ea)

  @param ea: ea_t

`def set_custom_data_type_ids(ea: ea_t, cdis: custom_data_type_ids_t)`

  set_custom_data_type_ids(ea, cdis)

  @param ea: ea_t @param cdis: custom_data_type_ids_t const *

`def set_data_guessed_by_hexrays(ea: ea_t)`

  set_data_guessed_by_hexrays(ea)

  @param ea: ea_t

`def set_default_encoding_idx(bpu: int, idx: int) ‑> bool`

  set_default_encoding_idx(bpu, idx) -> bool Set default encoding for a string type

  @param bpu: (C++: int) the amount of bytes per unit @param idx: (C++: int) the encoding index. It cannot be 0

`def set_fixed_spd(ea: ea_t)`

  set_fixed_spd(ea)

  @param ea: ea_t

`def set_func_guessed_by_hexrays(ea: ea_t)`

  set_func_guessed_by_hexrays(ea)

  @param ea: ea_t

`def set_gotea(gotea: ea_t)`

  set_gotea(gotea)

  @param gotea: ea_t

`def set_has_lname(ea: ea_t)`

  set_has_lname(ea)

  @param ea: ea_t

`def set_has_ti(ea: ea_t)`

  set_has_ti(ea)

  @param ea: ea_t

`def set_has_ti0(ea: ea_t)`

  set_has_ti0(ea)

  @param ea: ea_t

`def set_has_ti1(ea: ea_t)`

  set_has_ti1(ea)

  @param ea: ea_t

`def set_ida_notepad_text(text: char const *, size: size_t = 0)`

  set_ida_notepad_text(text, size=0) Set notepad text.

  @param text: (C++: const char *) char const * @param size: (C++: size_t)

`def set_ids_modnode(id: netnode)`

  set_ids_modnode(id) Set ids modnode.

  @param id: (C++: netnode)

`def set_imagebase(base: ea_t)`

  set_imagebase(base) Set image base address.

  @param base: (C++: ea_t)

`def set_item_color(ea: ea_t, color: bgcolor_t)`

  set_item_color(ea, color)

  @param ea: ea_t @param color: bgcolor_t

`def set_libitem(ea: ea_t)`

  set_libitem(ea)

  @param ea: ea_t

`def set_loader_format_name(name: char const *)`

  set_loader_format_name(name) Set file format name for loader modules.

  @param name: (C++: const char *) char const *

`def set_lzero0(ea: ea_t)`

  set_lzero0(ea)

  @param ea: ea_t

`def set_lzero1(ea: ea_t)`

  set_lzero1(ea)

  @param ea: ea_t

`def set_noret(ea: ea_t)`

  set_noret(ea)

  @param ea: ea_t

`def set_notcode(ea: ea_t)`

  set_notcode(ea) Mark address so that it cannot be converted to instruction.

  @param ea: (C++: ea_t)

`def set_notproc(ea: ea_t)`

  set_notproc(ea)

  @param ea: ea_t

`def set_op_tinfo(ea: ea_t, n: int, tif: tinfo_t)`

  set_op_tinfo(ea, n, tif) -> bool

  @param ea: ea_t @param n: int @param tif: tinfo_t const *

`def set_outfile_encoding_idx(idx: int) ‑> bool`

  set_outfile_encoding_idx(idx) -> bool set encoding to be used when producing files

  @param 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

  @param ea: ea_t @param n: int @param type: reftype_t @param target: ea_t @param base: ea_t @param tdelta: adiff_t

`def set_refinfo_ex(ea: ea_t, n: int, ri: refinfo_t)`

  set_refinfo_ex(ea, n, ri) -> bool

  @param ea: ea_t @param n: int @param ri: refinfo_t const *

`def set_retfp(ea: ea_t)`

  set_retfp(ea)

  @param ea: ea_t

`def set_root_filename(file: char const *)`

  set_root_filename(file) Set full path of the input file.

  @param file: (C++: const char *) char const *

`def set_source_linnum(ea: ea_t, lnnum: uval_t)`

  set_source_linnum(ea, lnnum)

  @param ea: ea_t @param lnnum: uval_t

`def set_srcdbg_paths(paths: char const *)`

  set_srcdbg_paths(paths) Set source debug paths.

  @param paths: (C++: const char *) char const *

`def set_srcdbg_undesired_paths(paths: char const *)`

  set_srcdbg_undesired_paths(paths) Set user-closed source files.

  @param paths: (C++: const char *) char const *

`def set_str_encoding_idx(strtype: int32, encoding_idx: int)`

  set_str_encoding_idx(strtype, encoding_idx) -> int32 Set index of the string encoding in the string type.

  @param strtype: (C++: int32) @param encoding_idx: (C++: int)

`def set_str_type(ea: ea_t, x: uint32)`

  set_str_type(ea, x)

  @param ea: ea_t @param x: uint32

`def set_switch_info(ea: ea_t, _in: switch_info_t)`

  set_switch_info(ea, _in)

  @param ea: ea_t @param in: switch_info_t const &

`def set_switch_parent(ea: ea_t, x: ea_t)`

  set_switch_parent(ea, x)

  @param ea: ea_t @param x: ea_t

`def set_terse_struc(ea: ea_t)`

  set_terse_struc(ea)

  @param ea: ea_t

`def set_tilcmt(ea: ea_t)`

  set_tilcmt(ea)

  @param ea: ea_t

`def set_tinfo(ea: ea_t, tif: tinfo_t)`

  set_tinfo(ea, tif) -> bool

  @param ea: ea_t @param tif: tinfo_t const *

`def set_type_determined_by_hexrays(ea: ea_t)`

  set_type_determined_by_hexrays(ea)

  @param ea: ea_t

`def set_type_guessed_by_ida(ea: ea_t)`

  set_type_guessed_by_ida(ea)

  @param ea: ea_t

`def set_usemodsp(ea: ea_t)`

  set_usemodsp(ea)

  @param ea: ea_t

`def set_usersp(ea: ea_t)`

  set_usersp(ea)

  @param ea: ea_t

`def set_userti(ea: ea_t)`

  set_userti(ea)

  @param ea: ea_t

`def set_visible_item(ea: ea_t, visible: bool)`

  set_visible_item(ea, visible) Change visibility of item at given ea.

  @param ea: (C++: ea_t) @param visible: (C++: bool)

`def set_zstroff(ea: ea_t)`

  set_zstroff(ea)

  @param ea: ea_t

`def switch_info_t__from_ptrval__(ptrval: size_t)`

  switch_info_t__from_ptrval__(ptrval) -> switch_info_t

  @param ptrval: size_t

`def unhide_border(ea: ea_t)`

  unhide_border(ea)

  @param ea: ea_t

`def unhide_item(ea: ea_t)`

  unhide_item(ea)

  @param ea: ea_t

`def upd_abits(ea: ea_t, clr_bits: aflags_t, set_bits: aflags_t)`

  upd_abits(ea, clr_bits, set_bits)

  @param ea: ea_t @param clr_bits: aflags_t @param set_bits: aflags_t

`def uses_aflag_modsp(flags: aflags_t)`

  uses_aflag_modsp(flags) -> bool

  @param flags: aflags_t

`def uses_modsp(ea: ea_t)`

  uses_modsp(ea) -> bool

  @param ea: ea_t

## Classes

`class array_parameters_t`

  Proxy of C++ array_parameters_t class.

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

  @param _f: int32 @param _l: int32 @param _a: int32

  ### Instance variables

  `var alignment : int32`

    -1 - don't align. 0 - align automatically. else item width

  `var flags : int32`

    flags

  `var lineitems : int32`

    number of items on a line

  `var thisown`

    The membership flag

  ### Methods

  `def is_default(self) ‑> bool`

    is_default(self) -> bool

`class custom_data_type_ids_fids_array (data: short (&)[8])`

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

  init(self, data) -> custom_data_type_ids_fids_array

  @param data: short (&)[8]

  ### Instance variables

  `var bytes : bytevec_t`

    _get_bytes(self) -> bytevec_t

  `var data : short (&)[8]`

    data

  `var thisown`

    The membership flag

`class custom_data_type_ids_t`

  Proxy of C++ custom_data_type_ids_t class.

  init(self) -> custom_data_type_ids_t

  ### Instance variables

  `var dtid : int16`

    data type id

  `var fids : wrapped_array_t< int16,8 >`

    data format ids

  `var thisown`

    The membership flag

  ### Methods

  `def get_dtid(self)`

    get_dtid(self) -> tid_t

  `def set(self, tid: tid_t)`

    set(self, tid)

    @param tid: tid_t

`class enum_const_t`

  Proxy of C++ enum_const_t class.

  init(self) -> enum_const_t

  ### Instance variables

  `var serial : uchar`

    serial

  `var thisown`

    The membership flag

  `var tid : tid_t`

    tid

`class opinfo_t`

  Proxy of C++ opinfo_t class.

  init(self) -> opinfo_t

  ### Instance variables

  `var cd : custom_data_type_ids_t`

    for custom data

  `var ec : enum_const_t`

    for enums

  `var path : strpath_t`

    for stroff

  `var ri : refinfo_t`

    for offset members

  `var strtype : int32`

    for strings (String type codes)

  `var thisown`

    The membership flag

  `var tid : tid_t`

    for struct, etc. members

`class printop_t`

  Proxy of C++ printop_t class.

  init(self) -> printop_t

  ### Instance variables

  `var aflags : aflags_t`

    aflags

  `var features : uchar`

    features

  `var flags : flags64_t`

    flags

  `var is_ti_valid : bool`

    is_ti_initialized(self) -> bool

  `var suspop : int`

    suspop

  `var thisown`

    The membership flag

  `var ti : opinfo_t`

    ti

  ### Methods

  `def get_ti(self)`

    get_ti(self) -> opinfo_t

  `def is_aflags_initialized(self) ‑> bool`

    is_aflags_initialized(self) -> bool

  `def is_f64(self) ‑> bool`

    is_f64(self) -> bool

  `def is_ti_initialized(self) ‑> bool`

    is_ti_initialized(self) -> bool

  `def set_aflags_initialized(self, v: bool = True)`

    set_aflags_initialized(self, v=True)

    @param v: bool

  `def set_ti_initialized(self, v: bool = True)`

    set_ti_initialized(self, v=True)

    @param v: bool

`class refinfo_t`

  Proxy of C++ refinfo_t class.

  init(self) -> refinfo_t

  ### Instance variables

  `var base : ea_t`

    base of reference (may be BADADDR)

  `var flags : uint32`

    Reference info flags

  `var target : ea_t`

    reference target (BADADDR-none)

  `var tdelta : adiff_t`

    offset from the target

  `var thisown`

    The membership flag

  ### Methods

  `def init(self, *args)`

    init(self, reft_and_flags, _base=0, _target=BADADDR, _tdelta=0)

    @param reft_and_flags: uint32 @param _base: ea_t @param _target: ea_t @param _tdelta: adiff_t

  `def is_custom(self) ‑> bool`

    is_custom(self) -> bool

  `def is_no_ones(self) ‑> bool`

    is_no_ones(self) -> bool

  `def is_no_zeros(self) ‑> bool`

    is_no_zeros(self) -> bool

  `def is_pastend(self) ‑> bool`

    is_pastend(self) -> bool

  `def is_rvaoff(self) ‑> bool`

    is_rvaoff(self) -> bool

  `def is_selfref(self) ‑> bool`

    is_selfref(self) -> bool

  `def is_signed(self) ‑> bool`

    is_signed(self) -> bool

  `def is_subtract(self) ‑> bool`

    is_subtract(self) -> bool

  `def is_target_optional(self) ‑> bool`

    is_target_optional(self) -> bool < is_reftype_target_optional()

  `def no_base_xref(self) ‑> bool`

    no_base_xref(self) -> bool

  `def set_type(self, rt: reftype_t)`

    set_type(self, rt)

    @param rt: reftype_t

  `def type(self)`

    type(self) -> reftype_t

`class strpath_ids_array (data: unsigned long long (&)[32])`

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

  init(self, data) -> strpath_ids_array

  @param data: unsigned long long (&)[32]

  ### Instance variables

  `var bytes : bytevec_t`

    _get_bytes(self) -> bytevec_t

  `var data : unsigned long long (&)[32]`

    data

  `var thisown`

    The membership flag

`class strpath_t`

  Proxy of C++ strpath_t class.

  init(self) -> strpath_t

  ### Instance variables

  `var delta : adiff_t`

    delta

  `var ids : wrapped_array_t< tid_t,32 >`

    __getIds(self) -> strpath_ids_array

  `var len : int`

    len

  `var thisown`

    The membership flag

`class switch_info_t`

  Proxy of C++ switch_info_t class.

  init(self) -> switch_info_t

  ### Class variables

  `var SWITCH_INFO_VERSION`

  ### Instance variables

  `var custom : uval_t`

    information for custom tables (filled and used by modules)

  `var defjump : ea_t`

    default jump address (BADADDR if no default case)

  `var elbase : ea_t`

    element base

  `var expr_ea : ea_t`

    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 : uint32`

    Switch info flags

  `var ind_lowcase : sval_t`

    ind_lowcase

  `var jcases : int`

    number of entries in the jump table (SWI_INDIRECT)

  `var jumps : ea_t`

    jump table start address

  `var lowcase : ea_t`

    the lowest value in cases

  `var marks : eavec_t`

    the insns marked as IM_SWITCH. They are used to delete the switch.

  `var ncases : ushort`

    number of cases (excluding default)

  `var regdtype : op_dtype_t`

    size of the switch expression register as dtype

  `var regnum : int`

    the switch expression as a value of the REGNUM register before the instruction at EXPR_EA. -1 means 'unknown'

  `var startea : ea_t`

    start of the switch idiom

  `var thisown`

    The membership flag

  `var values : ea_t`

    values table address (if SWI_SPARSE is set)

  ### Methods

  `def assign(self, other: switch_info_t)`

    assign(self, other)

    @param other: switch_info_t const &

  `def clear(self)`

    clear(self)

  `def get_jrange_vrange(self, jrange: range_t = None, vrange: range_t = None)`

    get_jrange_vrange(self, jrange=None, vrange=None) -> bool get separate parts of the switch

    @param jrange: (C++: range_t ) @param vrange: (C++: range_t )

  `def get_jtable_element_size(self) ‑> int`

    get_jtable_element_size(self) -> int

  `def get_jtable_size(self) ‑> int`

    get_jtable_size(self) -> int

  `def get_lowcase(self)`

    get_lowcase(self) -> sval_t

  `def get_shift(self) ‑> int`

    get_shift(self) -> int See SWI_SHIFT_MASK. possible answers: 0..3.

  `def get_version(self) ‑> int`

    get_version(self) -> int

  `def get_vtable_element_size(self) ‑> int`

    get_vtable_element_size(self) -> int

  `def has_default(self) ‑> bool`

    has_default(self) -> bool

  `def has_elbase(self) ‑> bool`

    has_elbase(self) -> bool

  `def is_custom(self) ‑> bool`

    is_custom(self) -> bool

  `def is_indirect(self) ‑> bool`

    is_indirect(self) -> bool

  `def is_nolowcase(self) ‑> bool`

    is_nolowcase(self) -> bool

  `def is_sparse(self) ‑> bool`

    is_sparse(self) -> bool

  `def is_subtract(self) ‑> bool`

    is_subtract(self) -> bool

  `def is_user_defined(self) ‑> bool`

    is_user_defined(self) -> bool

  `def set_elbase(self, base: ea_t)`

    set_elbase(self, base)

    @param base: ea_t

  `def set_expr(self, r: int, dt: op_dtype_t)`

    set_expr(self, r, dt)

    @param r: int @param dt: op_dtype_t

  `def set_jtable_element_size(self, size: int)`

    set_jtable_element_size(self, size)

    @param size: int

  `def set_jtable_size(self, size: int)`

    set_jtable_size(self, size)

    @param size: int

  `def set_shift(self, shift: int)`

    set_shift(self, shift) See SWI_SHIFT_MASK.

    @param shift: (C++: int)

  `def set_vtable_element_size(self, size: int)`

    set_vtable_element_size(self, size)

    @param size: int

  `def use_std_table(self) ‑> bool`

    use_std_table(self) -> bool