Module index

Module ida_name

Functions that deal with names.
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

var CN_KEEP_TRAILING__DIGITS
CN_KEEP_TRAILING__DIGITS = 1
var DEBNAME_EXACT
find a name at exactly the specified address
var DEBNAME_LOWER
find a name with the address >= the specified address
var DEBNAME_NICE
find a name with the address <= the specified address
var DEBNAME_UPPER
find a name with the address > the specified address
var DQT_COMPILER
DQT_COMPILER = 0
var DQT_FULL
DQT_FULL = 2
var DQT_NAME_TYPE
DQT_NAME_TYPE = 1
var DQT_NPURGED_2
DQT_NPURGED_2 = -2
var DQT_NPURGED_4
DQT_NPURGED_4 = -4
var DQT_NPURGED_8
DQT_NPURGED_8 = -8
var FUNC_IMPORT_PREFIX
Name prefix used by IDA for the imported functions.
var GETN_APPZERO
meaningful only if the name refers to a structure. append a struct field name if the field offset is zero?
var GETN_NODUMMY
do not create a new dummy name but pretend it exists
var GETN_NOFIXUP
ignore the fixup information when producing the name
var GNCN_NOCOLOR
generate an uncolored name
var GNCN_NODBGNM
don't use debug names
var GNCN_NOFUNC
don't generate funcname+... expressions
var GNCN_NOLABEL
don't generate labels
var GNCN_NOSEG
ignore the segment prefix when producing the name
var GNCN_PREFDBG
if using debug names, prefer debug names over function names
var GNCN_REQFUNC
return 0 if the address does not belong to a function
var GNCN_REQNAME
return 0 if the address can only be represented as a hex number
var GNCN_SEGNUM
segment part is displayed as a hex number
var GNCN_SEG_FUNC
generate both segment and function names (default is to omit segment name if a function name is present)
var GN_COLORED
return colored name
var GN_DEMANGLED
return demangled name
var GN_ISRET
for dummy names: use retloc
var GN_LOCAL
try to get local name first; if failed, get global
var GN_LONG
use long form of demangled name
var GN_NOT_DUMMY
do not return a dummy name
var GN_NOT_ISRET
for dummy names: do not use retloc
var GN_SHORT
use short form of demangled name
var GN_STRICT
fail if cannot demangle
var GN_VISIBLE
replace forbidden characters by SUBSTCHAR
var MANGLED_CODE
MANGLED_CODE = 0
var MANGLED_DATA
MANGLED_DATA = 1
var MANGLED_UNKNOWN
MANGLED_UNKNOWN = 2
var MAXNAMELEN
Maximum length of a name in IDA (with the trailing zero)
var ME_ERRAUTO
ME_ERRAUTO = -7
var ME_FRAME
ME_FRAME = -5
var ME_ILLSTR
ME_ILLSTR = -3
var ME_INTERR
ME_INTERR = -1
var ME_NOCOMP
ME_NOCOMP = -6
var ME_NOERROR_LIMIT
ME_NOERROR_LIMIT = -10
var ME_NOHASHMEM
ME_NOHASHMEM = -8
var ME_NOSTRMEM
ME_NOSTRMEM = -9
var ME_PARAMERR
ME_PARAMERR = -2
var ME_SMALLANS
ME_SMALLANS = -4
var MNG_CALC_VALID
MNG_CALC_VALID = 1979711488
var MNG_COMPILER_MSK
MNG_COMPILER_MSK = 1879048192
var MNG_DEFFAR
MNG_DEFFAR = 2
var MNG_DEFHUGE
MNG_DEFHUGE = 4
var MNG_DEFNEAR
MNG_DEFNEAR = 0
var MNG_DEFNEARANY
MNG_DEFNEARANY = 1
var MNG_DEFNONE
MNG_DEFNONE = 6
var MNG_DEFPTR64
MNG_DEFPTR64 = 5
var MNG_DROP_IMP
MNG_DROP_IMP = 8388608
var MNG_IGN_ANYWAY
MNG_IGN_ANYWAY = 33554432
var MNG_IGN_JMP
MNG_IGN_JMP = 67108864
var MNG_LONG_FORM
MNG_LONG_FORM = 104857607
var MNG_MOVE_JMP
MNG_MOVE_JMP = 134217728
var MNG_NOBASEDT
MNG_NOBASEDT = 128
var MNG_NOCALLC
MNG_NOCALLC = 256
var MNG_NOCLOSUR
MNG_NOCLOSUR = 32768
var MNG_NOCSVOL
MNG_NOCSVOL = 16384
var MNG_NODEFINIT
MNG_NODEFINIT = 8
var MNG_NOECSU
MNG_NOECSU = 8192
var MNG_NOMANAGE
MNG_NOMANAGE = 131072
var MNG_NOMODULE
MNG_NOMODULE = 262144
var MNG_NOPOSTFC
MNG_NOPOSTFC = 512
var MNG_NOPTRTYP
MNG_NOPTRTYP = 7
var MNG_NOPTRTYP16
MNG_NOPTRTYP16 = 3
var MNG_NORETTYPE
MNG_NORETTYPE = 64
var MNG_NOSCTYP
MNG_NOSCTYP = 1024
var MNG_NOSTVIR
MNG_NOSTVIR = 4096
var MNG_NOTHROW
MNG_NOTHROW = 2048
var MNG_NOTYPE
MNG_NOTYPE = 32
var MNG_NOUNALG
MNG_NOUNALG = 65536
var MNG_NOUNDERSCORE
MNG_NOUNDERSCORE = 16
var MNG_PTRMSK
MNG_PTRMSK = 7
var MNG_SHORT_FORM
MNG_SHORT_FORM = 245612135
var MNG_SHORT_S
MNG_SHORT_S = 1048576
var MNG_SHORT_U
MNG_SHORT_U = 2097152
var MNG_ZPT_SPACE
MNG_ZPT_SPACE = 4194304
var MT_BORLAN
MT_BORLAN = 536870912
var MT_CASTING
MT_CASTING = 4194304
var MT_CDECL
MT_CDECL = 2
var MT_CLRCALL
MT_CLRCALL = 11
var MT_CLRCDTOR
MT_CLRCDTOR = 5242880
var MT_CONSTR
MT_CONSTR = 2097152
var MT_DEFAULT
MT_DEFAULT = 1
var MT_DESTR
MT_DESTR = 3145728
var MT_DMDCALL
MT_DMDCALL = 12
var MT_FASTCALL
MT_FASTCALL = 5
var MT_FORTRAN
MT_FORTRAN = 7
var MT_GCC3
MT_GCC3 = 1610612736
var MT_GNU
MT_GNU = 1342177280
var MT_INTERRUPT
MT_INTERRUPT = 9
var MT_LOCALNAME
MT_LOCALNAME = 15
var MT_MEMBER
MT_MEMBER = 128
var MT_MSCOMP
MT_MSCOMP = 268435456
var MT_MSFASTCALL
MT_MSFASTCALL = 10
var MT_OPERAT
MT_OPERAT = 1048576
var MT_OTHER
MT_OTHER = 1073741824
var MT_PARMAX
MT_PARMAX = 255
var MT_PARSHF
MT_PARSHF = 8
var MT_PASCAL
MT_PASCAL = 3
var MT_PRIVATE
MT_PRIVATE = 64
var MT_PROTECT
MT_PROTECT = 96
var MT_PUBLIC
MT_PUBLIC = 32
var MT_REGCALL
MT_REGCALL = 14
var MT_RTTI
MT_RTTI = 192
var MT_STDCALL
MT_STDCALL = 4
var MT_SYSCALL
MT_SYSCALL = 8
var MT_THISCALL
MT_THISCALL = 6
var MT_VECTORCALL
MT_VECTORCALL = 13
var MT_VISAGE
MT_VISAGE = 1879048192
var MT_VOIDARG
MT_VOIDARG = 130816
var MT_VTABLE
MT_VTABLE = 160
var MT_WATCOM
MT_WATCOM = 805306368
var M_ANONNSP
M_ANONNSP = 33554432
var M_AUTOCRT
M_AUTOCRT = 524288
var M_CLASS
M_CLASS = 224
var M_COMPILER
M_COMPILER = 1879048192
var M_DBGNAME
M_DBGNAME = 134217728
var M_ELLIPSIS
M_ELLIPSIS = 65536
var M_PARMSK
M_PARMSK = 65280
var M_PRCMSK
M_PRCMSK = 15
var M_SAVEREGS
M_SAVEREGS = 16
var M_STATIC
M_STATIC = 131072
var M_THUNK
M_THUNK = 16777216
var M_TMPLNAM
M_TMPLNAM = 67108864
var M_TRUNCATE
M_TRUNCATE = 8388608
var M_TYPMASK
M_TYPMASK = 7340032
var M_VIRTUAL
M_VIRTUAL = 262144
var NT_ABS
name is absolute symbol (SEG_ABSSYM)
var NT_BMASK
name is a bit group mask name
var NT_BYTE
name is byte name (regular name)
var NT_ENUM
name is symbolic constant
var NT_LOCAL
name is local label
var NT_NONE
name doesn't exist or has no value
var NT_REGVAR
name is a renamed register (*value is idx into pfn->regvars)
var NT_SEG
name is segment or segment register name
var NT_STKVAR
name is stack variable name
var NT_STROFF
name is structure member
var SN_AUTO
if set, make name autogenerated
var SN_CHECK
Fail if the name contains invalid characters.
var SN_DELTAIL
if name cannot be set because of a tail byte, delete the hindering item
var SN_FORCE
if the specified name is already present in the database, try variations with a numerical suffix like "_123"
var SN_IDBENC
the name is given in the IDB encoding; non-ASCII bytes will be decoded accordingly. Specifying SN_IDBENC also implies SN_NODUMMY
var SN_LOCAL
create local name. a function should exist. local names can't be public or weak. also they are not included into the list of names they can't have dummy prefixes.
var SN_NOCHECK
Replace invalid characters silently. If this bit is set, all invalid chars (not in NameChars or MangleChars) will be replaced by '_' List of valid characters is defined in ida.cfg
var SN_NODUMMY
automatically prepend the name with '_' if it begins with a dummy suffix such as 'sub_'. See also SN_IDBENC
var SN_NOLIST
if set, exclude name from the list. if not set, then include the name into the list (however, if other bits are set, the name might be immediately excluded from the list).
var SN_NON_AUTO
if set, make name non-autogenerated
var SN_NON_PUBLIC
if set, make name non-public
var SN_NON_WEAK
if set, make name non-weak
var SN_NOWARN
don't display a warning if failed
var SN_PUBLIC
if set, make name public
var SN_WEAK
if set, make name weak
var UCDR_MANGLED
UCDR_MANGLED = 4
var UCDR_NAME
UCDR_NAME = 2
var UCDR_STRLIT
UCDR_STRLIT = 1
var UCDR_TYPE
UCDR_TYPE = 8
var VNT_IDENT
VNT_IDENT = 6
var VNT_STRLIT
VNT_STRLIT = 1
var VNT_TYPE
VNT_TYPE = 8
var VNT_UDTMEM
VNT_UDTMEM = 2
var VNT_VISIBLE
VNT_VISIBLE = 2
var ignore_glabel
ignore_glabel = 4
var ignore_llabel
ignore_llabel = 2
var ignore_none
ignore_none = 0
var ignore_regvar
ignore_regvar = 1
var ignore_stkvar
ignore_stkvar = 3

Functions

def append_struct_fields(*args) ‑> 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
def calc_gtn_flags(fromaddr, ea)
Calculate flags for get_ea_name() function
fromaddr: the referring address. May be BADADDR.
ea: linear address
return: flags
def cleanup_name(*args) ‑> qstring *
cleanup_name(ea, name, flags=0) -> str
ea: ea_t
name: char const *
flags: uint32
def del_debug_names(*args) ‑> void
del_debug_names(ea1, ea2)
ea1: ea_t
ea2: ea_t
def del_global_name(*args) ‑> bool
del_global_name(ea) -> bool
ea: ea_t
def del_local_name(*args) ‑> bool
del_local_name(ea) -> bool
ea: ea_t
def demangle_name(*args) ‑> qstring *
demangle_name(name, disable_mask, demreq=DQT_FULL) -> str
Demangle a name.
name: (C++: const char *) char const *
disable_mask: (C++: uint32)
demreq: (C++: demreq_type_t) enum demreq_type_t
def extract_name(*args) ‑> 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
def force_name(*args) ‑> bool
force_name(ea, name, flags=0) -> bool
ea: ea_t
name: char const *
flags: int
def get_colored_demangled_name(*args) ‑> qstring
get_colored_demangled_name(ea, inhibitor, demform, gtn_flags=0) -> qstring
ea: ea_t
inhibitor: int32
demform: int
gtn_flags: int
def get_colored_long_name(*args) ‑> qstring
get_colored_long_name(ea, gtn_flags=0) -> qstring
ea: ea_t
gtn_flags: int
def get_colored_name(*args) ‑> qstring
get_colored_name(ea) -> qstring
ea: ea_t
def get_colored_short_name(*args) ‑> qstring
get_colored_short_name(ea, gtn_flags=0) -> qstring
ea: ea_t
gtn_flags: int
def 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)
def get_debug_name(*args) ‑> qstring *
get_debug_name(ea_ptr, how) -> str
ea_ptr: ea_t *
how: enum debug_name_how_t
def get_debug_name_ea(*args) ‑> ea_t
get_debug_name_ea(name) -> ea_t
name: char const *
def 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) -> dict or None
ea1: ea_t
ea2: ea_t
return_list: bool
def get_demangled_name(*args) ‑> qstring
get_demangled_name(ea, inhibitor, demform, gtn_flags=0) -> qstring
ea: ea_t
inhibitor: int32
demform: int
gtn_flags: int
def get_ea_name(*args) ‑> 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
def get_long_name(*args) ‑> qstring
get_long_name(ea, gtn_flags=0) -> qstring
ea: ea_t
gtn_flags: int
def get_mangled_name_type(*args) ‑> mangled_name_type_t
get_mangled_name_type(name) -> mangled_name_type_t
name: char const *
def get_name(*args) ‑> qstring
get_name(ea) -> qstring
ea: ea_t
def get_name_base_ea(*args) ‑> 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
def get_name_color(*args) ‑> 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
def get_name_ea(*args) ‑> 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
def get_name_expr(*args) ‑> qstring *
get_name_expr(_from, n, ea, off, flags=0x0001) -> str
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 <name> +/- <offset>). 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.
def get_name_value(*args) ‑> 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
def get_nice_colored_name(*args) ‑> qstring *
get_nice_colored_name(ea, flags=0) -> str
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.
def get_nlist_ea(*args) ‑> ea_t
get_nlist_ea(idx) -> ea_t
Get address from the list at 'idx'.
idx: (C++: size_t)
def get_nlist_idx(*args) ‑> 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)
def get_nlist_name(*args) ‑> char const *
get_nlist_name(idx) -> char const *
Get name using idx.
idx: (C++: size_t)
def get_nlist_size(*args) ‑> size_t
get_nlist_size() -> size_t
Get number of names in the list.
def get_short_name(*args) ‑> qstring
get_short_name(ea, gtn_flags=0) -> qstring
ea: ea_t
gtn_flags: int
def get_visible_name(*args) ‑> qstring
get_visible_name(ea, gtn_flags=0) -> qstring
ea: ea_t
gtn_flags: int
def hide_name(*args) ‑> void
hide_name(ea)
Remove name from the list of names
ea: (C++: ea_t) address of the name
def is_ident(*args) ‑> bool
is_ident(name) -> bool
Is a valid name? (including ::MangleChars)
name: (C++: const char *) char const *
def is_ident_cp(*args) ‑> bool
is_ident_cp(cp) -> bool
Can a character appear in a name? (present in ::NameChars or ::MangleChars)
cp: (C++: wchar32_t)
def is_in_nlist(*args) ‑> bool
is_in_nlist(ea) -> bool
Is the name included into the name list?
ea: (C++: ea_t)
def 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
def is_public_name(*args) ‑> bool
is_public_name(ea) -> bool
ea: ea_t
def is_strlit_cp(*args) ‑> 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 *
def is_uname(*args) ‑> 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
def is_valid_cp(*args) ‑> 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 *)
def is_valid_name(*args) ‑> bool
is_valid_name(name, cpuregs_permitted) -> bool
name: char const *
cpuregs_permitted: bool
def is_valid_typename(*args) ‑> 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
def is_visible_cp(*args) ‑> bool
is_visible_cp(cp) -> bool
Can a character be displayed in a name? (present in ::NameChars)
cp: (C++: wchar32_t)
def is_weak_name(*args) ‑> bool
is_weak_name(ea) -> bool
ea: ea_t
def make_name_auto(*args) ‑> bool
make_name_auto(ea) -> bool
ea: ea_t
def make_name_non_public(*args) ‑> void
make_name_non_public(ea)
ea: ea_t
def make_name_non_weak(*args) ‑> void
make_name_non_weak(ea)
ea: ea_t
def make_name_public(*args) ‑> void
make_name_public(ea)
ea: ea_t
def make_name_user(*args) ‑> bool
make_name_user(ea) -> bool
ea: ea_t
def make_name_weak(*args) ‑> void
make_name_weak(ea)
ea: ea_t
def rebuild_nlist(*args) ‑> void
rebuild_nlist()
Rebuild the name list.
def reorder_dummy_names(*args) ‑> void
reorder_dummy_names()
Renumber dummy names.
def 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)
def set_debug_name(*args) ‑> bool
set_debug_name(ea, name) -> bool
ea: ea_t
name: char const *
def set_dummy_name(*args) ‑> 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
def set_name(*args) ‑> 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
def show_name(*args) ‑> void
show_name(ea)
Insert name to the list of names.
ea: (C++: ea_t)
def validate_name(*args) ‑> PyObject *
validate_name(name, type, flags=0) -> 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

class NearestName (ea_names)
Utility class to help find the nearest name in a given ea/name dictionary

Methods

def 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
def update(self, ea_names)
Updates the ea/names map
class 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

var ea
ea
var name
name
class 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

def at(self, *args) ‑> ea_name_t const &
at(self, _idx) -> ea_name_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< ea_name_t >::const_iterator
begin(self) -> ea_name_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< ea_name_t >::const_iterator
end(self) -> ea_name_t
def 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
def extract(self, *args) ‑> ea_name_t *
extract(self) -> ea_name_t
def front(self)
def grow(self, *args) ‑> void
grow(self, x=ea_name_t())
x: ea_name_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: ea_name_t *
len: size_t
def insert(self, *args) ‑> qvector< ea_name_t >::iterator
insert(self, it, x) -> ea_name_t
it: qvector< ea_name_t >::iterator
x: ea_name_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> ea_name_t &
push_back(self, x)
x: ea_name_t const &
push_back(self) -> ea_name_t
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t
x: ea_name_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< ea_name_t > &
def truncate(self, *args) ‑> void
truncate(self)