Module ida_name

A non-tail address of the program may have a name. Tail addresses (i.e. the addresses in the middle of an instruction or data item) cannot have names.

Global Variables

CN_KEEP_TRAILING__DIGITS

CN_KEEP_TRAILING__DIGITS = 1

DEBNAME_EXACT

DEBNAME_EXACT = 0

DEBNAME_LOWER

DEBNAME_LOWER = 1

DEBNAME_NICE

DEBNAME_NICE = 3

DEBNAME_UPPER

DEBNAME_UPPER = 2

DQT_COMPILER

DQT_COMPILER = 0

DQT_FULL

DQT_FULL = 2

DQT_NAME_TYPE

DQT_NAME_TYPE = 1

DQT_NPURGED_2

DQT_NPURGED_2 = -2

DQT_NPURGED_4

DQT_NPURGED_4 = -4

DQT_NPURGED_8

DQT_NPURGED_8 = -8

FUNC_IMPORT_PREFIX

FUNC_IMPORT_PREFIX = '__imp_'

GETN_APPZERO

GETN_APPZERO = 1

GETN_NODUMMY

GETN_NODUMMY = 4

GETN_NOFIXUP

GETN_NOFIXUP = 2

GNCN_NOCOLOR

GNCN_NOCOLOR = 2

GNCN_NODBGNM

GNCN_NODBGNM = 256

GNCN_NOFUNC

GNCN_NOFUNC = 8

GNCN_NOLABEL

GNCN_NOLABEL = 4

GNCN_NOSEG

GNCN_NOSEG = 1

GNCN_PREFDBG

GNCN_PREFDBG = 512

GNCN_REQFUNC

GNCN_REQFUNC = 64

GNCN_REQNAME

GNCN_REQNAME = 128

GNCN_SEGNUM

GNCN_SEGNUM = 32

GNCN_SEG_FUNC

GNCN_SEG_FUNC = 16

GN_COLORED

GN_COLORED = 2

GN_DEMANGLED

GN_DEMANGLED = 4

GN_ISRET

GN_ISRET = 128

GN_LOCAL

GN_LOCAL = 64

GN_LONG

GN_LONG = 32

GN_NOT_DUMMY

GN_NOT_DUMMY = 512

GN_NOT_ISRET

GN_NOT_ISRET = 256

GN_SHORT

GN_SHORT = 16

GN_STRICT

GN_STRICT = 8

GN_VISIBLE

GN_VISIBLE = 1

MANGLED_CODE

MANGLED_CODE = 0

MANGLED_DATA

MANGLED_DATA = 1

MANGLED_UNKNOWN

MANGLED_UNKNOWN = 2

MAXNAMELEN

MAXNAMELEN = 512

ME_ERRAUTO

ME_ERRAUTO = -7

ME_FRAME

ME_FRAME = -5

ME_ILLSTR

ME_ILLSTR = -3

ME_INTERR

ME_INTERR = -1

ME_NOCOMP

ME_NOCOMP = -6

ME_NOERROR_LIMIT

ME_NOERROR_LIMIT = -10

ME_NOHASHMEM

ME_NOHASHMEM = -8

ME_NOSTRMEM

ME_NOSTRMEM = -9

ME_PARAMERR

ME_PARAMERR = -2

ME_SMALLANS

ME_SMALLANS = -4

MNG_CALC_VALID

MNG_CALC_VALID = 1979711488

MNG_COMPILER_MSK

MNG_COMPILER_MSK = 1879048192

MNG_DEFFAR

MNG_DEFFAR = 2

MNG_DEFHUGE

MNG_DEFHUGE = 4

MNG_DEFNEAR

MNG_DEFNEAR = 0

MNG_DEFNEARANY

MNG_DEFNEARANY = 1

MNG_DEFNONE

MNG_DEFNONE = 6

MNG_DEFPTR64

MNG_DEFPTR64 = 5

MNG_DROP_IMP

MNG_DROP_IMP = 8388608

MNG_IGN_ANYWAY

MNG_IGN_ANYWAY = 33554432

MNG_IGN_JMP

MNG_IGN_JMP = 67108864

MNG_LONG_FORM

MNG_LONG_FORM = 104857607

MNG_MOVE_JMP

MNG_MOVE_JMP = 134217728

MNG_NOBASEDT

MNG_NOBASEDT = 128

MNG_NOCALLC

MNG_NOCALLC = 256

MNG_NOCLOSUR

MNG_NOCLOSUR = 32768

MNG_NOCSVOL

MNG_NOCSVOL = 16384

MNG_NODEFINIT

MNG_NODEFINIT = 8

MNG_NOECSU

MNG_NOECSU = 8192

MNG_NOMANAGE

MNG_NOMANAGE = 131072

MNG_NOMODULE

MNG_NOMODULE = 262144

MNG_NOPOSTFC

MNG_NOPOSTFC = 512

MNG_NOPTRTYP

MNG_NOPTRTYP = 7

MNG_NOPTRTYP16

MNG_NOPTRTYP16 = 3

MNG_NORETTYPE

MNG_NORETTYPE = 64

MNG_NOSCTYP

MNG_NOSCTYP = 1024

MNG_NOSTVIR

MNG_NOSTVIR = 4096

MNG_NOTHROW

MNG_NOTHROW = 2048

MNG_NOTYPE

MNG_NOTYPE = 32

MNG_NOUNALG

MNG_NOUNALG = 65536

MNG_NOUNDERSCORE

MNG_NOUNDERSCORE = 16

MNG_PTRMSK

MNG_PTRMSK = 7

MNG_SHORT_FORM

MNG_SHORT_FORM = 245612135

MNG_SHORT_S

MNG_SHORT_S = 1048576

MNG_SHORT_U

MNG_SHORT_U = 2097152

MNG_ZPT_SPACE

MNG_ZPT_SPACE = 4194304

MT_BORLAN

MT_BORLAN = 536870912

MT_CASTING

MT_CASTING = 4194304

MT_CDECL

MT_CDECL = 2

MT_CLRCALL

MT_CLRCALL = 11

MT_CLRCDTOR

MT_CLRCDTOR = 5242880

MT_CONSTR

MT_CONSTR = 2097152

MT_DEFAULT

MT_DEFAULT = 1

MT_DESTR

MT_DESTR = 3145728

MT_DMDCALL

MT_DMDCALL = 12

MT_FASTCALL

MT_FASTCALL = 5

MT_FORTRAN

MT_FORTRAN = 7

MT_GCC3

MT_GCC3 = 1610612736

MT_GNU

MT_GNU = 1342177280

MT_INTERRUPT

MT_INTERRUPT = 9

MT_LOCALNAME

MT_LOCALNAME = 15

MT_MEMBER

MT_MEMBER = 128

MT_MSCOMP

MT_MSCOMP = 268435456

MT_MSFASTCALL

MT_MSFASTCALL = 10

MT_OPERAT

MT_OPERAT = 1048576

MT_OTHER

MT_OTHER = 1073741824

MT_PARMAX

MT_PARMAX = 255

MT_PARSHF

MT_PARSHF = 8

MT_PASCAL

MT_PASCAL = 3

MT_PRIVATE

MT_PRIVATE = 64

MT_PROTECT

MT_PROTECT = 96

MT_PUBLIC

MT_PUBLIC = 32

MT_REGCALL

MT_REGCALL = 14

MT_RTTI

MT_RTTI = 192

MT_STDCALL

MT_STDCALL = 4

MT_SYSCALL

MT_SYSCALL = 8

MT_THISCALL

MT_THISCALL = 6

MT_VECTORCALL

MT_VECTORCALL = 13

MT_VISAGE

MT_VISAGE = 1879048192

MT_VOIDARG

MT_VOIDARG = 130816

MT_VTABLE

MT_VTABLE = 160

MT_WATCOM

MT_WATCOM = 805306368

M_ANONNSP

M_ANONNSP = 33554432

M_AUTOCRT

M_AUTOCRT = 524288

M_CLASS

M_CLASS = 224

M_COMPILER

M_COMPILER = 1879048192

M_DBGNAME

M_DBGNAME = 134217728

M_ELLIPSIS

M_ELLIPSIS = 65536

M_PARMSK

M_PARMSK = 65280

M_PRCMSK

M_PRCMSK = 15

M_SAVEREGS

M_SAVEREGS = 16

M_STATIC

M_STATIC = 131072

M_THUNK

M_THUNK = 16777216

M_TMPLNAM

M_TMPLNAM = 67108864

M_TRUNCATE

M_TRUNCATE = 8388608

M_TYPMASK

M_TYPMASK = 7340032

M_VIRTUAL

M_VIRTUAL = 262144

NT_ABS

NT_ABS = 5

NT_BMASK

NT_BMASK = 8

NT_BYTE

NT_BYTE = 1

NT_ENUM

NT_ENUM = 4

NT_LOCAL

NT_LOCAL = 2

NT_NONE

NT_NONE = 0

NT_REGVAR

NT_REGVAR = 9

NT_SEG

NT_SEG = 6

NT_STKVAR

NT_STKVAR = 3

NT_STROFF

NT_STROFF = 7

SN_AUTO

SN_AUTO = 32

SN_CHECK

SN_CHECK = 0

SN_DELTAIL

SN_DELTAIL = 8192

SN_FORCE

SN_FORCE = 2048

SN_IDBENC

SN_IDBENC = 1024

SN_LOCAL

SN_LOCAL = 512

SN_NOCHECK

SN_NOCHECK = 1

SN_NODUMMY

SN_NODUMMY = 4096

SN_NOLIST

SN_NOLIST = 128

SN_NON_AUTO

SN_NON_AUTO = 64

SN_NON_PUBLIC

SN_NON_PUBLIC = 4

SN_NON_WEAK

SN_NON_WEAK = 16

SN_NOWARN

SN_NOWARN = 256

SN_PUBLIC

SN_PUBLIC = 2

SN_WEAK

SN_WEAK = 8

UCDR_MANGLED

UCDR_MANGLED = 4

UCDR_NAME

UCDR_NAME = 2

UCDR_STRLIT

UCDR_STRLIT = 1

UCDR_TYPE

UCDR_TYPE = 8

VNT_IDENT

VNT_IDENT = 6

VNT_STRLIT

VNT_STRLIT = 1

VNT_TYPE

VNT_TYPE = 8

VNT_UDTMEM

VNT_UDTMEM = 2

VNT_VISIBLE

VNT_VISIBLE = 2

ignore_glabel

ignore_glabel = 4

ignore_llabel

ignore_llabel = 2

ignore_none

ignore_none = 0

ignore_regvar

ignore_regvar = 1

ignore_stkvar

ignore_stkvar = 3

Functions

append_struct_fields(disp: adiff_t *, n: int, path: tid_t const *, flags: flags64_t, delta: adiff_t, appzero: bool) ‑> qstring *, adiff_t *

append_struct_fields(disp, n, path, flags, delta, appzero) -> str Append names of struct fields to a name if the name is a struct name.

disp: (C++: adiff_t *) displacement from the name
n: (C++: int) operand number in which the name appears
path: (C++: const tid_t *) path in the struct. path is an array of id's. maximal length of
            array is MAXSTRUCPATH. the first element of the array is the
            structure id. consecutive elements are id's of used union members
            (if any).
flags: (C++: flags64_t) the input flags. they will be returned if the struct cannot be
             found.
delta: (C++: adiff_t) delta to add to displacement
appzero: (C++: bool) should append a struct field name if the displacement is zero?
return: flags of the innermost struct member or the input flags

calc_gtn_flags(fromaddr, ea)

Calculate flags for get_ea_name() function

fromaddr: the referring address. May be BADADDR.
ea: linear address

return: flags

cleanup_name(ea: ea_t, name: char const *, flags: uint32 = 0) ‑> qstring *

cleanup_name(ea, name, flags=0) -> bool

ea: ea_t
name: char const *
flags: uint32

del_debug_names(ea1: ea_t, ea2: ea_t) ‑> void

del_debug_names(ea1, ea2)

ea1: ea_t
ea2: ea_t

del_global_name(ea: ea_t) ‑> bool

del_global_name(ea) -> bool

ea: ea_t

del_local_name(ea: ea_t) ‑> bool

del_local_name(ea) -> bool

ea: ea_t

demangle_name(name: char const *, disable_mask: uint32, demreq: demreq_type_t = 2) ‑> qstring *

demangle_name(name, disable_mask, demreq=DQT_FULL) -> int32 Demangle a name.

name: (C++: const char *) char const *
disable_mask: (C++: uint32)
demreq: (C++: demreq_type_t) enum demreq_type_t

extract_name(line: char const *, x: int) ‑> qstring *

extract_name(line, x) -> str Extract a name or address from the specified string.

line: (C++: const char *) input string
x: (C++: int) x coordinate of cursor
return: -1 if cannot extract. otherwise length of the name

force_name(ea: ea_t, name: char const *, flags: int = 0) ‑> bool

force_name(ea, name, flags=0) -> bool

ea: ea_t
name: char const *
flags: int

get_colored_demangled_name(ea: ea_t, inhibitor: int32, demform: int, gtn_flags: int = 0) ‑> qstring

get_colored_demangled_name(ea, inhibitor, demform, gtn_flags=0) -> qstring

ea: ea_t
inhibitor: int32
demform: int
gtn_flags: int

get_colored_long_name(ea: ea_t, gtn_flags: int = 0) ‑> qstring

get_colored_long_name(ea, gtn_flags=0) -> qstring

ea: ea_t
gtn_flags: int

get_colored_name(ea: ea_t) ‑> qstring

get_colored_name(ea) -> qstring

ea: ea_t

get_colored_short_name(ea: ea_t, gtn_flags: int = 0) ‑> qstring

get_colored_short_name(ea, gtn_flags=0) -> qstring

ea: ea_t
gtn_flags: int

get_cp_validity(*args) ‑> bool

get_cp_validity(kind, cp, endcp=wchar32_t(-1)) -> bool Is the given codepoint (or range) acceptable in the given context? If 'endcp' is not BADCP, it is considered to be the end of the range: [cp, endcp), and is not included in the range

kind: (C++: ucdr_kind_t) enum ucdr_kind_t
cp: (C++: wchar32_t)
endcp: (C++: wchar32_t)

get_debug_name(ea_ptr: ea_t *, how: debug_name_how_t) ‑> qstring *

get_debug_name(ea_ptr, how) -> str

ea_ptr: ea_t *
how: enum debug_name_how_t

get_debug_name_ea(name: char const *) ‑> ea_t

get_debug_name_ea(name) -> ea_t

name: char const *

get_debug_names(*args) ‑> PyObject *

get_debug_names(names, ea1, ea2)

names: ea_name_vec_t *
ea1: ea_t
ea2: ea_t

get_debug_names(ea1, ea2, return_list=False) -> PyObject

ea1: ea_t
ea2: ea_t
return_list: bool

get_demangled_name(ea: ea_t, inhibitor: int32, demform: int, gtn_flags: int = 0) ‑> qstring

get_demangled_name(ea, inhibitor, demform, gtn_flags=0) -> qstring

ea: ea_t
inhibitor: int32
demform: int
gtn_flags: int

get_ea_name(ea: ea_t, gtn_flags: int = 0) ‑> qstring

get_ea_name(ea, gtn_flags=0) -> qstring Get name at the specified address.

ea: (C++: ea_t) linear address
gtn_flags: (C++: int) how exactly the name should be retrieved. combination of bits
                 for get_ea_name() function. There is a convenience bits
return: success

get_long_name(ea: ea_t, gtn_flags: int = 0) ‑> qstring

get_long_name(ea, gtn_flags=0) -> qstring

ea: ea_t
gtn_flags: int

get_mangled_name_type(name: char const *) ‑> mangled_name_type_t

get_mangled_name_type(name) -> mangled_name_type_t

name: char const *

get_name(ea: ea_t) ‑> qstring

get_name(ea) -> qstring

ea: ea_t

get_name_base_ea(_from: ea_t, to: ea_t) ‑> ea_t

get_name_base_ea(_from, to) -> ea_t Get address of the name used in the expression for the address

from: (C++: ea_t) address of the operand which references to the address
to: (C++: ea_t) the referenced address
return: address of the name used to represent the operand

get_name_color(_from: ea_t, ea: ea_t) ‑> color_t

get_name_color(_from, ea) -> color_t Calculate flags for get_ea_name() function.

Get name color.

from: (C++: ea_t) linear address where the name is used. if not applicable, then
            should be BADADDR. The kernel returns a local name color if the
            reference is within a function, i.e. 'from' and 'ea' belong to the
            same function.
ea: (C++: ea_t) linear address

get_name_ea(_from: ea_t, name: char const *) ‑> ea_t

get_name_ea(_from, name) -> ea_t Get the address of a name. This function resolves a name into an address. It can handle regular global and local names, as well as debugger names.

from: (C++: ea_t) linear address where the name is used. If specified, the local
            labels of the function at the specified address will will be
            checked. BADADDR means that local names won't be consulted.
name: (C++: const char *) any name in the program or nullptr
return: address of the name or BADADDR

get_name_expr(_from: ea_t, n: int, ea: ea_t, off: uval_t, flags: int = 1) ‑> qstring *

get_name_expr(_from, n, ea, off, flags=0x0001) -> ssize_t Convert address to name expression (name with a displacement). This function takes into account fixup information and returns a colored name expression (in the form +/- ). It also knows about structure members and arrays. If the specified address doesn't have a name, a dummy name is generated.

from: (C++: ea_t) linear address of instruction operand or data referring to the
            name. This address will be used to get fixup information, so it
            should point to exact position of the operand in the instruction.
n: (C++: int) number of referencing operand. for data items specify 0
ea: (C++: ea_t) address to convert to name expression
off: (C++: uval_t) the value of name expression. this parameter is used only to check
           that the name expression will have the wanted value. 'off' may be
           equal to BADADDR but this is discouraged because it prohibits
           checks.
flags: (C++: int) Name expression flags
return: < 0 if address is not valid, no segment or other failure. otherwise the
        length of the name expression in characters.

get_name_value(_from: ea_t, name: char const *) ‑> uval_t *

get_name_value(_from, name) -> int Get value of the name. This function knows about: regular names, enums, special segments, etc.

from: (C++: ea_t) linear address where the name is used if not applicable, then
            should be BADADDR
name: (C++: const char *) any name in the program or nullptr
return: Name value result codes

get_nice_colored_name(ea: ea_t, flags: int = 0) ‑> qstring *

get_nice_colored_name(ea, flags=0) -> ssize_t Get a nice colored name at the specified address. Ex:

  • segment:sub+offset

  • segment:sub:local_label

  • segment:label

  • segment:address

  • segment:address+offset

ea: (C++: ea_t) linear address
flags: (C++: int) Nice colored name flags
return: the length of the generated name in bytes.

get_nlist_ea(idx: size_t) ‑> ea_t

get_nlist_ea(idx) -> ea_t Get address from the list at 'idx'.

idx: (C++: size_t)

get_nlist_idx(ea: ea_t) ‑> size_t

get_nlist_idx(ea) -> size_t Get index of the name in the list @warning: returns the closest match. may return idx >= size.

ea: (C++: ea_t)

get_nlist_name(idx: size_t) ‑> char const *

get_nlist_name(idx) -> char const * Get name using idx.

idx: (C++: size_t)

get_nlist_size() ‑> size_t

get_nlist_size() -> size_t Get number of names in the list.

get_short_name(ea: ea_t, gtn_flags: int = 0) ‑> qstring

get_short_name(ea, gtn_flags=0) -> qstring

ea: ea_t
gtn_flags: int

get_visible_name(ea: ea_t, gtn_flags: int = 0) ‑> qstring

get_visible_name(ea, gtn_flags=0) -> qstring

ea: ea_t
gtn_flags: int

hide_name(ea: ea_t) ‑> void

hide_name(ea) Remove name from the list of names

ea: (C++: ea_t) address of the name

is_ident(name: char const *) ‑> bool

is_ident(name) -> bool Is a valid name? (including ::MangleChars)

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

is_ident_cp(cp: wchar32_t) ‑> bool

is_ident_cp(cp) -> bool Can a character appear in a name? (present in ::NameChars or ::MangleChars)

cp: (C++: wchar32_t)

is_in_nlist(ea: ea_t) ‑> bool

is_in_nlist(ea) -> bool Is the name included into the name list?

ea: (C++: ea_t)

is_name_defined_locally(*args) ‑> bool

is_name_defined_locally(pfn, name, ignore_name_def, ea1=BADADDR, ea2=BADADDR) -> bool Is the name defined locally in the specified function?

pfn: (C++: func_t *) pointer to function
name: (C++: const char *) name to check
ignore_name_def: (C++: ignore_name_def_t) which names to ignore when checking
ea1: (C++: ea_t) the starting address of the range inside the function (optional)
ea2: (C++: ea_t) the ending address of the range inside the function (optional)
return: true if the name has been defined

is_public_name(ea: ea_t) ‑> bool

is_public_name(ea) -> bool

ea: ea_t

is_strlit_cp(cp: wchar32_t, specific_ranges: rangeset_crefvec_t const * = None) ‑> bool

is_strlit_cp(cp, specific_ranges=None) -> bool Can a character appear in a string literal (present in ::StrlitChars) If 'specific_ranges' are specified, those will be used instead of the ones corresponding to the current culture (only if ::StrlitChars is configured to use the current culture)

cp: (C++: wchar32_t)
specific_ranges: (C++: const rangeset_crefvec_t *) rangeset_crefvec_t const *

is_uname(name: char const *) ‑> bool

is_uname(name) -> bool Is valid user-specified name? (valid name & !dummy prefix).

name: (C++: const char *) name to test. may be nullptr.
retval 1: yes
retval 0: no

is_valid_cp(cp: wchar32_t, kind: nametype_t, data: void * = None) ‑> bool

is_valid_cp(cp, kind, data=None) -> bool Is the given codepoint acceptable in the given context?

cp: (C++: wchar32_t)
kind: (C++: nametype_t) enum nametype_t
data: (C++: void *)

is_valid_name(name: char const *, cpuregs_permitted: bool) ‑> bool

is_valid_name(name, cpuregs_permitted) -> bool

name: char const *
cpuregs_permitted: bool

is_valid_typename(name: char const *) ‑> bool

is_valid_typename(name) -> bool Is valid type name?

name: (C++: const char *) name to test. may be nullptr.
retval 1: yes
retval 0: no

is_visible_cp(cp: wchar32_t) ‑> bool

is_visible_cp(cp) -> bool Can a character be displayed in a name? (present in ::NameChars)

cp: (C++: wchar32_t)

is_weak_name(ea: ea_t) ‑> bool

is_weak_name(ea) -> bool

ea: ea_t

make_name_auto(ea: ea_t) ‑> bool

make_name_auto(ea) -> bool

ea: ea_t

make_name_non_public(ea: ea_t) ‑> void

make_name_non_public(ea)

ea: ea_t

make_name_non_weak(ea: ea_t) ‑> void

make_name_non_weak(ea)

ea: ea_t

make_name_public(ea: ea_t) ‑> void

make_name_public(ea)

ea: ea_t

make_name_user(ea: ea_t) ‑> bool

make_name_user(ea) -> bool

ea: ea_t

make_name_weak(ea: ea_t) ‑> void

make_name_weak(ea)

ea: ea_t

rebuild_nlist() ‑> void

rebuild_nlist() Rebuild the name list.

reorder_dummy_names() ‑> void

reorder_dummy_names() Renumber dummy names.

set_cp_validity(*args) ‑> void

set_cp_validity(kind, cp, endcp=wchar32_t(-1), valid=True) Mark the given codepoint (or range) as acceptable or unacceptable in the given context If 'endcp' is not BADCP, it is considered to be the end of the range: [cp, endcp), and is not included in the range

kind: (C++: ucdr_kind_t) enum ucdr_kind_t
cp: (C++: wchar32_t)
endcp: (C++: wchar32_t)

set_debug_name(ea: ea_t, name: char const *) ‑> bool

set_debug_name(ea, name) -> bool

ea: ea_t
name: char const *

set_dummy_name(_from: ea_t, ea: ea_t) ‑> bool

set_dummy_name(from, ea) -> bool Give an autogenerated (dummy) name. Autogenerated names have special prefixes (loc...).

from: (C++: ea_t) linear address of the operand which references to the address
ea: (C++: ea_t) linear address
retval 1: ok, dummy name is generated or the byte already had a name
retval 0: failure, invalid address or tail byte

set_name(ea: ea_t, name: char const *, flags: int = 0) ‑> bool

set_name(ea, name, flags=0) -> bool Set or delete name of an item at the specified address. An item can be anything: instruction, function, data byte, word, string, structure, etc... Include name into the list of names.

ea: (C++: ea_t) linear address. do nothing if ea is not valid (return 0). tail bytes
          can't have names.
name: (C++: const char *) new name.

  • nullptr: do nothing (return 0).

  • "" : delete name.

  • otherwise this is a new name. flags: (C++: int) Set name flags. If a bit is not specified, then the corresponding action is not performed and the name will retain the same bits as before calling this function. For new names, default is: non- public, non-weak, non-auto. retval 1: ok, name is changed retval 0: failure, a warning is displayed

show_name(ea: ea_t) ‑> void

show_name(ea) Insert name to the list of names.

ea: (C++: ea_t)

validate_name(name: char const *, type: nametype_t, flags: int = 1) ‑> PyObject *

validate_name(name, type, flags=0x01) -> PyObject Validate a name. If SN_NOCHECK is specified, this function replaces all invalid characters in the name with SUBSTCHAR. However, it will return false if name is valid but not allowed to be an identifier (is a register name).

name: (C++: qstring *) ptr to name. the name will be modified
type: (C++: nametype_t) the type of name we want to validate
flags: (C++: int) see SN_*
return: success

Classes

NearestName(ea_names)

: Utility class to help find the nearest name in a given ea/name dictionary

Methods

  • find(self, ea) Returns a tupple (ea, name, pos) that is the nearest to the passed ea If no name is matched then None is returned

  • update(self, ea_names) Updates the ea/names map

ea_name_t(*args)

: Proxy of C++ ea_name_t class.

__init__(self) -> ea_name_t
__init__(self, _ea, _name) -> ea_name_t

 _ea: ea_t
 _name: qstring const &

Instance variables

  • ea: ea_t ea

  • name: qstring name

ea_name_vec_t(*args)

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

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

 x: qvector< ea_name_t > const &

Methods

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

    _idx: size_t

  • back(self)

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

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

  • clear(self) ‑> void clear(self)

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

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

  • erase(self, *args) ‑> qvector< ea_name_t >::iterator erase(self, it) -> ea_name_t

    it: qvector< ea_name_t >::iterator

    erase(self, first, last) -> ea_name_t

    first: qvector< ea_name_t >::iterator last: qvector< ea_name_t >::iterator

  • extract(self) ‑> ea_name_t * extract(self) -> ea_name_t

  • front(self)

  • grow(self, *args) ‑> void grow(self, x=ea_name_t())

    x: ea_name_t const &

  • inject(self, s: ea_name_t, len: size_t) ‑> void inject(self, s, len)

    s: ea_name_t * len: size_t

  • insert(self, it: ea_name_t, x: ea_name_t) ‑> qvector< ea_name_t >::iterator insert(self, it, x) -> ea_name_t

    it: qvector< ea_name_t >::iterator x: ea_name_t const &

  • pop_back(self) ‑> void pop_back(self)

  • push_back(self, *args) ‑> ea_name_t & push_back(self, x)

    x: ea_name_t const &

    push_back(self) -> ea_name_t

  • qclear(self) ‑> void qclear(self)

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

    cnt: size_t

  • resize(self, *args) ‑> void resize(self, _newsize, x)

    _newsize: size_t x: ea_name_t const &

    resize(self, _newsize)

    _newsize: size_t

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

  • swap(self, r: ea_name_vec_t) ‑> void swap(self, r)

    r: qvector< ea_name_t > &

  • truncate(self) ‑> void truncate(self)

PreviousModule ida_naltNextModule ida_netnode

Last updated