Module index

# Module `ida_netnode`

Functions that provide the lowest level public interface to the database. Namely, we use Btree. To learn more about BTree:

\link{https://en.wikipedia.org/wiki/B-tree}

We do not use Btree directly. Instead, we have another layer built on the top of Btree. Here is a brief explanation of this layer.

An object called "netnode" is modeled on the top of Btree. Each netnode has a unique id: a 32-bit value (64-bit for ida64). Initially there is a trivial mapping of the linear addresses used in the program to netnodes (later this mapping may be modified using ea2node and node2ea functions; this is used for fast database rebasings). If we have additional information about an address (for example, a comment is attached to it), this information is stored in the corresponding netnode. See nalt.hpp to see how the kernel uses netnodes. Also, some netnodes have no corresponding linear address (however, they still have an id). They are used to store information not related to a particular address.

Each netnode may have the following attributes:

- a name: an arbitrary non-empty string, up to 255KB-1 bytes
- a value: arbitrary sized object, max size is MAXSPECSIZE
- altvals: a sparse array of 32-bit values. indexes in this array may be 8-bit or 32-bit values
- supvals: an array of arbitrary sized objects. (size of each object is limited by MAXSPECSIZE) indexes in this array may be 8-bit or 32-bit values
- charvals: a sparse array of 8-bit values. indexes in this array may be 8-bit or 32-bit values
- hashvals: a hash (an associative array). indexes in this array are strings values are arbitrary sized (max size is MAXSPECSIZE)

Initially a new netnode contains no information at all so no disk space is used for it. As you add new information, the netnode grows.

All arrays that are attached to the netnode behave in the same manner. Initially: * all members of altvals/charvals array are zeroes * all members of supvals/hashvals array are undefined

If you need to store objects bigger that MAXSPECSIZE, please note that there are high-level functions to store arbitrary sized objects in supvals. See setblob/getblob and other blob-related functions.

You may use netnodes to store additional information about the program. Limitations on the use of netnodes are the following:

- use netnodes only if you could not find a kernel service to store your type of information
- do not create netnodes with valid identifier names. Use the "$ " prefix (or any other prefix with characters not allowed in the identifiers for the names of your netnodes. Although you will probably not destroy anything by accident, using already defined names for the names of your netnodes is still discouraged.
- you may create as many netnodes as you want (creation of an unnamed netnode does not increase the size of the database). however, since each netnode has a number, creating too many netnodes could lead to the exhaustion of the netnode numbers (the numbering starts at 0xFF000000)
- remember that netnodes are automatically saved to the disk by the kernel.

Advanced info:

In fact a netnode may contain up to 256 arrays of arbitrary sized objects (not only the 4 listed above). Each array has an 8-bit tag. Usually tags are represented by character constants. For example, altvals and supvals are simply 2 of 256 arrays, with the tags 'A' and 'S' respectively.

## Global variables

`var BADNODE`

  A number to represent a bad netnode reference.

`var MAXNAMESIZE`

  Maximum length of a netnode name. WILL BE REMOVED IN THE FUTURE.

`var MAXSPECSIZE`

  Maximum length of strings or objects stored in a supval array element.

`var MAX_NODENAME_SIZE`

  Maximum length of a name. We permit names up to 32KB-1 bytes.

`var atag`

  Array of altvals.

`var htag`

  Array of hashvals.

`var ltag`

  Links between netnodes.

`var ntag`

  Name of netnode.

`var stag`

  Array of supvals.

`var vtag`

  Value of netnode.

## Functions

`def exist(n: netnode) ‑> bool`

  exist(n) -> bool

  @param n: netnode const &

`def netnode_exist(_name: char const *)`

  exist(_name) -> bool Does the netnode with the specified name exist?

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

## Classes

`class netnode (*args)`

  Proxy of C++ netnode class.

  init(self, num=nodeidx_t(-1)) -> netnode

  @param num: nodeidx_t

  init(self, _name, namlen=0, do_create=False) -> netnode

  @param _name: char const * @param namlen: size_t @param do_create: bool

  ### Static methods

  `def exist(_name: char const *)`

    exist(_name) -> bool Does the netnode with the specified name exist?

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

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def altdel(self, *args) ‑> bool`

    altdel(self, alt, tag=atag) -> bool Delete all elements of altval array. This function may be applied to 32-bit and 8-bit altval arrays. This function deletes the whole altval array.

    @param alt: nodeidx_t @param tag: uchar

    @return: success altdel(self) -> bool

  `def altdel_all(self, *args) ‑> bool`

    altdel_all(self, tag=atag) -> bool Delete all elements of the specified altval array. This function may be applied to 32-bit and 8-bit altval arrays. This function deletes the whole altval array.

    @param tag: (C++: uchar) tag of array @return: success

  `def altdel_ea(self, *args) ‑> bool`

    altdel_ea(self, ea, tag=atag) -> bool

    @param ea: ea_t @param tag: uchar

  `def altdel_idx8(self, alt: uchar, tag: uchar)`

    altdel_idx8(self, alt, tag) -> bool

    @param alt: uchar @param tag: uchar

  `def altfirst(self, *args)`

    altfirst(self, tag=atag) -> nodeidx_t Get first existing element of altval array.

    @param tag: (C++: uchar) tag of array @return: index of first existing element of altval array, BADNODE if altval array is empty

  `def altfirst_idx8(self, tag: uchar)`

    altfirst_idx8(self, tag) -> nodeidx_t

    @param tag: uchar

  `def altlast(self, *args)`

    altlast(self, tag=atag) -> nodeidx_t Get last element of altval array.

    @param tag: (C++: uchar) tag of array @return: index of last existing element of altval array, BADNODE if altval array is empty

  `def altlast_idx8(self, tag: uchar)`

    altlast_idx8(self, tag) -> nodeidx_t

    @param tag: uchar

  `def altnext(self, *args)`

    altnext(self, cur, tag=atag) -> nodeidx_t Get next existing element of altval array.

    @param cur: (C++: nodeidx_t) current index @param tag: (C++: uchar) tag of array @return: index of the next existing element of altval array, BADNODE if no more altval array elements exist

  `def altnext_idx8(self, cur: uchar, tag: uchar)`

    altnext_idx8(self, cur, tag) -> nodeidx_t

    @param cur: uchar @param tag: uchar

  `def altprev(self, *args)`

    altprev(self, cur, tag=atag) -> nodeidx_t Get previous existing element of altval array.

    @param cur: (C++: nodeidx_t) current index @param tag: (C++: uchar) tag of array @return: index of the previous existing element of altval array, BADNODE if no more altval array elements exist

  `def altprev_idx8(self, cur: uchar, tag: uchar)`

    altprev_idx8(self, cur, tag) -> nodeidx_t

    @param cur: uchar @param tag: uchar

  `def altset(self, *args) ‑> bool`

    altset(self, alt, value, tag=atag) -> bool Set value of altval array.

    @param alt: (C++: nodeidx_t) index into array of altvals @param value: (C++: nodeidx_t) new value of altval element @param tag: (C++: uchar) tag of array @retval 1: ok @retval 0: failed, normally should not occur

  `def altset_ea(self, *args) ‑> bool`

    altset_ea(self, ea, value, tag=atag) -> bool

    @param ea: ea_t @param value: nodeidx_t @param tag: uchar

  `def altset_idx8(self, alt: uchar, val: nodeidx_t, tag: uchar)`

    altset_idx8(self, alt, val, tag) -> bool

    @param alt: uchar @param val: nodeidx_t @param tag: uchar

  `def altshift(self, *args)`

    altshift(self, _from, to, size, tag=atag) -> size_t Shift the altval array elements. Moves the array elements at (from..from+size) to (to..to+size)

    @param from: (C++: nodeidx_t) @param to: (C++: nodeidx_t) @param size: (C++: nodeidx_t) @param tag: (C++: uchar) @return: number of shifted elements

  `def altval(self, *args)`

    altval(self, alt, tag=atag) -> nodeidx_t Get altval element of the specified array.

    @param alt: (C++: nodeidx_t) index into array of altvals @param tag: (C++: uchar) tag of array. may be omitted @return: value of altval element. nonexistent altval members are returned as zeroes

  `def altval_ea(self, *args)`

    altval_ea(self, ea, tag=atag) -> nodeidx_t

    @param ea: ea_t @param tag: uchar

  `def altval_idx8(self, alt: uchar, tag: uchar)`

    altval_idx8(self, alt, tag) -> nodeidx_t

    @param alt: uchar @param tag: uchar

  `def blobshift(self, _from: nodeidx_t, to: nodeidx_t, size: nodeidx_t, tag: uchar)`

    blobshift(self, _from, to, size, tag) -> size_t Shift the blob array elements. Moves the array elements at (from..from+size) to (to..to+size)

    @param from: (C++: nodeidx_t) @param to: (C++: nodeidx_t) @param size: (C++: nodeidx_t) @param tag: (C++: uchar) @return: number of shifted elements

  `def blobsize(self, _start: nodeidx_t, tag: uchar)`

    blobsize(self, _start, tag) -> size_t Get size of blob.

    @param _start: (C++: nodeidx_t) index of the first supval element used to store blob @param tag: (C++: uchar) tag of supval array @return: number of bytes required to store a blob

  `def blobsize_ea(self, ea: ea_t, tag: uchar)`

    blobsize_ea(self, ea, tag) -> size_t

    @param ea: ea_t @param tag: uchar

  `def chardel(self, alt: nodeidx_t, tag: uchar)`

    chardel(self, alt, tag) -> bool

    @param alt: nodeidx_t @param tag: uchar

  `def chardel_ea(self, ea: ea_t, tag: uchar)`

    chardel_ea(self, ea, tag) -> bool

    @param ea: ea_t @param tag: uchar

  `def chardel_idx8(self, alt: uchar, tag: uchar)`

    chardel_idx8(self, alt, tag) -> bool

    @param alt: uchar @param tag: uchar

  `def charfirst(self, tag: uchar)`

    charfirst(self, tag) -> nodeidx_t

    @param tag: uchar

  `def charfirst_idx8(self, tag: uchar)`

    charfirst_idx8(self, tag) -> nodeidx_t

    @param tag: uchar

  `def charlast(self, tag: uchar)`

    charlast(self, tag) -> nodeidx_t

    @param tag: uchar

  `def charlast_idx8(self, tag: uchar)`

    charlast_idx8(self, tag) -> nodeidx_t

    @param tag: uchar

  `def charnext(self, cur: nodeidx_t, tag: uchar)`

    charnext(self, cur, tag) -> nodeidx_t

    @param cur: nodeidx_t @param tag: uchar

  `def charnext_idx8(self, cur: uchar, tag: uchar)`

    charnext_idx8(self, cur, tag) -> nodeidx_t

    @param cur: uchar @param tag: uchar

  `def charprev(self, cur: nodeidx_t, tag: uchar)`

    charprev(self, cur, tag) -> nodeidx_t

    @param cur: nodeidx_t @param tag: uchar

  `def charprev_idx8(self, cur: uchar, tag: uchar)`

    charprev_idx8(self, cur, tag) -> nodeidx_t

    @param cur: uchar @param tag: uchar

  `def charset(self, alt: nodeidx_t, val: uchar, tag: uchar)`

    charset(self, alt, val, tag) -> bool

    @param alt: nodeidx_t @param val: uchar @param tag: uchar

  `def charset_ea(self, ea: ea_t, val: uchar, tag: uchar)`

    charset_ea(self, ea, val, tag) -> bool

    @param ea: ea_t @param val: uchar @param tag: uchar

  `def charset_idx8(self, alt: uchar, val: uchar, tag: uchar)`

    charset_idx8(self, alt, val, tag) -> bool

    @param alt: uchar @param val: uchar @param tag: uchar

  `def charshift(self, _from: nodeidx_t, to: nodeidx_t, size: nodeidx_t, tag: uchar)`

    charshift(self, _from, to, size, tag) -> size_t

    @param from: nodeidx_t @param to: nodeidx_t @param size: nodeidx_t @param tag: uchar

  `def charval(self, alt: nodeidx_t, tag: uchar)`

    charval(self, alt, tag) -> uchar

    @param alt: nodeidx_t @param tag: uchar

  `def charval_ea(self, ea: ea_t, tag: uchar)`

    charval_ea(self, ea, tag) -> uchar

    @param ea: ea_t @param tag: uchar

  `def charval_idx8(self, alt: uchar, tag: uchar)`

    charval_idx8(self, alt, tag) -> uchar

    @param alt: uchar @param tag: uchar

  `def copyto(self, destnode: netnode, count: nodeidx_t = 1)`

    copyto(self, destnode, count=1) -> size_t

    @param destnode: netnode @param count: nodeidx_t

  `def create(self, *args) ‑> bool`

    create(self, _name, namlen=0) -> bool Create unnamed netnode. @retval 1: ok @retval 0: should not happen, indicates internal error

    @param _name: char const * @param namlen: size_t

    create(self) -> bool

  `def delblob(self, _start: nodeidx_t, tag: uchar)`

    delblob(self, _start, tag) -> int Delete a blob.

    @param _start: (C++: nodeidx_t) index of the first supval element used to store blob @param tag: (C++: uchar) tag of supval array @return: number of deleted supvals

  `def delblob_ea(self, ea: ea_t, tag: uchar)`

    delblob_ea(self, ea, tag) -> int

    @param ea: ea_t @param tag: uchar

  `def delvalue(self) ‑> bool`

    delvalue(self) -> bool Delete value of netnode. @retval 1: ok @retval 0: failed, netnode is bad or other error

  `def eadel(self, ea: ea_t, tag: uchar)`

    eadel(self, ea, tag) -> bool

    @param ea: ea_t @param tag: uchar

  `def eadel_idx8(self, idx: uchar, tag: uchar)`

    eadel_idx8(self, idx, tag) -> bool

    @param idx: uchar @param tag: uchar

  `def eaget(self, ea: ea_t, tag: uchar)`

    eaget(self, ea, tag) -> ea_t

    @param ea: ea_t @param tag: uchar

  `def eaget_idx(self, idx: nodeidx_t, tag: uchar)`

    eaget_idx(self, idx, tag) -> ea_t

    @param idx: nodeidx_t @param tag: uchar

  `def eaget_idx8(self, idx: uchar, tag: uchar)`

    eaget_idx8(self, idx, tag) -> ea_t

    @param idx: uchar @param tag: uchar

  `def easet(self, ea: ea_t, addr: ea_t, tag: uchar)`

    easet(self, ea, addr, tag) -> bool Store/retrieve/delete an address value in the netnode that corresponds to an address.

    @param ea: (C++: ea_t) @param addr: (C++: ea_t) @param tag: (C++: uchar)

  `def easet_idx(self, idx: nodeidx_t, addr: ea_t, tag: uchar)`

    easet_idx(self, idx, addr, tag) -> bool

    @param idx: nodeidx_t @param addr: ea_t @param tag: uchar

  `def easet_idx8(self, idx: uchar, addr: ea_t, tag: uchar)`

    easet_idx8(self, idx, addr, tag) -> bool

    @param idx: uchar @param addr: ea_t @param tag: uchar

  `def end(self) ‑> bool`

    end(self) -> bool Get last netnode in the graph. Sets netnodenumber to the highest existing number. @retval true: ok @retval false: graph is empty

  `def get_name(self)`

    get_name(self) -> ssize_t Get the netnode name.

    @return: -1 if netnode is unnamed (buf is untouched in this case), otherwise the name length

  `def getblob(self, start: nodeidx_t, tag: char)`

    getblob(self, start, tag) -> bytes or None Get blob from a netnode into a qstring* and make sure the string is null- terminated.

    @param start: nodeidx_t @param tag: (C++: uchar) tag of supval array @return: -1 if blob doesn't exist size of string (including terminating null) otherwise

  `def getblob_ea(self, ea: ea_t, tag: char)`

    getblob_ea(self, ea, tag) -> PyObject *

    @param ea: ea_t @param tag: char

  `def getclob(self, start: nodeidx_t, tag: char)`

    getclob(self, start, tag) -> str

    @param start: nodeidx_t @param tag: char

  `def hashdel(self, *args) ‑> bool`

    hashdel(self, idx, tag=htag) -> bool Delete hash element.

    @param idx: (C++: const char *) index into hash @param tag: (C++: uchar) tag of hash. Default: htag @retval true: deleted @retval false: element does not exist

  `def hashdel_all(self, *args) ‑> bool`

    hashdel_all(self, tag=htag) -> bool Delete all elements of hash. This function deletes the whole hash.

    @param tag: (C++: uchar) tag of hash. Default: htag @return: success

  `def hashfirst(self, *args)`

    hashfirst(self, tag=htag) -> ssize_t @see: hashfirst(qstring *buf, uchar tag=htag) const

    @param tag: (C++: uchar)

  `def hashlast(self, *args)`

    hashlast(self, tag=htag) -> ssize_t @see: hashlast(qstring *buf, uchar tag=htag) const

    @param tag: (C++: uchar)

  `def hashnext(self, *args)`

    hashnext(self, idx, tag=htag) -> ssize_t @see: hashnext(qstring buf, const char idx, uchar tag=htag) const

    @param idx: (C++: const char *) char const * @param tag: (C++: uchar)

  `def hashprev(self, *args)`

    hashprev(self, idx, tag=htag) -> ssize_t @see: hashprev(qstring buf, const char idx, uchar tag=htag) const

    @param idx: (C++: const char *) char const * @param tag: (C++: uchar)

  `def hashset(self, *args) ‑> bool`

    hashset(self, idx, value, tag=htag) -> bool Set value of hash element to long value.

    @param idx: (C++: const char *) index into hash @param value: (C++: nodeidx_t) new value of hash element @param tag: (C++: uchar) tag of hash. Default: htag @retval 1: ok @retval 0: should not occur - indicates internal error

  `def hashset_buf(self, *args) ‑> bool`

    hashset_buf(self, idx, py_str, tag=htag) -> bool

    @param idx: char const * @param py_str: PyObject * @param tag: char

  `def hashset_idx(self, *args) ‑> bool`

    hashset_idx(self, idx, value, tag=htag) -> bool

    @param idx: char const * @param value: nodeidx_t @param tag: uchar

  `def hashstr(self, *args)`

    hashstr(self, idx, tag=htag) -> ssize_t @see: hashstr(qstring buf, const char idx, uchar tag=htag) const

    @param idx: (C++: const char *) char const * @param tag: (C++: uchar)

  `def hashstr_buf(self, *args)`

    hashstr_buf(self, idx, tag=htag) -> PyObject

    @param idx: char const * @param tag: char

  `def hashval(self, *args)`

    hashval(self, idx, tag=htag) -> ssize_t Get value of the specified hash element.

    @param idx: (C++: const char *) index into hash @param tag: (C++: uchar) tag of hash. Default: htag @return: -1 if element doesn't exist or idx is nullptr. otherwise returns the value size in bytes

  `def hashval_long(self, *args)`

    hashval_long(self, idx, tag=htag) -> nodeidx_t Get value of the specified hash element.

    @param idx: (C++: const char *) index into hash @param tag: (C++: uchar) tag of hash. Default: htag @return: value of hash element (it should be set using hashset(nodeidx_t)), 0 if the element does not exist

  `def index(self)`

    index(self) -> nodeidx_t

  `def kill(self)`

    kill(self) Delete a netnode with all information attached to it.

  `def long_value(self)`

    long_value(self) -> nodeidx_t

  `def lower_bound(self, *args)`

    lower_bound(self, cur, tag=stag) -> nodeidx_t Get lower bound of existing elements of supval array.

    @param cur: (C++: nodeidx_t) current index @param tag: (C++: uchar) tag of array @return: index of first existing element of supval array >= cur BADNODE if supval array is empty

  `def lower_bound_ea(self, *args)`

    lower_bound_ea(self, ea, tag=stag) -> nodeidx_t

    @param ea: ea_t @param tag: uchar

  `def lower_bound_idx8(self, alt: uchar, tag: uchar)`

    lower_bound_idx8(self, alt, tag) -> nodeidx_t

    @param alt: uchar @param tag: uchar

  `def moveto(self, destnode: netnode, count: nodeidx_t = 1)`

    moveto(self, destnode, count=1) -> size_t

    @param destnode: netnode @param count: nodeidx_t

  `def next(self) ‑> bool`

    next(self) -> bool Get next netnode in the graph. Sets netnodenumber to the next existing number @retval true: ok @retval false: no more netnodes

  `def prev(self) ‑> bool`

    prev(self) -> bool Get prev netnode in the graph. Sets netnodenumber to the previous existing number @retval true: ok @retval false: no more netnodes

  `def rename(self, newname: char const *, namlen: size_t = 0)`

    rename(self, newname, namlen=0) -> bool Rename a netnode.

    @param newname: (C++: const char *) new name of netnode. nullptr or "" means to delete name. names of user-defined netnodes must have the "$ " prefix in order to avoid clashes with program byte names. @param namlen: (C++: size_t) length of new name. if not specified, it will be calculated using strlen() @retval 1: ok @retval 0: failed, newname is already used

  `def set(self, value: void const *)`

    set(self, value) -> bool Set value of netnode.

    @param value: (C++: const void *) pointer to value @return: 1 - ok

  `def set_long(self, x: nodeidx_t)`

    set_long(self, x) -> bool Value of netnode as a long number:

    @param x: (C++: nodeidx_t)

  `def setblob(self, buf: void const *, _start: nodeidx_t, tag: uchar)`

    setblob(self, buf, _start, tag) -> bool Store a blob in a netnode.

    @param buf: (C++: const void *) pointer to blob to save @param _start: (C++: nodeidx_t) @param tag: (C++: uchar) tag of supval array @return: success

  `def setblob_ea(self, buf: void const *, ea: ea_t, tag: uchar)`

    setblob_ea(self, buf, ea, tag) -> bool

    @param buf: void const * @param ea: ea_t @param tag: uchar

  `def start(self) ‑> bool`

    start(self) -> bool Get first netnode in the graph. Sets netnodenumber to the lowest existing number. @retval true: ok @retval false: graph is empty

  `def supdel(self, *args) ‑> bool`

    supdel(self, alt, tag=stag) -> bool Delete all elements of supval array. This function may be applied to 32-bit and 8-bit supval arrays. This function deletes the whole supval array.

    @param alt: nodeidx_t @param tag: uchar

    @return: success supdel(self) -> bool

  `def supdel_all(self, tag: uchar)`

    supdel_all(self, tag) -> bool Delete all elements of the specified supval array. This function may be applied to 32-bit and 8-bit supval arrays. This function deletes the whole supval array.

    @param tag: (C++: uchar) @return: success

  `def supdel_ea(self, *args) ‑> bool`

    supdel_ea(self, ea, tag=stag) -> bool

    @param ea: ea_t @param tag: uchar

  `def supdel_idx8(self, alt: uchar, tag: uchar)`

    supdel_idx8(self, alt, tag) -> bool

    @param alt: uchar @param tag: uchar

  `def supdel_range(self, idx1: nodeidx_t, idx2: nodeidx_t, tag: uchar)`

    supdel_range(self, idx1, idx2, tag) -> int Delete range of elements in the specified supval array. Elements in range [idx1, idx2) will be deleted. @note: This function can also be used to delete a range of altval elements

    @param idx1: (C++: nodeidx_t) first element to delete @param idx2: (C++: nodeidx_t) last element to delete + 1 @param tag: (C++: uchar) tag of array @return: number of deleted elements

  `def supdel_range_idx8(self, idx1: uchar, idx2: uchar, tag: uchar)`

    supdel_range_idx8(self, idx1, idx2, tag) -> int Same as above, but accepts 8-bit indexes.

    @param idx1: (C++: uchar) @param idx2: (C++: uchar) @param tag: (C++: uchar)

  `def supfirst(self, *args)`

    supfirst(self, tag=stag) -> nodeidx_t Get first existing element of supval array.

    @param tag: (C++: uchar) tag of array @return: index of first existing element of supval array, BADNODE if supval array is empty

  `def supfirst_idx8(self, tag: uchar)`

    supfirst_idx8(self, tag) -> nodeidx_t

    @param tag: uchar

  `def suplast(self, *args)`

    suplast(self, tag=stag) -> nodeidx_t Get last existing element of supval array.

    @param tag: (C++: uchar) tag of array @return: index of last existing element of supval array, BADNODE if supval array is empty

  `def suplast_idx8(self, tag: uchar)`

    suplast_idx8(self, tag) -> nodeidx_t

    @param tag: uchar

  `def supnext(self, *args)`

    supnext(self, cur, tag=stag) -> nodeidx_t Get next existing element of supval array.

    @param cur: (C++: nodeidx_t) current index @param tag: (C++: uchar) tag of array @return: index of the next existing element of supval array, BADNODE if no more supval array elements exist

  `def supnext_idx8(self, alt: uchar, tag: uchar)`

    supnext_idx8(self, alt, tag) -> nodeidx_t

    @param alt: uchar @param tag: uchar

  `def supprev(self, *args)`

    supprev(self, cur, tag=stag) -> nodeidx_t Get previous existing element of supval array.

    @param cur: (C++: nodeidx_t) current index @param tag: (C++: uchar) tag of array @return: index of the previous existing element of supval array BADNODE if no more supval array elements exist

  `def supprev_idx8(self, alt: uchar, tag: uchar)`

    supprev_idx8(self, alt, tag) -> nodeidx_t

    @param alt: uchar @param tag: uchar

  `def supset(self, *args) ‑> bool`

    supset(self, alt, value, tag=stag) -> bool Set value of supval array element.

    @param alt: (C++: nodeidx_t) index into array of supvals @param value: (C++: const void *) pointer to supval value @param tag: (C++: uchar) tag of array @retval 1: ok @retval 0: should not occur - indicates internal error

  `def supset_ea(self, *args) ‑> bool`

    supset_ea(self, ea, value, tag=stag) -> bool

    @param ea: ea_t @param value: void const * @param tag: uchar

  `def supset_idx8(self, alt: uchar, value: void const *, tag: uchar)`

    supset_idx8(self, alt, value, tag) -> bool

    @param alt: uchar @param value: void const * @param tag: uchar

  `def supshift(self, *args)`

    supshift(self, _from, to, size, tag=stag) -> size_t Shift the supval array elements. Moves the array elements at (from..from+size) to (to..to+size)

    @param from: (C++: nodeidx_t) @param to: (C++: nodeidx_t) @param size: (C++: nodeidx_t) @param tag: (C++: uchar) @return: number of shifted elements

  `def supstr(self, *args)`

    supstr(self, alt, tag=stag) -> ssize_t @see: supstr(qstring *buf, nodeidx_t alt, uchar tag=stag) const

    @param alt: (C++: nodeidx_t) @param tag: (C++: uchar)

  `def supstr_ea(self, *args)`

    supstr_ea(self, ea, tag=stag) -> ssize_t

    @param ea: ea_t @param tag: uchar

  `def supstr_idx8(self, alt: uchar, tag: uchar)`

    supstr_idx8(self, alt, tag) -> ssize_t

    @param alt: uchar @param tag: uchar

  `def supval(self, *args)`

    supval(self, alt, tag=stag) -> ssize_t Get value of the specified supval array element. NB: do not use this function to retrieve strings, see supstr()!

    @param alt: (C++: nodeidx_t) index into array of supvals @param tag: (C++: uchar) tag of array. Default: stag @return: size of value, -1 if element doesn't exist

  `def supval_ea(self, *args)`

    supval_ea(self, ea, tag=stag) -> ssize_t

    @param ea: ea_t @param tag: uchar

  `def supval_idx8(self, *args)`

    supval_idx8(self, alt, tag) -> ssize_t

    @param alt: uchar @param tag: uchar

  `def valobj(self, *args)`

    valobj(self) -> ssize_t Get value of netnode. Netnode values are arbitrary sized objects with max size is MAXSPECSIZE. NB: do not use this function for strings - see valstr().

    @return: length of value, -1 if no value present

  `def valstr(self)`

    valstr(self) -> ssize_t @see: valstr(qstring *buf) const

  `def value_exists(self) ‑> bool`

    value_exists(self) -> bool