diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..4ee61a2 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Datasource local storage ignored files +/../../../../../:\hkn\project_folder\Gencoding3\.idea/dataSources/ +/dataSources.local.xml +# Editor-based HTTP Client requests +/httpRequests/ diff --git a/.idea/Gencoding3.iml b/.idea/Gencoding3.iml new file mode 100644 index 0000000..68e4e15 --- /dev/null +++ b/.idea/Gencoding3.iml @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000..9622261 --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,24 @@ + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 0000000..105ce2d --- /dev/null +++ b/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..c13a1ac --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..28c88d3 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Genius3/beautified_sample.json b/Genius3/beautified_sample.json new file mode 100644 index 0000000..513ede9 --- /dev/null +++ b/Genius3/beautified_sample.json @@ -0,0 +1,623 @@ +{ + "function_edges": [ + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 0, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26 + ] + ], // 看FCG，所有函数之间连接边的出边函数index和入边函数index + "acfg_list": [ // 对应 data.raw_graph_list + { // 一个CFG对应 data.raw_graph_list[a] + "block_number": 3, // CFG中基本块的个数 √ data.raw_graph_list[a].g.__len__() + "block_edges": [ + [ + 0, + 0, + 1, + 1 + ], + [ + 0, + 2, + 0, + 2 + ] + ], // 中间那个块才是第0块，不知道为什么；第一个数组是所有边的出块号，第二个数组是所有边的入块号 √ data.raw_graph_list[a].g.edges + "block_features": [ // 每个基本块的属性 + [ + 0, + 2, + 1, + 0, + 7, + 0, + 1, + 1, + 4, + 0, + 0 + ], // 每个块的属性特征，属性特征为11维向量，具体是调用/传输/算术/逻辑/比较/移动/终止/数据声明/总指令数/字符串或整数常量/后代的数量 + [ + 0, + 2, + 0, + 0, + 3, + 1, + 0, + 1, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0 + ] + ] + }, + { + "block_number": 29, // CFG中基本块的个数 + "block_edges": [ + [ + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 5, + 6, + 6, + 7, + 7, + 8, + 8, + 9, + 9, + 10, + 10, + 11, + 12, + 12, + 13, + 14, + 14, + 15, + 16, + 17, + 18, + 19, + 19, + 20, + 20, + 21, + 21, + 23, + 24, + 24, + 26, + 26, + 27, + 28 + ], + [ + 16, + 0, + 2, + 0, + 4, + 1, + 3, + 3, + 3, + 25, + 15, + 8, + 6, + 6, + 7, + 28, + 12, + 9, + 23, + 16, + 25, + 11, + 21, + 17, + 13, + 19, + 22, + 14, + 19, + 18, + 27, + 24, + 23, + 26, + 21, + 22, + 25, + 10, + 25, + 5, + 14, + 8 + ] + ], + "block_features": [ + [ + 8, + 2, + 1, + 5, + 36, + 0, + 6, + 0, + 2, + 0, + 0 + ], + [ + 0, + 7, + 0, + 0, + 3, + 0, + 1, + 1, + 1, + 0, + 0 + ], + [ + 0, + 7, + 0, + 0, + 2, + 0, + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 7, + 0, + 1, + 8, + 1, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 7, + 1, + 0, + 2, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 7, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0 + ], + [ + 1, + 18, + 0, + 1, + 9, + 0, + 2, + 1, + 1, + 0, + 0 + ], + [ + 1, + 21, + 1, + 0, + 3, + 0, + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 21, + 0, + 1, + 4, + 1, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 24, + 0, + 2, + 12, + 1, + 3, + 0, + 0, + 0, + 0 + ], + [ + 1, + 26, + 0, + 3, + 16, + 0, + 4, + 1, + 4, + 0, + 0 + ], + [ + 1, + 2, + 0, + 5, + 22, + 0, + 5, + 0, + 1, + 0, + 0 + ], + [ + 5, + 4, + 1, + 3, + 21, + 0, + 4, + 1, + 3, + 0, + 0 + ], + [ + 4, + 11, + 0, + 2, + 17, + 1, + 2, + 0, + 1, + 0, + 0 + ], + [ + 2, + 14, + 0, + 1, + 12, + 0, + 2, + 1, + 1, + 0, + 0 + ], + [ + 3, + 17, + 0, + 0, + 10, + 0, + 1, + 0, + 1, + 0, + 0 + ], + [ + 1, + 1, + 0, + 1, + 5, + 0, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 14, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 3, + 17, + 0, + 0, + 7, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 17, + 0, + 1, + 5, + 0, + 2, + 1, + 1, + 0, + 0 + ], + [ + 2, + 28, + 1, + 1, + 11, + 1, + 2, + 1, + 1, + 0, + 0 + ], + [ + 0, + 11, + 0, + 1, + 8, + 1, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 12, + 27, + 1, + 7, + 41, + 0, + 8, + 1, + 6, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 7, + 1, + 0, + 0, + 0, + 1, + 0 + ], + [ + 2, + 9, + 0, + 2, + 17, + 0, + 3, + 1, + 3, + 0, + 0 + ], + [ + 2, + 14, + 0, + 0, + 5, + 0, + 1, + 0, + 4, + 0, + 0 + ], + [ + 1, + 21, + 4, + 1, + 13, + 0, + 2, + 0, + 5, + 0, + 0 + ] + ] + } + ], + "function_names": [ // 包括外部函数和局部函数的函数名 + "sub_401000", + "start", + "GetTempPathW", + "GetFileSize", + "GetCurrentDirectoryW", + "DeleteFileW", + "CloseHandle", + "WriteFile", + "lstrcmpW", + "ReadFile", + "GetModuleHandleW", + "ExitProcess", + "HeapCreate", + "HeapAlloc", + "GetModuleFileNameW", + "CreateFileW", + "lstrlenW", + "ShellExecuteW", + "wsprintfW", + "HttpSendRequestW", + "InternetSetOptionW", + "InternetQueryOptionW", + "HttpOpenRequestW", + "HttpQueryInfoW", + "InternetReadFile", + "InternetConnectW", + "InternetOpenW" + ], // √ + "hash": "316ebb797d5196020eee013cfe771671fff4da8859adc9f385f52a74e82f4e55", // 文件哈希，可以用文件名中的md5替代 √ + "function_number": 27 // 函数数量 √ +} \ No newline at end of file diff --git a/Genius3/python/idaapi.py b/Genius3/python/idaapi.py index c07de40..1371bee 100644 --- a/Genius3/python/idaapi.py +++ b/Genius3/python/idaapi.py @@ -155,22 +155,34 @@ PLUGIN_KEEP = 2 # PyIdc conversion object IDs PY_ICID_INT64 = 0 -"""int64 object""" +""" +int64 object +""" PY_ICID_BYREF = 1 -"""byref object""" +""" +byref object +""" PY_ICID_OPAQUE = 2 -"""opaque object""" +""" +opaque object +""" # Step trace options (used with set_step_trace_options()) ST_OVER_DEBUG_SEG = 0x01 -"""step tracing will be disabled when IP is in a debugger segment""" +""" +step tracing will be disabled when IP is in a debugger segment +""" ST_OVER_LIB_FUNC = 0x02 -"""step tracing will be disabled when IP is in a library function""" +""" +step tracing will be disabled when IP is in a library function +""" # ----------------------------------------------------------------------- class pyidc_opaque_object_t(object): - """This is the base class for all Python<->IDC opaque objects""" + """ + This is the base class for all Python<->IDC opaque objects + """ __idc_cvt_id__ = PY_ICID_OPAQUE # ----------------------------------------------------------------------- @@ -186,17 +198,23 @@ class py_clinked_object_t(pyidc_opaque_object_t): self.__clink__ = lnk if lnk else self._create_clink() def __del__(self): - """Delete the link upon object destruction (only if not static)""" + """ + Delete the link upon object destruction (only if not static) + """ self._free() def _free(self): - """Explicitly delete the link (only if not static)""" + """ + Explicitly delete the link (only if not static) + """ if not self.__static_clink__ and self.__clink__ is not None: self._del_clink(self.__clink__) self.__clink__ = None def copy(self): - """Returns a new copy of this class""" + """ + Returns a new copy of this class + """ # Create an unlinked instance inst = self.__class__() @@ -240,30 +258,42 @@ class py_clinked_object_t(pyidc_opaque_object_t): pass clink = property(lambda self: self.__clink__) - """Returns the C link as a PyObject""" + """ + Returns the C link as a PyObject + """ clink_ptr = property(lambda self: self._get_clink_ptr()) - """Returns the C link pointer as a number""" + """ + Returns the C link pointer as a number + """ # ----------------------------------------------------------------------- class object_t(object): - """Helper class used to initialize empty objects""" + """ + Helper class used to initialize empty objects + """ def __init__(self, **kwds): self.__dict__ = kwds def __getitem__(self, idx): - """Allow access to object attributes by index (like dictionaries)""" + """ + Allow access to object attributes by index (like dictionaries) + """ return getattr(self, idx) # ----------------------------------------------------------------------- def _bounded_getitem_iterator(self): - """Helper function, to be set as __iter__ method for qvector-, or array-based classes.""" + """ + Helper function, to be set as __iter__ method for qvector-, or array-based classes. + """ for i in range(len(self)): yield self[i] # ----------------------------------------------------------------------- class plugin_t(pyidc_opaque_object_t): - """Base class for all scripted plugins.""" + """ + Base class for all scripted plugins. + """ pass # ----------------------------------------------------------------------- @@ -286,7 +316,9 @@ class pyidc_cvt_helper__(object): # ----------------------------------------------------------------------- class PyIdc_cvt_int64__(pyidc_cvt_helper__): - """Helper class for explicitly representing VT_INT64 values""" + """ + Helper class for explicitly representing VT_INT64 values + """ def __init__(self, v): # id = 0 = int64 object @@ -357,33 +389,47 @@ class _qstrvec_t(py_clinked_object_t): return _idaapi.qstrvec_t_get_clink_ptr(self) def assign(self, other): - """Copies the contents of 'other' to 'self'""" + """ + Copies the contents of 'other' to 'self' + """ return _idaapi.qstrvec_t_assign(self, other) def __setitem__(self, idx, s): - """Sets string at the given index""" + """ + Sets string at the given index + """ return _idaapi.qstrvec_t_set(self, idx, s) def __getitem__(self, idx): - """Gets the string at the given index""" + """ + Gets the string at the given index + """ return _idaapi.qstrvec_t_get(self, idx) def __get_size(self): return _idaapi.qstrvec_t_size(self) size = property(__get_size) - """Returns the count of elements""" + """ + Returns the count of elements + """ def addressof(self, idx): - """Returns the address (as number) of the qstring at the given index""" + """ + Returns the address (as number) of the qstring at the given index + """ return _idaapi.qstrvec_t_addressof(self, idx) def add(self, s): - """Add a string to the vector""" + """ + Add a string to the vector + """ return _idaapi.qstrvec_t_add(self, s) def from_list(self, lst): - """Populates the vector from a Python string list""" + """ + Populates the vector from a Python string list + """ return _idaapi.qstrvec_t_from_list(self, lst) def clear(self, qclear=False): @@ -394,22 +440,30 @@ class _qstrvec_t(py_clinked_object_t): return _idaapi.qstrvec_t_clear(self, qclear) def insert(self, idx, s): - """Insert a string into the vector""" + """ + Insert a string into the vector + """ return _idaapi.qstrvec_t_insert(self, idx, s) def remove(self, idx): - """Removes a string from the vector""" + """ + Removes a string from the vector + """ return _idaapi.qstrvec_t_remove(self, idx) # ----------------------------------------------------------------------- class PyIdc_cvt_refclass__(pyidc_cvt_helper__): - """Helper class for representing references to immutable objects""" + """ + Helper class for representing references to immutable objects + """ def __init__(self, v): # id = one = byref object super(self.__class__, self).__init__(PY_ICID_BYREF, v) def cstr(self): - """Returns the string as a C string (up to the zero termination)""" + """ + Returns the string as a C string (up to the zero termination) + """ return as_cstr(self.value) # ----------------------------------------------------------------------- @@ -426,18 +480,24 @@ def as_cstr(val): # ----------------------------------------------------------------------- def as_unicode(s): - """Convenience function to convert a string into appropriate unicode format""" + """ + Convenience function to convert a string into appropriate unicode format + """ # use UTF16 big/little endian, depending on the environment? return unicode(s).encode("UTF-16" + ("BE" if _idaapi.cvar.inf.mf else "LE")) # ----------------------------------------------------------------------- def as_uint32(v): - """Returns a number as an unsigned int32 number""" + """ + Returns a number as an unsigned int32 number + """ return v & 0xffffffff # ----------------------------------------------------------------------- def as_int32(v): - """Returns a number as a signed int32 number""" + """ + Returns a number as a signed int32 number + """ return -((~v & 0xffffffff)+1) # ----------------------------------------------------------------------- @@ -607,7 +667,9 @@ def IDAPython_UnLoadProcMod(script, g): # ---------------------------------------------------------------------- class __IDAPython_Completion_Util(object): - """Internal utility class for auto-completion support""" + """ + Internal utility class for auto-completion support + """ def __init__(self): self.n = 0 self.completion = None @@ -677,7 +739,7 @@ class __IDAPython_Completion_Util(object): return s -# Instantiate an IDAPython command completion object (for use with IDA's CLI bar) +# Instantiate a completion object IDAPython_Completion = __IDAPython_Completion_Util() def _listify_types(*classes): @@ -693,15 +755,25 @@ def _listify_types(*classes): # In the case of NW_OPENIDB, the callback is: # def notify_when_callback(nw_code, is_old_database) NW_OPENIDB = 0x0001 -"""Notify when the database is opened. Its callback is of the form: def notify_when_callback(nw_code, is_old_database)""" +""" +Notify when the database is opened. Its callback is of the form: def notify_when_callback(nw_code, is_old_database) +""" NW_CLOSEIDB = 0x0002 -"""Notify when the database is closed. Its callback is of the form: def notify_when_callback(nw_code)""" +""" +Notify when the database is closed. Its callback is of the form: def notify_when_callback(nw_code) +""" NW_INITIDA = 0x0004 -"""Notify when the IDA starts. Its callback is of the form: def notify_when_callback(nw_code)""" +""" +Notify when the IDA starts. Its callback is of the form: def notify_when_callback(nw_code) +""" NW_TERMIDA = 0x0008 -"""Notify when the IDA terminates. Its callback is of the form: def notify_when_callback(nw_code)""" +""" +Notify when the IDA terminates. Its callback is of the form: def notify_when_callback(nw_code) +""" NW_REMOVE = 0x0010 -"""Use this flag with other flags to uninstall a notifywhen callback""" +""" +Use this flag with other flags to uninstall a notifywhen callback +""" # @@ -711,7 +783,9 @@ MAXSTR = _idaapi.MAXSTR __MF__ = _idaapi.__MF__ def qatoll(*args): - """qatoll(nptr) -> int64""" + """ + qatoll(nptr) -> int64 + """ return _idaapi.qatoll(*args) FMT_64 = _idaapi.FMT_64 FMT_Z = _idaapi.FMT_Z @@ -719,34 +793,50 @@ FMT_ZS = _idaapi.FMT_ZS FMT_EA = _idaapi.FMT_EA def qexit(*args): - """qexit(code)""" + """ + qexit(code) + """ return _idaapi.qexit(*args) def extend_sign(*args): - """extend_sign(v, nbytes, sign_extend) -> uint64""" + """ + extend_sign(v, nbytes, sign_extend) -> uint64 + """ return _idaapi.extend_sign(*args) def readbytes(*args): - """readbytes(h, res, size, mf) -> int""" + """ + readbytes(h, res, size, mf) -> int + """ return _idaapi.readbytes(*args) def writebytes(*args): - """writebytes(h, l, size, mf) -> int""" + """ + writebytes(h, l, size, mf) -> int + """ return _idaapi.writebytes(*args) def reloc_value(*args): - """reloc_value(value, size, delta, mf)""" + """ + reloc_value(value, size, delta, mf) + """ return _idaapi.reloc_value(*args) def qvector_reserve(*args): - """qvector_reserve(vec, old, cnt, elsize) -> void *""" + """ + qvector_reserve(vec, old, cnt, elsize) -> void * + """ return _idaapi.qvector_reserve(*args) class ida_true_type(object): - """Proxy of C++ ida_true_type class""" + """ + Proxy of C++ ida_true_type class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> ida_true_type""" + def __init__(self, *args): + """ + __init__(self) -> ida_true_type + """ this = _idaapi.new_ida_true_type(*args) try: self.this.append(this) except: self.this = this @@ -756,11 +846,15 @@ ida_true_type_swigregister = _idaapi.ida_true_type_swigregister ida_true_type_swigregister(ida_true_type) class ida_false_type(object): - """Proxy of C++ ida_false_type class""" + """ + Proxy of C++ ida_false_type class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> ida_false_type""" + def __init__(self, *args): + """ + __init__(self) -> ida_false_type + """ this = _idaapi.new_ida_false_type(*args) try: self.this.append(this) except: self.this = this @@ -777,13 +871,17 @@ def check_type_trait(*args): """ return _idaapi.check_type_trait(*args) class qrefcnt_obj_t(object): - """Proxy of C++ qrefcnt_obj_t class""" + """ + Proxy of C++ qrefcnt_obj_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr refcnt = _swig_property(_idaapi.qrefcnt_obj_t_refcnt_get, _idaapi.qrefcnt_obj_t_refcnt_set) def release(self, *args): - """release(self)""" + """ + release(self) + """ return _idaapi.qrefcnt_obj_t_release(self, *args) __swig_destroy__ = _idaapi.delete_qrefcnt_obj_t @@ -793,49 +891,69 @@ qrefcnt_obj_t_swigregister(qrefcnt_obj_t) def relocate_relobj(*args): - """relocate_relobj(_relobj, ea, mf) -> bool""" + """ + relocate_relobj(_relobj, ea, mf) -> bool + """ return _idaapi.relocate_relobj(*args) def replace_tabs(*args): - """replace_tabs(str, tabsize) -> bool""" + """ + replace_tabs(out, str, tabsize) -> bool + """ return _idaapi.replace_tabs(*args) def get_utf8_char(*args): - """get_utf8_char(pptr) -> wchar32_t""" + """ + get_utf8_char(pptr) -> wchar32_t + """ return _idaapi.get_utf8_char(*args) def convert_encoding(*args): - """convert_encoding(fromcode, tocode, indata, out, flags=0) -> int""" + """ + convert_encoding(fromcode, tocode, indata, out, flags=0) -> int + """ return _idaapi.convert_encoding(*args) CP_UTF8 = _idaapi.CP_UTF8 CP_UTF16 = _idaapi.CP_UTF16 class channel_redir_t(object): - """Proxy of C++ channel_redir_t class""" + """ + Proxy of C++ channel_redir_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr fd = _swig_property(_idaapi.channel_redir_t_fd_get, _idaapi.channel_redir_t_fd_set) file = _swig_property(_idaapi.channel_redir_t_file_get, _idaapi.channel_redir_t_file_set) flags = _swig_property(_idaapi.channel_redir_t_flags_get, _idaapi.channel_redir_t_flags_set) def is_input(self, *args): - """is_input(self) -> bool""" + """ + is_input(self) -> bool + """ return _idaapi.channel_redir_t_is_input(self, *args) def is_output(self, *args): - """is_output(self) -> bool""" + """ + is_output(self) -> bool + """ return _idaapi.channel_redir_t_is_output(self, *args) def is_append(self, *args): - """is_append(self) -> bool""" + """ + is_append(self) -> bool + """ return _idaapi.channel_redir_t_is_append(self, *args) def is_quoted(self, *args): - """is_quoted(self) -> bool""" + """ + is_quoted(self) -> bool + """ return _idaapi.channel_redir_t_is_quoted(self, *args) start = _swig_property(_idaapi.channel_redir_t_start_get, _idaapi.channel_redir_t_start_set) length = _swig_property(_idaapi.channel_redir_t_length_get, _idaapi.channel_redir_t_length_set) - def __init__(self, *args): - """__init__(self) -> channel_redir_t""" + def __init__(self, *args): + """ + __init__(self) -> channel_redir_t + """ this = _idaapi.new_channel_redir_t(*args) try: self.this.append(this) except: self.this = this @@ -851,22 +969,32 @@ IOREDIR_QUOTED = _idaapi.IOREDIR_QUOTED def expand_argv(*args): - """expand_argv(p_argc, argc, argv) -> char **""" + """ + expand_argv(p_argc, argc, argv) -> char ** + """ return _idaapi.expand_argv(*args) def free_argv(*args): - """free_argv(argc, argv)""" + """ + free_argv(argc, argv) + """ return _idaapi.free_argv(*args) def quote_cmdline_arg(*args): - """quote_cmdline_arg(arg) -> bool""" + """ + quote_cmdline_arg(arg) -> bool + """ return _idaapi.quote_cmdline_arg(*args) def parse_dbgopts(*args): - """parse_dbgopts(ido, r_switch) -> bool""" + """ + parse_dbgopts(ido, r_switch) -> bool + """ return _idaapi.parse_dbgopts(*args) class instant_dbgopts_t(object): - """Proxy of C++ instant_dbgopts_t class""" + """ + Proxy of C++ instant_dbgopts_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr debmod = _swig_property(_idaapi.instant_dbgopts_t_debmod_get, _idaapi.instant_dbgopts_t_debmod_set) @@ -877,8 +1005,10 @@ class instant_dbgopts_t(object): pid = _swig_property(_idaapi.instant_dbgopts_t_pid_get, _idaapi.instant_dbgopts_t_pid_set) event_id = _swig_property(_idaapi.instant_dbgopts_t_event_id_get, _idaapi.instant_dbgopts_t_event_id_set) attach = _swig_property(_idaapi.instant_dbgopts_t_attach_get, _idaapi.instant_dbgopts_t_attach_set) - def __init__(self, *args): - """__init__(self) -> instant_dbgopts_t""" + def __init__(self, *args): + """ + __init__(self) -> instant_dbgopts_t + """ this = _idaapi.new_instant_dbgopts_t(*args) try: self.this.append(this) except: self.this = this @@ -888,34 +1018,42 @@ instant_dbgopts_t_swigregister = _idaapi.instant_dbgopts_t_swigregister instant_dbgopts_t_swigregister(instant_dbgopts_t) -def qwait_timed(*args): - """qwait_timed(child, status, flags, timeout_ms) -> int""" - return _idaapi.qwait_timed(*args) - def check_process_exit(*args): - """check_process_exit(handle, exit_code, msecs=-1) -> int""" + """ + check_process_exit(handle, exit_code, msecs=-1) -> int + """ return _idaapi.check_process_exit(*args) TCT_UNKNOWN = _idaapi.TCT_UNKNOWN TCT_OWNER = _idaapi.TCT_OWNER TCT_NOT_OWNER = _idaapi.TCT_NOT_OWNER def is_control_tty(*args): - """is_control_tty(fd) -> tty_control_t""" + """ + is_control_tty(fd) -> tty_control_t + """ return _idaapi.is_control_tty(*args) def qdetach_tty(*args): - """qdetach_tty()""" + """ + qdetach_tty() + """ return _idaapi.qdetach_tty(*args) def qcontrol_tty(*args): - """qcontrol_tty()""" + """ + qcontrol_tty() + """ return _idaapi.qcontrol_tty(*args) class __qthread_t(object): - """Proxy of C++ __qthread_t class""" + """ + Proxy of C++ __qthread_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> __qthread_t""" + def __init__(self, *args): + """ + __init__(self) -> __qthread_t + """ this = _idaapi.new___qthread_t(*args) try: self.this.append(this) except: self.this = this @@ -926,14 +1064,20 @@ __qthread_t_swigregister(__qthread_t) def is_main_thread(*args): - """is_main_thread() -> bool""" + """ + is_main_thread() -> bool + """ return _idaapi.is_main_thread(*args) class __qsemaphore_t(object): - """Proxy of C++ __qsemaphore_t class""" + """ + Proxy of C++ __qsemaphore_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> __qsemaphore_t""" + def __init__(self, *args): + """ + __init__(self) -> __qsemaphore_t + """ this = _idaapi.new___qsemaphore_t(*args) try: self.this.append(this) except: self.this = this @@ -943,11 +1087,15 @@ __qsemaphore_t_swigregister = _idaapi.__qsemaphore_t_swigregister __qsemaphore_t_swigregister(__qsemaphore_t) class __qmutex_t(object): - """Proxy of C++ __qmutex_t class""" + """ + Proxy of C++ __qmutex_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> __qmutex_t""" + def __init__(self, *args): + """ + __init__(self) -> __qmutex_t + """ this = _idaapi.new___qmutex_t(*args) try: self.this.append(this) except: self.this = this @@ -957,11 +1105,15 @@ __qmutex_t_swigregister = _idaapi.__qmutex_t_swigregister __qmutex_t_swigregister(__qmutex_t) class qmutex_locker_t(object): - """Proxy of C++ qmutex_locker_t class""" + """ + Proxy of C++ qmutex_locker_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, _lock) -> qmutex_locker_t""" + def __init__(self, *args): + """ + __init__(self, _lock) -> qmutex_locker_t + """ this = _idaapi.new_qmutex_locker_t(*args) try: self.this.append(this) except: self.this = this @@ -972,29 +1124,41 @@ qmutex_locker_t_swigregister(qmutex_locker_t) def qsplitpath(*args): - """qsplitpath(path, dir, file) -> char *""" + """ + qsplitpath(path, dir, file) -> char * + """ return _idaapi.qsplitpath(*args) def init_process(*args): - """init_process(lpi, errbuf) -> void *""" + """ + init_process(lpi, errbuf) -> void * + """ return _idaapi.init_process(*args) def vinterr(*args): - """vinterr(file, line, format, va)""" + """ + vinterr(file, line, format, va) + """ return _idaapi.vinterr(*args) def strlwr(*args): - """strlwr(s) -> char *""" + """ + strlwr(s) -> char * + """ return _idaapi.strlwr(*args) def strupr(*args): - """strupr(s) -> char *""" + """ + strupr(s) -> char * + """ return _idaapi.strupr(*args) class uvalvec_t(object): - """Proxy of C++ qvector<(uval_t)> class""" + """ + Proxy of C++ qvector<(uval_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> uvalvec_t __init__(self, x) -> uvalvec_t @@ -1012,19 +1176,27 @@ class uvalvec_t(object): return _idaapi.uvalvec_t_push_back(self, *args) def pop_back(self, *args): - """pop_back(self)""" + """ + pop_back(self) + """ return _idaapi.uvalvec_t_pop_back(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.uvalvec_t_size(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.uvalvec_t_empty(self, *args) def at(self, *args): - """at(self, _idx) -> unsigned int const &""" + """ + at(self, _idx) -> unsigned int const & + """ return _idaapi.uvalvec_t_at(self, *args) def front(self, *args): @@ -1042,11 +1214,15 @@ class uvalvec_t(object): return _idaapi.uvalvec_t_back(self, *args) def qclear(self, *args): - """qclear(self)""" + """ + qclear(self) + """ return _idaapi.uvalvec_t_qclear(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.uvalvec_t_clear(self, *args) def resize(self, *args): @@ -1057,35 +1233,51 @@ class uvalvec_t(object): return _idaapi.uvalvec_t_resize(self, *args) def capacity(self, *args): - """capacity(self) -> size_t""" + """ + capacity(self) -> size_t + """ return _idaapi.uvalvec_t_capacity(self, *args) def reserve(self, *args): - """reserve(self, cnt)""" + """ + reserve(self, cnt) + """ return _idaapi.uvalvec_t_reserve(self, *args) def truncate(self, *args): - """truncate(self)""" + """ + truncate(self) + """ return _idaapi.uvalvec_t_truncate(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.uvalvec_t_swap(self, *args) def extract(self, *args): - """extract(self) -> unsigned int *""" + """ + extract(self) -> unsigned int * + """ return _idaapi.uvalvec_t_extract(self, *args) def inject(self, *args): - """inject(self, s, len)""" + """ + inject(self, s, len) + """ return _idaapi.uvalvec_t_inject(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.uvalvec_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.uvalvec_t___ne__(self, *args) def begin(self, *args): @@ -1103,7 +1295,9 @@ class uvalvec_t(object): return _idaapi.uvalvec_t_end(self, *args) def insert(self, *args): - """insert(self, it, x) -> qvector< unsigned int >::iterator""" + """ + insert(self, it, x) -> qvector< unsigned int >::iterator + """ return _idaapi.uvalvec_t_insert(self, *args) def erase(self, *args): @@ -1121,27 +1315,39 @@ class uvalvec_t(object): return _idaapi.uvalvec_t_find(self, *args) def has(self, *args): - """has(self, x) -> bool""" + """ + has(self, x) -> bool + """ return _idaapi.uvalvec_t_has(self, *args) def add_unique(self, *args): - """add_unique(self, x) -> bool""" + """ + add_unique(self, x) -> bool + """ return _idaapi.uvalvec_t_add_unique(self, *args) def _del(self, *args): - """_del(self, x) -> bool""" + """ + _del(self, x) -> bool + """ return _idaapi.uvalvec_t__del(self, *args) def __len__(self, *args): - """__len__(self) -> size_t""" + """ + __len__(self) -> size_t + """ return _idaapi.uvalvec_t___len__(self, *args) def __getitem__(self, *args): - """__getitem__(self, i) -> unsigned int const &""" + """ + __getitem__(self, i) -> unsigned int const & + """ return _idaapi.uvalvec_t___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, i, v)""" + """ + __setitem__(self, i, v) + """ return _idaapi.uvalvec_t___setitem__(self, *args) __iter__ = _bounded_getitem_iterator @@ -1150,10 +1356,12 @@ uvalvec_t_swigregister = _idaapi.uvalvec_t_swigregister uvalvec_t_swigregister(uvalvec_t) class intvec_t(object): - """Proxy of C++ qvector<(int)> class""" + """ + Proxy of C++ qvector<(int)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> intvec_t __init__(self, x) -> intvec_t @@ -1171,19 +1379,27 @@ class intvec_t(object): return _idaapi.intvec_t_push_back(self, *args) def pop_back(self, *args): - """pop_back(self)""" + """ + pop_back(self) + """ return _idaapi.intvec_t_pop_back(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.intvec_t_size(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.intvec_t_empty(self, *args) def at(self, *args): - """at(self, _idx) -> int const &""" + """ + at(self, _idx) -> int const & + """ return _idaapi.intvec_t_at(self, *args) def front(self, *args): @@ -1201,11 +1417,15 @@ class intvec_t(object): return _idaapi.intvec_t_back(self, *args) def qclear(self, *args): - """qclear(self)""" + """ + qclear(self) + """ return _idaapi.intvec_t_qclear(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.intvec_t_clear(self, *args) def resize(self, *args): @@ -1216,39 +1436,57 @@ class intvec_t(object): return _idaapi.intvec_t_resize(self, *args) def grow(self, *args): - """grow(self, x=int())""" + """ + grow(self, x=int()) + """ return _idaapi.intvec_t_grow(self, *args) def capacity(self, *args): - """capacity(self) -> size_t""" + """ + capacity(self) -> size_t + """ return _idaapi.intvec_t_capacity(self, *args) def reserve(self, *args): - """reserve(self, cnt)""" + """ + reserve(self, cnt) + """ return _idaapi.intvec_t_reserve(self, *args) def truncate(self, *args): - """truncate(self)""" + """ + truncate(self) + """ return _idaapi.intvec_t_truncate(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.intvec_t_swap(self, *args) def extract(self, *args): - """extract(self) -> int *""" + """ + extract(self) -> int * + """ return _idaapi.intvec_t_extract(self, *args) def inject(self, *args): - """inject(self, s, len)""" + """ + inject(self, s, len) + """ return _idaapi.intvec_t_inject(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.intvec_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.intvec_t___ne__(self, *args) def begin(self, *args): @@ -1266,7 +1504,9 @@ class intvec_t(object): return _idaapi.intvec_t_end(self, *args) def insert(self, *args): - """insert(self, it, x) -> qvector< int >::iterator""" + """ + insert(self, it, x) -> qvector< int >::iterator + """ return _idaapi.intvec_t_insert(self, *args) def erase(self, *args): @@ -1284,27 +1524,39 @@ class intvec_t(object): return _idaapi.intvec_t_find(self, *args) def has(self, *args): - """has(self, x) -> bool""" + """ + has(self, x) -> bool + """ return _idaapi.intvec_t_has(self, *args) def add_unique(self, *args): - """add_unique(self, x) -> bool""" + """ + add_unique(self, x) -> bool + """ return _idaapi.intvec_t_add_unique(self, *args) def _del(self, *args): - """_del(self, x) -> bool""" + """ + _del(self, x) -> bool + """ return _idaapi.intvec_t__del(self, *args) def __len__(self, *args): - """__len__(self) -> size_t""" + """ + __len__(self) -> size_t + """ return _idaapi.intvec_t___len__(self, *args) def __getitem__(self, *args): - """__getitem__(self, i) -> int const &""" + """ + __getitem__(self, i) -> int const & + """ return _idaapi.intvec_t___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, i, v)""" + """ + __setitem__(self, i, v) + """ return _idaapi.intvec_t___setitem__(self, *args) __iter__ = _bounded_getitem_iterator @@ -1313,10 +1565,12 @@ intvec_t_swigregister = _idaapi.intvec_t_swigregister intvec_t_swigregister(intvec_t) class boolvec_t(object): - """Proxy of C++ qvector<(bool)> class""" + """ + Proxy of C++ qvector<(bool)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> boolvec_t __init__(self, x) -> boolvec_t @@ -1334,19 +1588,27 @@ class boolvec_t(object): return _idaapi.boolvec_t_push_back(self, *args) def pop_back(self, *args): - """pop_back(self)""" + """ + pop_back(self) + """ return _idaapi.boolvec_t_pop_back(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.boolvec_t_size(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.boolvec_t_empty(self, *args) def at(self, *args): - """at(self, _idx) -> bool const &""" + """ + at(self, _idx) -> bool const & + """ return _idaapi.boolvec_t_at(self, *args) def front(self, *args): @@ -1364,11 +1626,15 @@ class boolvec_t(object): return _idaapi.boolvec_t_back(self, *args) def qclear(self, *args): - """qclear(self)""" + """ + qclear(self) + """ return _idaapi.boolvec_t_qclear(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.boolvec_t_clear(self, *args) def resize(self, *args): @@ -1379,39 +1645,57 @@ class boolvec_t(object): return _idaapi.boolvec_t_resize(self, *args) def grow(self, *args): - """grow(self, x=bool())""" + """ + grow(self, x=bool()) + """ return _idaapi.boolvec_t_grow(self, *args) def capacity(self, *args): - """capacity(self) -> size_t""" + """ + capacity(self) -> size_t + """ return _idaapi.boolvec_t_capacity(self, *args) def reserve(self, *args): - """reserve(self, cnt)""" + """ + reserve(self, cnt) + """ return _idaapi.boolvec_t_reserve(self, *args) def truncate(self, *args): - """truncate(self)""" + """ + truncate(self) + """ return _idaapi.boolvec_t_truncate(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.boolvec_t_swap(self, *args) def extract(self, *args): - """extract(self) -> bool *""" + """ + extract(self) -> bool * + """ return _idaapi.boolvec_t_extract(self, *args) def inject(self, *args): - """inject(self, s, len)""" + """ + inject(self, s, len) + """ return _idaapi.boolvec_t_inject(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.boolvec_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.boolvec_t___ne__(self, *args) def begin(self, *args): @@ -1429,7 +1713,9 @@ class boolvec_t(object): return _idaapi.boolvec_t_end(self, *args) def insert(self, *args): - """insert(self, it, x) -> qvector< bool >::iterator""" + """ + insert(self, it, x) -> qvector< bool >::iterator + """ return _idaapi.boolvec_t_insert(self, *args) def erase(self, *args): @@ -1447,27 +1733,39 @@ class boolvec_t(object): return _idaapi.boolvec_t_find(self, *args) def has(self, *args): - """has(self, x) -> bool""" + """ + has(self, x) -> bool + """ return _idaapi.boolvec_t_has(self, *args) def add_unique(self, *args): - """add_unique(self, x) -> bool""" + """ + add_unique(self, x) -> bool + """ return _idaapi.boolvec_t_add_unique(self, *args) def _del(self, *args): - """_del(self, x) -> bool""" + """ + _del(self, x) -> bool + """ return _idaapi.boolvec_t__del(self, *args) def __len__(self, *args): - """__len__(self) -> size_t""" + """ + __len__(self) -> size_t + """ return _idaapi.boolvec_t___len__(self, *args) def __getitem__(self, *args): - """__getitem__(self, i) -> bool const &""" + """ + __getitem__(self, i) -> bool const & + """ return _idaapi.boolvec_t___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, i, v)""" + """ + __setitem__(self, i, v) + """ return _idaapi.boolvec_t___setitem__(self, *args) __iter__ = _bounded_getitem_iterator @@ -1476,10 +1774,12 @@ boolvec_t_swigregister = _idaapi.boolvec_t_swigregister boolvec_t_swigregister(boolvec_t) class casevec_t(object): - """Proxy of C++ qvector<(qvector<(sval_t)>)> class""" + """ + Proxy of C++ qvector<(qvector<(sval_t)>)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> casevec_t __init__(self, x) -> casevec_t @@ -1497,19 +1797,27 @@ class casevec_t(object): return _idaapi.casevec_t_push_back(self, *args) def pop_back(self, *args): - """pop_back(self)""" + """ + pop_back(self) + """ return _idaapi.casevec_t_pop_back(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.casevec_t_size(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.casevec_t_empty(self, *args) def at(self, *args): - """at(self, _idx) -> intvec_t""" + """ + at(self, _idx) -> intvec_t + """ return _idaapi.casevec_t_at(self, *args) def front(self, *args): @@ -1527,11 +1835,15 @@ class casevec_t(object): return _idaapi.casevec_t_back(self, *args) def qclear(self, *args): - """qclear(self)""" + """ + qclear(self) + """ return _idaapi.casevec_t_qclear(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.casevec_t_clear(self, *args) def resize(self, *args): @@ -1542,39 +1854,57 @@ class casevec_t(object): return _idaapi.casevec_t_resize(self, *args) def grow(self, *args): - """grow(self, x=qvector< int >())""" + """ + grow(self, x=qvector< int >()) + """ return _idaapi.casevec_t_grow(self, *args) def capacity(self, *args): - """capacity(self) -> size_t""" + """ + capacity(self) -> size_t + """ return _idaapi.casevec_t_capacity(self, *args) def reserve(self, *args): - """reserve(self, cnt)""" + """ + reserve(self, cnt) + """ return _idaapi.casevec_t_reserve(self, *args) def truncate(self, *args): - """truncate(self)""" + """ + truncate(self) + """ return _idaapi.casevec_t_truncate(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.casevec_t_swap(self, *args) def extract(self, *args): - """extract(self) -> intvec_t""" + """ + extract(self) -> intvec_t + """ return _idaapi.casevec_t_extract(self, *args) def inject(self, *args): - """inject(self, s, len)""" + """ + inject(self, s, len) + """ return _idaapi.casevec_t_inject(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.casevec_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.casevec_t___ne__(self, *args) def begin(self, *args): @@ -1592,7 +1922,9 @@ class casevec_t(object): return _idaapi.casevec_t_end(self, *args) def insert(self, *args): - """insert(self, it, x) -> intvec_t""" + """ + insert(self, it, x) -> intvec_t + """ return _idaapi.casevec_t_insert(self, *args) def erase(self, *args): @@ -1610,27 +1942,39 @@ class casevec_t(object): return _idaapi.casevec_t_find(self, *args) def has(self, *args): - """has(self, x) -> bool""" + """ + has(self, x) -> bool + """ return _idaapi.casevec_t_has(self, *args) def add_unique(self, *args): - """add_unique(self, x) -> bool""" + """ + add_unique(self, x) -> bool + """ return _idaapi.casevec_t_add_unique(self, *args) def _del(self, *args): - """_del(self, x) -> bool""" + """ + _del(self, x) -> bool + """ return _idaapi.casevec_t__del(self, *args) def __len__(self, *args): - """__len__(self) -> size_t""" + """ + __len__(self) -> size_t + """ return _idaapi.casevec_t___len__(self, *args) def __getitem__(self, *args): - """__getitem__(self, i) -> intvec_t""" + """ + __getitem__(self, i) -> intvec_t + """ return _idaapi.casevec_t___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, i, v)""" + """ + __setitem__(self, i, v) + """ return _idaapi.casevec_t___setitem__(self, *args) __iter__ = _bounded_getitem_iterator @@ -1639,10 +1983,12 @@ casevec_t_swigregister = _idaapi.casevec_t_swigregister casevec_t_swigregister(casevec_t) class strvec_t(object): - """Proxy of C++ qvector<(simpleline_t)> class""" + """ + Proxy of C++ qvector<(simpleline_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> strvec_t __init__(self, x) -> strvec_t @@ -1660,19 +2006,27 @@ class strvec_t(object): return _idaapi.strvec_t_push_back(self, *args) def pop_back(self, *args): - """pop_back(self)""" + """ + pop_back(self) + """ return _idaapi.strvec_t_pop_back(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.strvec_t_size(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.strvec_t_empty(self, *args) def at(self, *args): - """at(self, _idx) -> simpleline_t""" + """ + at(self, _idx) -> simpleline_t + """ return _idaapi.strvec_t_at(self, *args) def front(self, *args): @@ -1690,11 +2044,15 @@ class strvec_t(object): return _idaapi.strvec_t_back(self, *args) def qclear(self, *args): - """qclear(self)""" + """ + qclear(self) + """ return _idaapi.strvec_t_qclear(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.strvec_t_clear(self, *args) def resize(self, *args): @@ -1705,31 +2063,45 @@ class strvec_t(object): return _idaapi.strvec_t_resize(self, *args) def grow(self, *args): - """grow(self, x=simpleline_t())""" + """ + grow(self, x=simpleline_t()) + """ return _idaapi.strvec_t_grow(self, *args) def capacity(self, *args): - """capacity(self) -> size_t""" + """ + capacity(self) -> size_t + """ return _idaapi.strvec_t_capacity(self, *args) def reserve(self, *args): - """reserve(self, cnt)""" + """ + reserve(self, cnt) + """ return _idaapi.strvec_t_reserve(self, *args) def truncate(self, *args): - """truncate(self)""" + """ + truncate(self) + """ return _idaapi.strvec_t_truncate(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.strvec_t_swap(self, *args) def extract(self, *args): - """extract(self) -> simpleline_t""" + """ + extract(self) -> simpleline_t + """ return _idaapi.strvec_t_extract(self, *args) def inject(self, *args): - """inject(self, s, len)""" + """ + inject(self, s, len) + """ return _idaapi.strvec_t_inject(self, *args) def begin(self, *args): @@ -1747,7 +2119,9 @@ class strvec_t(object): return _idaapi.strvec_t_end(self, *args) def insert(self, *args): - """insert(self, it, x) -> simpleline_t""" + """ + insert(self, it, x) -> simpleline_t + """ return _idaapi.strvec_t_insert(self, *args) def erase(self, *args): @@ -1758,15 +2132,21 @@ class strvec_t(object): return _idaapi.strvec_t_erase(self, *args) def __len__(self, *args): - """__len__(self) -> size_t""" + """ + __len__(self) -> size_t + """ return _idaapi.strvec_t___len__(self, *args) def __getitem__(self, *args): - """__getitem__(self, i) -> simpleline_t""" + """ + __getitem__(self, i) -> simpleline_t + """ return _idaapi.strvec_t___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, i, v)""" + """ + __setitem__(self, i, v) + """ return _idaapi.strvec_t___setitem__(self, *args) __iter__ = _bounded_getitem_iterator @@ -1781,30 +2161,42 @@ _listify_types(uvalvec_t, strvec_t) class uchar_array(object): - """Proxy of C++ uchar_array class""" + """ + Proxy of C++ uchar_array class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, nelements) -> uchar_array""" + def __init__(self, *args): + """ + __init__(self, nelements) -> uchar_array + """ this = _idaapi.new_uchar_array(*args) try: self.this.append(this) except: self.this = this __swig_destroy__ = _idaapi.delete_uchar_array __del__ = lambda self : None; def __getitem__(self, *args): - """__getitem__(self, index) -> uchar""" + """ + __getitem__(self, index) -> uchar + """ return _idaapi.uchar_array___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, index, value)""" + """ + __setitem__(self, index, value) + """ return _idaapi.uchar_array___setitem__(self, *args) def cast(self, *args): - """cast(self) -> uchar *""" + """ + cast(self) -> uchar * + """ return _idaapi.uchar_array_cast(self, *args) def frompointer(*args): - """frompointer(t) -> uchar_array""" + """ + frompointer(t) -> uchar_array + """ return _idaapi.uchar_array_frompointer(*args) frompointer = staticmethod(frompointer) @@ -1812,34 +2204,48 @@ uchar_array_swigregister = _idaapi.uchar_array_swigregister uchar_array_swigregister(uchar_array) def uchar_array_frompointer(*args): - """uchar_array_frompointer(t) -> uchar_array""" + """ + uchar_array_frompointer(t) -> uchar_array + """ return _idaapi.uchar_array_frompointer(*args) class tid_array(object): - """Proxy of C++ tid_array class""" + """ + Proxy of C++ tid_array class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, nelements) -> tid_array""" + def __init__(self, *args): + """ + __init__(self, nelements) -> tid_array + """ this = _idaapi.new_tid_array(*args) try: self.this.append(this) except: self.this = this __swig_destroy__ = _idaapi.delete_tid_array __del__ = lambda self : None; def __getitem__(self, *args): - """__getitem__(self, index) -> tid_t""" + """ + __getitem__(self, index) -> tid_t + """ return _idaapi.tid_array___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, index, value)""" + """ + __setitem__(self, index, value) + """ return _idaapi.tid_array___setitem__(self, *args) def cast(self, *args): - """cast(self) -> tid_t *""" + """ + cast(self) -> tid_t * + """ return _idaapi.tid_array_cast(self, *args) def frompointer(*args): - """frompointer(t) -> tid_array""" + """ + frompointer(t) -> tid_array + """ return _idaapi.tid_array_frompointer(*args) frompointer = staticmethod(frompointer) @@ -1847,34 +2253,48 @@ tid_array_swigregister = _idaapi.tid_array_swigregister tid_array_swigregister(tid_array) def tid_array_frompointer(*args): - """tid_array_frompointer(t) -> tid_array""" + """ + tid_array_frompointer(t) -> tid_array + """ return _idaapi.tid_array_frompointer(*args) class ea_array(object): - """Proxy of C++ ea_array class""" + """ + Proxy of C++ ea_array class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, nelements) -> ea_array""" + def __init__(self, *args): + """ + __init__(self, nelements) -> ea_array + """ this = _idaapi.new_ea_array(*args) try: self.this.append(this) except: self.this = this __swig_destroy__ = _idaapi.delete_ea_array __del__ = lambda self : None; def __getitem__(self, *args): - """__getitem__(self, index) -> ea_t""" + """ + __getitem__(self, index) -> ea_t + """ return _idaapi.ea_array___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, index, value)""" + """ + __setitem__(self, index, value) + """ return _idaapi.ea_array___setitem__(self, *args) def cast(self, *args): - """cast(self) -> ea_t *""" + """ + cast(self) -> ea_t * + """ return _idaapi.ea_array_cast(self, *args) def frompointer(*args): - """frompointer(t) -> ea_array""" + """ + frompointer(t) -> ea_array + """ return _idaapi.ea_array_frompointer(*args) frompointer = staticmethod(frompointer) @@ -1882,34 +2302,48 @@ ea_array_swigregister = _idaapi.ea_array_swigregister ea_array_swigregister(ea_array) def ea_array_frompointer(*args): - """ea_array_frompointer(t) -> ea_array""" + """ + ea_array_frompointer(t) -> ea_array + """ return _idaapi.ea_array_frompointer(*args) class sel_array(object): - """Proxy of C++ sel_array class""" + """ + Proxy of C++ sel_array class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, nelements) -> sel_array""" + def __init__(self, *args): + """ + __init__(self, nelements) -> sel_array + """ this = _idaapi.new_sel_array(*args) try: self.this.append(this) except: self.this = this __swig_destroy__ = _idaapi.delete_sel_array __del__ = lambda self : None; def __getitem__(self, *args): - """__getitem__(self, index) -> sel_t""" + """ + __getitem__(self, index) -> sel_t + """ return _idaapi.sel_array___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, index, value)""" + """ + __setitem__(self, index, value) + """ return _idaapi.sel_array___setitem__(self, *args) def cast(self, *args): - """cast(self) -> sel_t *""" + """ + cast(self) -> sel_t * + """ return _idaapi.sel_array_cast(self, *args) def frompointer(*args): - """frompointer(t) -> sel_array""" + """ + frompointer(t) -> sel_array + """ return _idaapi.sel_array_frompointer(*args) frompointer = staticmethod(frompointer) @@ -1917,34 +2351,48 @@ sel_array_swigregister = _idaapi.sel_array_swigregister sel_array_swigregister(sel_array) def sel_array_frompointer(*args): - """sel_array_frompointer(t) -> sel_array""" + """ + sel_array_frompointer(t) -> sel_array + """ return _idaapi.sel_array_frompointer(*args) class uval_array(object): - """Proxy of C++ uval_array class""" + """ + Proxy of C++ uval_array class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, nelements) -> uval_array""" + def __init__(self, *args): + """ + __init__(self, nelements) -> uval_array + """ this = _idaapi.new_uval_array(*args) try: self.this.append(this) except: self.this = this __swig_destroy__ = _idaapi.delete_uval_array __del__ = lambda self : None; def __getitem__(self, *args): - """__getitem__(self, index) -> uval_t""" + """ + __getitem__(self, index) -> uval_t + """ return _idaapi.uval_array___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, index, value)""" + """ + __setitem__(self, index, value) + """ return _idaapi.uval_array___setitem__(self, *args) def cast(self, *args): - """cast(self) -> uval_t *""" + """ + cast(self) -> uval_t * + """ return _idaapi.uval_array_cast(self, *args) def frompointer(*args): - """frompointer(t) -> uval_array""" + """ + frompointer(t) -> uval_array + """ return _idaapi.uval_array_frompointer(*args) frompointer = staticmethod(frompointer) @@ -1952,34 +2400,48 @@ uval_array_swigregister = _idaapi.uval_array_swigregister uval_array_swigregister(uval_array) def uval_array_frompointer(*args): - """uval_array_frompointer(t) -> uval_array""" + """ + uval_array_frompointer(t) -> uval_array + """ return _idaapi.uval_array_frompointer(*args) class int_pointer(object): - """Proxy of C++ int_pointer class""" + """ + Proxy of C++ int_pointer class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> int_pointer""" + def __init__(self, *args): + """ + __init__(self) -> int_pointer + """ this = _idaapi.new_int_pointer(*args) try: self.this.append(this) except: self.this = this __swig_destroy__ = _idaapi.delete_int_pointer __del__ = lambda self : None; def assign(self, *args): - """assign(self, value)""" + """ + assign(self, value) + """ return _idaapi.int_pointer_assign(self, *args) def value(self, *args): - """value(self) -> int""" + """ + value(self) -> int + """ return _idaapi.int_pointer_value(self, *args) def cast(self, *args): - """cast(self) -> int *""" + """ + cast(self) -> int * + """ return _idaapi.int_pointer_cast(self, *args) def frompointer(*args): - """frompointer(t) -> int_pointer""" + """ + frompointer(t) -> int_pointer + """ return _idaapi.int_pointer_frompointer(*args) frompointer = staticmethod(frompointer) @@ -1987,34 +2449,48 @@ int_pointer_swigregister = _idaapi.int_pointer_swigregister int_pointer_swigregister(int_pointer) def int_pointer_frompointer(*args): - """int_pointer_frompointer(t) -> int_pointer""" + """ + int_pointer_frompointer(t) -> int_pointer + """ return _idaapi.int_pointer_frompointer(*args) class ea_pointer(object): - """Proxy of C++ ea_pointer class""" + """ + Proxy of C++ ea_pointer class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> ea_pointer""" + def __init__(self, *args): + """ + __init__(self) -> ea_pointer + """ this = _idaapi.new_ea_pointer(*args) try: self.this.append(this) except: self.this = this __swig_destroy__ = _idaapi.delete_ea_pointer __del__ = lambda self : None; def assign(self, *args): - """assign(self, value)""" + """ + assign(self, value) + """ return _idaapi.ea_pointer_assign(self, *args) def value(self, *args): - """value(self) -> ea_t""" + """ + value(self) -> ea_t + """ return _idaapi.ea_pointer_value(self, *args) def cast(self, *args): - """cast(self) -> ea_t *""" + """ + cast(self) -> ea_t * + """ return _idaapi.ea_pointer_cast(self, *args) def frompointer(*args): - """frompointer(t) -> ea_pointer""" + """ + frompointer(t) -> ea_pointer + """ return _idaapi.ea_pointer_frompointer(*args) frompointer = staticmethod(frompointer) @@ -2022,34 +2498,48 @@ ea_pointer_swigregister = _idaapi.ea_pointer_swigregister ea_pointer_swigregister(ea_pointer) def ea_pointer_frompointer(*args): - """ea_pointer_frompointer(t) -> ea_pointer""" + """ + ea_pointer_frompointer(t) -> ea_pointer + """ return _idaapi.ea_pointer_frompointer(*args) class sval_pointer(object): - """Proxy of C++ sval_pointer class""" + """ + Proxy of C++ sval_pointer class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> sval_pointer""" + def __init__(self, *args): + """ + __init__(self) -> sval_pointer + """ this = _idaapi.new_sval_pointer(*args) try: self.this.append(this) except: self.this = this __swig_destroy__ = _idaapi.delete_sval_pointer __del__ = lambda self : None; def assign(self, *args): - """assign(self, value)""" + """ + assign(self, value) + """ return _idaapi.sval_pointer_assign(self, *args) def value(self, *args): - """value(self) -> sval_t""" + """ + value(self) -> sval_t + """ return _idaapi.sval_pointer_value(self, *args) def cast(self, *args): - """cast(self) -> sval_t *""" + """ + cast(self) -> sval_t * + """ return _idaapi.sval_pointer_cast(self, *args) def frompointer(*args): - """frompointer(t) -> sval_pointer""" + """ + frompointer(t) -> sval_pointer + """ return _idaapi.sval_pointer_frompointer(*args) frompointer = staticmethod(frompointer) @@ -2057,34 +2547,48 @@ sval_pointer_swigregister = _idaapi.sval_pointer_swigregister sval_pointer_swigregister(sval_pointer) def sval_pointer_frompointer(*args): - """sval_pointer_frompointer(t) -> sval_pointer""" + """ + sval_pointer_frompointer(t) -> sval_pointer + """ return _idaapi.sval_pointer_frompointer(*args) class sel_pointer(object): - """Proxy of C++ sel_pointer class""" + """ + Proxy of C++ sel_pointer class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> sel_pointer""" + def __init__(self, *args): + """ + __init__(self) -> sel_pointer + """ this = _idaapi.new_sel_pointer(*args) try: self.this.append(this) except: self.this = this __swig_destroy__ = _idaapi.delete_sel_pointer __del__ = lambda self : None; def assign(self, *args): - """assign(self, value)""" + """ + assign(self, value) + """ return _idaapi.sel_pointer_assign(self, *args) def value(self, *args): - """value(self) -> sel_t""" + """ + value(self) -> sel_t + """ return _idaapi.sel_pointer_value(self, *args) def cast(self, *args): - """cast(self) -> sel_t *""" + """ + cast(self) -> sel_t * + """ return _idaapi.sel_pointer_cast(self, *args) def frompointer(*args): - """frompointer(t) -> sel_pointer""" + """ + frompointer(t) -> sel_pointer + """ return _idaapi.sel_pointer_frompointer(*args) frompointer = staticmethod(frompointer) @@ -2092,7 +2596,9 @@ sel_pointer_swigregister = _idaapi.sel_pointer_swigregister sel_pointer_swigregister(sel_pointer) def sel_pointer_frompointer(*args): - """sel_pointer_frompointer(t) -> sel_pointer""" + """ + sel_pointer_frompointer(t) -> sel_pointer + """ return _idaapi.sel_pointer_frompointer(*args) f_EXE_old = _idaapi.f_EXE_old @@ -2122,7 +2628,9 @@ f_COM = _idaapi.f_COM f_AIXAR = _idaapi.f_AIXAR f_MACHO = _idaapi.f_MACHO class compiler_info_t(object): - """Proxy of C++ compiler_info_t class""" + """ + Proxy of C++ compiler_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr id = _swig_property(_idaapi.compiler_info_t_id_get, _idaapi.compiler_info_t_id_set) @@ -2134,8 +2642,10 @@ class compiler_info_t(object): size_s = _swig_property(_idaapi.compiler_info_t_size_s_get, _idaapi.compiler_info_t_size_s_set) size_l = _swig_property(_idaapi.compiler_info_t_size_l_get, _idaapi.compiler_info_t_size_l_set) size_ll = _swig_property(_idaapi.compiler_info_t_size_ll_get, _idaapi.compiler_info_t_size_ll_set) - def __init__(self, *args): - """__init__(self) -> compiler_info_t""" + def __init__(self, *args): + """ + __init__(self) -> compiler_info_t + """ this = _idaapi.new_compiler_info_t(*args) try: self.this.append(this) except: self.this = this @@ -2149,45 +2659,63 @@ STT_VA = _idaapi.STT_VA STT_MM = _idaapi.STT_MM STT_DBG = _idaapi.STT_DBG class idainfo(object): - """Proxy of C++ idainfo class""" + """ + Proxy of C++ idainfo class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr tag = _swig_property(_idaapi.idainfo_tag_get, _idaapi.idainfo_tag_set) version = _swig_property(_idaapi.idainfo_version_get, _idaapi.idainfo_version_set) procName = _swig_property(_idaapi.idainfo_procName_get, _idaapi.idainfo_procName_set) def set_proc_name(self, *args): - """set_proc_name(self, name)""" + """ + set_proc_name(self, name) + """ return _idaapi.idainfo_set_proc_name(self, *args) def get_proc_name(self, *args): - """get_proc_name(self) -> char *""" + """ + get_proc_name(self) -> char * + """ return _idaapi.idainfo_get_proc_name(self, *args) lflags = _swig_property(_idaapi.idainfo_lflags_get, _idaapi.idainfo_lflags_set) def is_32bit(self, *args): - """is_32bit(self) -> bool""" + """ + is_32bit(self) -> bool + """ return _idaapi.idainfo_is_32bit(self, *args) def is_64bit(self, *args): - """is_64bit(self) -> bool""" + """ + is_64bit(self) -> bool + """ return _idaapi.idainfo_is_64bit(self, *args) def is_snapshot(self, *args): - """is_snapshot(self) -> bool""" + """ + is_snapshot(self) -> bool + """ return _idaapi.idainfo_is_snapshot(self, *args) def is_dll(self, *args): - """is_dll(self) -> bool""" + """ + is_dll(self) -> bool + """ return _idaapi.idainfo_is_dll(self, *args) demnames = _swig_property(_idaapi.idainfo_demnames_get, _idaapi.idainfo_demnames_set) def get_demname_form(self, *args): - """get_demname_form(self) -> uchar""" + """ + get_demname_form(self) -> uchar + """ return _idaapi.idainfo_get_demname_form(self, *args) filetype = _swig_property(_idaapi.idainfo_filetype_get, _idaapi.idainfo_filetype_set) def like_binary(self, *args): - """like_binary(self) -> bool""" + """ + like_binary(self) -> bool + """ return _idaapi.idainfo_like_binary(self, *args) fcoresiz = _swig_property(_idaapi.idainfo_fcoresiz_get, _idaapi.idainfo_fcoresiz_set) @@ -2213,18 +2741,22 @@ class idainfo(object): s_entab = _swig_property(_idaapi.idainfo_s_entab_get, _idaapi.idainfo_s_entab_set) specsegs = _swig_property(_idaapi.idainfo_specsegs_get, _idaapi.idainfo_specsegs_set) s_void = _swig_property(_idaapi.idainfo_s_void_get, _idaapi.idainfo_s_void_set) - type_xrefnum = _swig_property(_idaapi.idainfo_type_xrefnum_get, _idaapi.idainfo_type_xrefnum_set) + s_reserved2 = _swig_property(_idaapi.idainfo_s_reserved2_get, _idaapi.idainfo_s_reserved2_set) s_showauto = _swig_property(_idaapi.idainfo_s_showauto_get, _idaapi.idainfo_s_showauto_set) s_auto = _swig_property(_idaapi.idainfo_s_auto_get, _idaapi.idainfo_s_auto_set) s_limiter = _swig_property(_idaapi.idainfo_s_limiter_get, _idaapi.idainfo_s_limiter_set) s_null = _swig_property(_idaapi.idainfo_s_null_get, _idaapi.idainfo_s_null_set) s_genflags = _swig_property(_idaapi.idainfo_s_genflags_get, _idaapi.idainfo_s_genflags_set) def use_allasm(self, *args): - """use_allasm(self) -> bool""" + """ + use_allasm(self) -> bool + """ return _idaapi.idainfo_use_allasm(self, *args) def loading_idc(self, *args): - """loading_idc(self) -> bool""" + """ + loading_idc(self) -> bool + """ return _idaapi.idainfo_loading_idc(self, *args) s_showpref = _swig_property(_idaapi.idainfo_s_showpref_get, _idaapi.idainfo_s_showpref_set) @@ -2268,8 +2800,10 @@ class idainfo(object): size_ldbl = _swig_property(_idaapi.idainfo_size_ldbl_get, _idaapi.idainfo_size_ldbl_set) appcall_options = _swig_property(_idaapi.idainfo_appcall_options_get, _idaapi.idainfo_appcall_options_set) reserved = _swig_property(_idaapi.idainfo_reserved_get, _idaapi.idainfo_reserved_set) - def __init__(self, *args): - """__init__(self) -> idainfo""" + def __init__(self, *args): + """ + __init__(self) -> idainfo + """ this = _idaapi.new_idainfo(*args) try: self.this.append(this) except: self.this = this @@ -2365,22 +2899,30 @@ AF2_PURDAT = _idaapi.AF2_PURDAT AF2_MEMFUNC = _idaapi.AF2_MEMFUNC class text_options_t(object): - """Proxy of C++ text_options_t class""" + """ + Proxy of C++ text_options_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr text = _swig_property(_idaapi.text_options_t_text_get, _idaapi.text_options_t_text_set) graph = _swig_property(_idaapi.text_options_t_graph_get, _idaapi.text_options_t_graph_set) - def __init__(self, *args): - """__init__(self) -> text_options_t""" + def __init__(self, *args): + """ + __init__(self) -> text_options_t + """ this = _idaapi.new_text_options_t(*args) try: self.this.append(this) except: self.this = this def copy_to_inf(self, *args): - """copy_to_inf(self, gv, _inf)""" + """ + copy_to_inf(self, gv, _inf) + """ return _idaapi.text_options_t_copy_to_inf(self, *args) def copy_from_inf(self, *args): - """copy_from_inf(self, _inf)""" + """ + copy_from_inf(self, _inf) + """ return _idaapi.text_options_t_copy_from_inf(self, *args) __swig_destroy__ = _idaapi.delete_text_options_t @@ -2390,73 +2932,103 @@ text_options_t_swigregister(text_options_t) def showRepeatables(*args): - """showRepeatables() -> bool""" + """ + showRepeatables() -> bool + """ return _idaapi.showRepeatables(*args) def showAllComments(*args): - """showAllComments() -> bool""" + """ + showAllComments() -> bool + """ return _idaapi.showAllComments(*args) def showComments(*args): - """showComments() -> bool""" + """ + showComments() -> bool + """ return _idaapi.showComments(*args) def should_trace_sp(*args): - """should_trace_sp() -> bool""" + """ + should_trace_sp() -> bool + """ return _idaapi.should_trace_sp(*args) def should_create_stkvars(*args): - """should_create_stkvars() -> bool""" + """ + should_create_stkvars() -> bool + """ return _idaapi.should_create_stkvars(*args) IDAPLACE_HEXDUMP = _idaapi.IDAPLACE_HEXDUMP IDAPLACE_STACK = _idaapi.IDAPLACE_STACK IDAPLACE_SEGADDR = _idaapi.IDAPLACE_SEGADDR def calc_default_idaplace_flags(*args): - """calc_default_idaplace_flags() -> int""" + """ + calc_default_idaplace_flags() -> int + """ return _idaapi.calc_default_idaplace_flags(*args) MAXADDR = _idaapi.MAXADDR def toEA(*args): - """toEA(reg_cs, reg_ip) -> ea_t""" + """ + toEA(reg_cs, reg_ip) -> ea_t + """ return _idaapi.toEA(*args) def idb2scr(*args): - """idb2scr(name) -> char *""" + """ + idb2scr(name) -> char * + """ return _idaapi.idb2scr(*args) def scr2idb(*args): - """scr2idb(name) -> char *""" + """ + scr2idb(name) -> char * + """ return _idaapi.scr2idb(*args) def ansi2idb(*args): - """ansi2idb(name) -> char *""" + """ + ansi2idb(name) -> char * + """ return _idaapi.ansi2idb(*args) IDB_EXT32 = _idaapi.IDB_EXT32 IDB_EXT64 = _idaapi.IDB_EXT64 IDB_EXT = _idaapi.IDB_EXT def dto_copy_to_inf(*args): - """dto_copy_to_inf(arg1, inf)""" + """ + dto_copy_to_inf(arg1, inf) + """ return _idaapi.dto_copy_to_inf(*args) def dto_copy_from_inf(*args): - """dto_copy_from_inf(arg1, inf)""" + """ + dto_copy_from_inf(arg1, inf) + """ return _idaapi.dto_copy_from_inf(*args) def dto_init(*args): - """dto_init(dt, for_graph)""" + """ + dto_init(dt, for_graph) + """ return _idaapi.dto_init(*args) IDD_INTERFACE_VERSION = _idaapi.IDD_INTERFACE_VERSION NO_THREAD = _idaapi.NO_THREAD class process_info_t(object): - """Proxy of C++ process_info_t class""" + """ + Proxy of C++ process_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr pid = _swig_property(_idaapi.process_info_t_pid_get, _idaapi.process_info_t_pid_set) name = _swig_property(_idaapi.process_info_t_name_get, _idaapi.process_info_t_name_set) - def __init__(self, *args): - """__init__(self) -> process_info_t""" + def __init__(self, *args): + """ + __init__(self) -> process_info_t + """ this = _idaapi.new_process_info_t(*args) try: self.this.append(this) except: self.this = this @@ -2466,14 +3038,18 @@ process_info_t_swigregister = _idaapi.process_info_t_swigregister process_info_t_swigregister(process_info_t) class debapp_attrs_t(object): - """Proxy of C++ debapp_attrs_t class""" + """ + Proxy of C++ debapp_attrs_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr cbsize = _swig_property(_idaapi.debapp_attrs_t_cbsize_get, _idaapi.debapp_attrs_t_cbsize_set) addrsize = _swig_property(_idaapi.debapp_attrs_t_addrsize_get, _idaapi.debapp_attrs_t_addrsize_set) platform = _swig_property(_idaapi.debapp_attrs_t_platform_get, _idaapi.debapp_attrs_t_platform_set) - def __init__(self, *args): - """__init__(self) -> debapp_attrs_t""" + def __init__(self, *args): + """ + __init__(self) -> debapp_attrs_t + """ this = _idaapi.new_debapp_attrs_t(*args) try: self.this.append(this) except: self.this = this @@ -2501,15 +3077,19 @@ PROCESS_DETACH = _idaapi.PROCESS_DETACH PROCESS_SUSPEND = _idaapi.PROCESS_SUSPEND TRACE_FULL = _idaapi.TRACE_FULL class module_info_t(object): - """Proxy of C++ module_info_t class""" + """ + Proxy of C++ module_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr name = _swig_property(_idaapi.module_info_t_name_get, _idaapi.module_info_t_name_set) base = _swig_property(_idaapi.module_info_t_base_get, _idaapi.module_info_t_base_set) size = _swig_property(_idaapi.module_info_t_size_get, _idaapi.module_info_t_size_set) rebase_to = _swig_property(_idaapi.module_info_t_rebase_to_get, _idaapi.module_info_t_rebase_to_set) - def __init__(self, *args): - """__init__(self) -> module_info_t""" + def __init__(self, *args): + """ + __init__(self) -> module_info_t + """ this = _idaapi.new_module_info_t(*args) try: self.this.append(this) except: self.this = this @@ -2519,13 +3099,17 @@ module_info_t_swigregister = _idaapi.module_info_t_swigregister module_info_t_swigregister(module_info_t) class e_breakpoint_t(object): - """Proxy of C++ e_breakpoint_t class""" + """ + Proxy of C++ e_breakpoint_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr hea = _swig_property(_idaapi.e_breakpoint_t_hea_get, _idaapi.e_breakpoint_t_hea_set) kea = _swig_property(_idaapi.e_breakpoint_t_kea_get, _idaapi.e_breakpoint_t_kea_set) - def __init__(self, *args): - """__init__(self) -> e_breakpoint_t""" + def __init__(self, *args): + """ + __init__(self) -> e_breakpoint_t + """ this = _idaapi.new_e_breakpoint_t(*args) try: self.this.append(this) except: self.this = this @@ -2535,15 +3119,19 @@ e_breakpoint_t_swigregister = _idaapi.e_breakpoint_t_swigregister e_breakpoint_t_swigregister(e_breakpoint_t) class e_exception_t(object): - """Proxy of C++ e_exception_t class""" + """ + Proxy of C++ e_exception_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr code = _swig_property(_idaapi.e_exception_t_code_get, _idaapi.e_exception_t_code_set) can_cont = _swig_property(_idaapi.e_exception_t_can_cont_get, _idaapi.e_exception_t_can_cont_set) ea = _swig_property(_idaapi.e_exception_t_ea_get, _idaapi.e_exception_t_ea_set) info = _swig_property(_idaapi.e_exception_t_info_get, _idaapi.e_exception_t_info_set) - def __init__(self, *args): - """__init__(self) -> e_exception_t""" + def __init__(self, *args): + """ + __init__(self) -> e_exception_t + """ this = _idaapi.new_e_exception_t(*args) try: self.this.append(this) except: self.this = this @@ -2553,11 +3141,15 @@ e_exception_t_swigregister = _idaapi.e_exception_t_swigregister e_exception_t_swigregister(e_exception_t) class debug_event_t(object): - """Proxy of C++ debug_event_t class""" + """ + Proxy of C++ debug_event_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> debug_event_t""" + def __init__(self, *args): + """ + __init__(self) -> debug_event_t + """ this = _idaapi.new_debug_event_t(*args) try: self.this.append(this) except: self.this = this @@ -2572,7 +3164,9 @@ class debug_event_t(object): bpt = _swig_property(_idaapi.debug_event_t_bpt_get, _idaapi.debug_event_t_bpt_set) exc = _swig_property(_idaapi.debug_event_t_exc_get, _idaapi.debug_event_t_exc_set) def bpt_ea(self, *args): - """bpt_ea(self) -> ea_t""" + """ + bpt_ea(self) -> ea_t + """ return _idaapi.debug_event_t_bpt_ea(self, *args) __swig_destroy__ = _idaapi.delete_debug_event_t @@ -2581,22 +3175,28 @@ debug_event_t_swigregister = _idaapi.debug_event_t_swigregister debug_event_t_swigregister(debug_event_t) class exception_info_t(object): - """Proxy of C++ exception_info_t class""" + """ + Proxy of C++ exception_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr code = _swig_property(_idaapi.exception_info_t_code_get, _idaapi.exception_info_t_code_set) flags = _swig_property(_idaapi.exception_info_t_flags_get, _idaapi.exception_info_t_flags_set) def break_on(self, *args): - """break_on(self) -> bool""" + """ + break_on(self) -> bool + """ return _idaapi.exception_info_t_break_on(self, *args) def handle(self, *args): - """handle(self) -> bool""" + """ + handle(self) -> bool + """ return _idaapi.exception_info_t_handle(self, *args) name = _swig_property(_idaapi.exception_info_t_name_get, _idaapi.exception_info_t_name_set) desc = _swig_property(_idaapi.exception_info_t_desc_get, _idaapi.exception_info_t_desc_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> exception_info_t __init__(self, _code, _flags, _name, _desc) -> exception_info_t @@ -2621,7 +3221,9 @@ EXC_MSG = _idaapi.EXC_MSG EXC_SILENT = _idaapi.EXC_SILENT class regval_t(object): - """Proxy of C++ regval_t class""" + """ + Proxy of C++ regval_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr rvtype = _swig_property(_idaapi.regval_t_rvtype_get, _idaapi.regval_t_rvtype_set) @@ -2629,7 +3231,7 @@ class regval_t(object): fval = _swig_property(_idaapi.regval_t_fval_get, _idaapi.regval_t_fval_set) __swig_destroy__ = _idaapi.delete_regval_t __del__ = lambda self : None; - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> regval_t __init__(self, r) -> regval_t @@ -2638,29 +3240,60 @@ class regval_t(object): try: self.this.append(this) except: self.this = this def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.regval_t_clear(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.regval_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.regval_t___ne__(self, *args) - def swap(self, *args): - """swap(self, r)""" - return _idaapi.regval_t_swap(self, *args) - def _set_int(self, *args): - """_set_int(self, x)""" + """ + _set_int(self, x) + """ return _idaapi.regval_t__set_int(self, *args) def _set_float(self, *args): - """_set_float(self, x)""" + """ + _set_float(self, x) + """ return _idaapi.regval_t__set_float(self, *args) + def set_int(self, *args): + """ + set_int(self, x) + """ + return _idaapi.regval_t_set_int(self, *args) + + def set_float(self, *args): + """ + set_float(self, x) + """ + return _idaapi.regval_t_set_float(self, *args) + + def swap(self, *args): + """ + swap(self, r) + """ + return _idaapi.regval_t_swap(self, *args) + + def bytes(self, *args): + """ + bytes(self) -> bytevec_t + bytes(self) -> bytevec_t const & + """ + return _idaapi.regval_t_bytes(self, *args) + def _set_bytes(self, *args): """ _set_bytes(self, data, size) @@ -2669,14 +3302,6 @@ class regval_t(object): """ return _idaapi.regval_t__set_bytes(self, *args) - def set_int(self, *args): - """set_int(self, x)""" - return _idaapi.regval_t_set_int(self, *args) - - def set_float(self, *args): - """set_float(self, x)""" - return _idaapi.regval_t_set_float(self, *args) - def set_bytes(self, *args): """ set_bytes(self, data, size) @@ -2685,13 +3310,6 @@ class regval_t(object): """ return _idaapi.regval_t_set_bytes(self, *args) - def bytes(self, *args): - """ - bytes(self) -> bytevec_t - bytes(self) -> bytevec_t const & - """ - return _idaapi.regval_t_bytes(self, *args) - def get_data(self, *args): """ get_data(self) @@ -2700,7 +3318,9 @@ class regval_t(object): return _idaapi.regval_t_get_data(self, *args) def get_data_size(self, *args): - """get_data_size(self) -> size_t""" + """ + get_data_size(self) -> size_t + """ return _idaapi.regval_t_get_data_size(self, *args) regval_t_swigregister = _idaapi.regval_t_swigregister @@ -2709,7 +3329,9 @@ RVT_INT = _idaapi.RVT_INT RVT_FLOAT = _idaapi.RVT_FLOAT class call_stack_info_t(object): - """Proxy of C++ call_stack_info_t class""" + """ + Proxy of C++ call_stack_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr callea = _swig_property(_idaapi.call_stack_info_t_callea_get, _idaapi.call_stack_info_t_callea_set) @@ -2717,15 +3339,21 @@ class call_stack_info_t(object): fp = _swig_property(_idaapi.call_stack_info_t_fp_get, _idaapi.call_stack_info_t_fp_set) funcok = _swig_property(_idaapi.call_stack_info_t_funcok_get, _idaapi.call_stack_info_t_funcok_set) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.call_stack_info_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.call_stack_info_t___ne__(self, *args) - def __init__(self, *args): - """__init__(self) -> call_stack_info_t""" + def __init__(self, *args): + """ + __init__(self) -> call_stack_info_t + """ this = _idaapi.new_call_stack_info_t(*args) try: self.this.append(this) except: self.this = this @@ -2735,12 +3363,16 @@ call_stack_info_t_swigregister = _idaapi.call_stack_info_t_swigregister call_stack_info_t_swigregister(call_stack_info_t) class call_stack_t(object): - """Proxy of C++ call_stack_t class""" + """ + Proxy of C++ call_stack_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr dirty = _swig_property(_idaapi.call_stack_t_dirty_get, _idaapi.call_stack_t_dirty_set) - def __init__(self, *args): - """__init__(self) -> call_stack_t""" + def __init__(self, *args): + """ + __init__(self) -> call_stack_t + """ this = _idaapi.new_call_stack_t(*args) try: self.this.append(this) except: self.this = this @@ -2751,43 +3383,21 @@ call_stack_t_swigregister(call_stack_t) def dbg_appcall(*args): - """dbg_appcall(func_ea, tid, tif, argnum, argv, r) -> error_t""" + """ + dbg_appcall(func_ea, tid, tif, argnum, argv, r) -> error_t + """ return _idaapi.dbg_appcall(*args) def cleanup_appcall(*args): - """cleanup_appcall(tid) -> error_t""" + """ + cleanup_appcall(tid) -> error_t + """ return _idaapi.cleanup_appcall(*args) -RESMOD_NONE = _idaapi.RESMOD_NONE -RESMOD_INTO = _idaapi.RESMOD_INTO -RESMOD_OVER = _idaapi.RESMOD_OVER -RESMOD_OUT = _idaapi.RESMOD_OUT -RESMOD_SRCINTO = _idaapi.RESMOD_SRCINTO -RESMOD_SRCOVER = _idaapi.RESMOD_SRCOVER -RESMOD_SRCOUT = _idaapi.RESMOD_SRCOUT -RESMOD_USER = _idaapi.RESMOD_USER -RESMOD_HANDLE = _idaapi.RESMOD_HANDLE -RESMOD_MAX = _idaapi.RESMOD_MAX -PROCESS_NO_THREAD = _idaapi.PROCESS_NO_THREAD -class idd_opinfo_old_t(object): - """Proxy of C++ idd_opinfo_old_t class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - addr = _swig_property(_idaapi.idd_opinfo_old_t_addr_get, _idaapi.idd_opinfo_old_t_addr_set) - value = _swig_property(_idaapi.idd_opinfo_old_t_value_get, _idaapi.idd_opinfo_old_t_value_set) - modified = _swig_property(_idaapi.idd_opinfo_old_t_modified_get, _idaapi.idd_opinfo_old_t_modified_set) - def __init__(self, *args): - """__init__(self) -> idd_opinfo_old_t""" - this = _idaapi.new_idd_opinfo_old_t(*args) - try: self.this.append(this) - except: self.this = this - __swig_destroy__ = _idaapi.delete_idd_opinfo_old_t - __del__ = lambda self : None; -idd_opinfo_old_t_swigregister = _idaapi.idd_opinfo_old_t_swigregister -idd_opinfo_old_t_swigregister(idd_opinfo_old_t) - def handle_debug_event(*args): - """handle_debug_event(ev, rqflags) -> int""" + """ + handle_debug_event(ev, rqflags) -> int + """ return _idaapi.handle_debug_event(*args) RQ_MASKING = _idaapi.RQ_MASKING RQ_SUSPEND = _idaapi.RQ_SUSPEND @@ -2801,8 +3411,28 @@ RQ_PROCEXIT = _idaapi.RQ_PROCEXIT RQ_IDAIDLE = _idaapi.RQ_IDAIDLE RQ_SUSPRUN = _idaapi.RQ_SUSPRUN RQ_RESUME = _idaapi.RQ_RESUME -RQ_RESMOD = _idaapi.RQ_RESMOD -RQ_RESMOD_SHIFT = _idaapi.RQ_RESMOD_SHIFT +PROCESS_NO_THREAD = _idaapi.PROCESS_NO_THREAD +class idd_opinfo_old_t(object): + """ + Proxy of C++ idd_opinfo_old_t class + """ + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + addr = _swig_property(_idaapi.idd_opinfo_old_t_addr_get, _idaapi.idd_opinfo_old_t_addr_set) + value = _swig_property(_idaapi.idd_opinfo_old_t_value_get, _idaapi.idd_opinfo_old_t_value_set) + modified = _swig_property(_idaapi.idd_opinfo_old_t_modified_get, _idaapi.idd_opinfo_old_t_modified_set) + def __init__(self, *args): + """ + __init__(self) -> idd_opinfo_old_t + """ + this = _idaapi.new_idd_opinfo_old_t(*args) + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _idaapi.delete_idd_opinfo_old_t + __del__ = lambda self : None; +idd_opinfo_old_t_swigregister = _idaapi.idd_opinfo_old_t_swigregister +idd_opinfo_old_t_swigregister(idd_opinfo_old_t) + # NO_PROCESS = 0xFFFFFFFF NO_THREAD = 0 @@ -2810,83 +3440,166 @@ NO_THREAD = 0 def dbg_get_registers(*args): - """dbg_get_registers() -> PyObject *""" + """ + dbg_get_registers() -> PyObject * + + + This function returns the register definition from the currently loaded debugger. + Basically, it returns an array of structure similar to to idd.hpp / register_info_t + @return: + None if no debugger is loaded + tuple(name, flags, class, dtyp, bit_strings, bit_strings_default_mask) + The bit_strings can be a tuple of strings or None (if the register does not have bit_strings) + """ return _idaapi.dbg_get_registers(*args) def dbg_get_thread_sreg_base(*args): - """dbg_get_thread_sreg_base(py_tid, py_sreg_value) -> PyObject *""" + """ + dbg_get_thread_sreg_base(py_tid, py_sreg_value) -> PyObject * + + + Returns the segment register base value + @param tid: thread id + @param sreg_value: segment register (selector) value + @return: + - The base as an 'ea' + - Or None on failure + """ return _idaapi.dbg_get_thread_sreg_base(*args) def dbg_read_memory(*args): - """dbg_read_memory(py_ea, py_sz) -> PyObject *""" + """ + dbg_read_memory(py_ea, py_sz) -> PyObject * + + + Reads from the debugee's memory at the specified ea + @return: + - The read buffer (as a string) + - Or None on failure + """ return _idaapi.dbg_read_memory(*args) def dbg_write_memory(*args): - """dbg_write_memory(py_ea, py_buf) -> PyObject *""" + """ + dbg_write_memory(py_ea, py_buf) -> PyObject * + + + Writes a buffer to the debugee's memory + @return: Boolean + """ return _idaapi.dbg_write_memory(*args) def dbg_get_name(*args): - """dbg_get_name() -> PyObject *""" + """ + dbg_get_name() -> PyObject * + + + This function returns the current debugger's name. + @return: Debugger name or None if no debugger is active + """ return _idaapi.dbg_get_name(*args) def dbg_get_memory_info(*args): - """dbg_get_memory_info() -> PyObject *""" + """ + dbg_get_memory_info() -> PyObject * + + + This function returns the memory configuration of a debugged process. + @return: + None if no debugger is active + tuple(startEA, endEA, name, sclass, sbase, bitness, perm) + """ return _idaapi.dbg_get_memory_info(*args) def dbg_can_query(*args): - """dbg_can_query() -> bool""" + """ + dbg_can_query() -> bool + + + This function can be used to check if the debugger can be queried: + - debugger is loaded + - process is suspended + - process is not suspended but can take requests. In this case some requests like + memory read/write, bpt management succeed and register querying will fail. + Check if idaapi.get_process_state() < 0 to tell if the process is suspended + @return: Boolean + """ return _idaapi.dbg_can_query(*args) def appcall(*args): - """appcall(func_ea, tid, py_type, py_fields, arg_list) -> PyObject *""" + """ + appcall(func_ea, tid, py_type, py_fields, arg_list) -> PyObject * + """ return _idaapi.appcall(*args) def get_event_module_name(*args): - """get_event_module_name(ev) -> char""" + """ + get_event_module_name(ev) -> char + """ return _idaapi.get_event_module_name(*args) def get_event_module_base(*args): - """get_event_module_base(ev) -> ea_t""" + """ + get_event_module_base(ev) -> ea_t + """ return _idaapi.get_event_module_base(*args) def get_event_module_size(*args): - """get_event_module_size(ev) -> asize_t""" + """ + get_event_module_size(ev) -> asize_t + """ return _idaapi.get_event_module_size(*args) def get_event_exc_info(*args): - """get_event_exc_info(ev) -> char""" + """ + get_event_exc_info(ev) -> char + """ return _idaapi.get_event_exc_info(*args) def get_event_info(*args): - """get_event_info(ev) -> char""" + """ + get_event_info(ev) -> char + """ return _idaapi.get_event_info(*args) def get_event_bpt_hea(*args): - """get_event_bpt_hea(ev) -> ea_t""" + """ + get_event_bpt_hea(ev) -> ea_t + """ return _idaapi.get_event_bpt_hea(*args) def get_event_exc_code(*args): - """get_event_exc_code(ev) -> uint""" + """ + get_event_exc_code(ev) -> uint + """ return _idaapi.get_event_exc_code(*args) def get_event_exc_ea(*args): - """get_event_exc_ea(ev) -> ea_t""" + """ + get_event_exc_ea(ev) -> ea_t + """ return _idaapi.get_event_exc_ea(*args) def can_exc_continue(*args): - """can_exc_continue(ev) -> bool""" + """ + can_exc_continue(ev) -> bool + """ return _idaapi.can_exc_continue(*args) # import types # ----------------------------------------------------------------------- class Appcall_array__(object): - """This class is used with Appcall.array() method""" + """ + This class is used with Appcall.array() method + """ def __init__(self, tp): self.__type = tp def pack(self, L): - """Packs a list or tuple into a byref buffer""" + """ + Packs a list or tuple into a byref buffer + """ t = type(L) if not (t == types.ListType or t == types.TupleType): raise ValueError, "Either a list or a tuple must be passed" @@ -2903,7 +3616,9 @@ class Appcall_array__(object): return None def try_to_convert_to_list(self, obj): - """Is this object a list? We check for the existance of attribute zero and attribute self.size-1""" + """ + Is this object a list? We check for the existance of attribute zero and attribute self.size-1 + """ if not (hasattr(obj, "0") and hasattr(obj, str(self.__size-1))): return obj # at this point, we are sure we have an "idc list" @@ -2911,7 +3626,9 @@ class Appcall_array__(object): return [getattr(obj, str(x)) for x in xrange(0, self.__size)] def unpack(self, buf, as_list=True): - """Unpacks an array back into a list or an object""" + """ + Unpacks an array back into a list or an object + """ # take the value from the special ref object if isinstance(buf, PyIdc_cvt_refclass__): buf = buf.value @@ -2945,7 +3662,9 @@ class Appcall_callable__(object): appcall.funcname(arg1, i, "hello", o) """ def __init__(self, ea, tp = None, fld = None): - """Initializes an appcall with a given function ea""" + """ + Initializes an appcall with a given function ea + """ self.__ea = ea self.__type = tp self.__fields = fld @@ -2959,7 +3678,9 @@ class Appcall_callable__(object): self.__timeout = v timeout = property(__get_timeout, __set_timeout) - """An Appcall instance can change its timeout value with this attribute""" + """ + An Appcall instance can change its timeout value with this attribute + """ def __get_options(self): return self.__options if self.__options != None else Appcall__.get_appcall_options() @@ -2975,10 +3696,14 @@ class Appcall_callable__(object): self.__options = v options = property(__get_options, __set_options) - """Sets the Appcall options locally to this Appcall instance""" + """ + Sets the Appcall options locally to this Appcall instance + """ def __call__(self, *args): - """Make object callable. We redirect execution to idaapi.appcall()""" + """ + Make object callable. We redirect execution to idaapi.appcall() + """ if self.ea is None: raise ValueError, "Object not callable!" @@ -3017,7 +3742,9 @@ class Appcall_callable__(object): self.__ea = val ea = property(__get_ea, __set_ea) - """Returns or sets the EA associated with this object""" + """ + Returns or sets the EA associated with this object + """ def __get_size(self): if self.__type == None: @@ -3028,19 +3755,25 @@ class Appcall_callable__(object): return r size = property(__get_size) - """Returns the size of the type""" + """ + Returns the size of the type + """ def __get_type(self): return self.__type type = property(__get_type) - """Returns the typestring""" + """ + Returns the typestring + """ def __get_fields(self): return self.__fields fields = property(__get_fields) - """Returns the field names""" + """ + Returns the field names + """ def retrieve(self, src=None, flags=0): @@ -3089,8 +3822,10 @@ class Appcall_callable__(object): # ----------------------------------------------------------------------- class Appcall_consts__(object): - """Helper class used by Appcall.Consts attribute - It is used to retrieve constants via attribute access""" + """ + Helper class used by Appcall.Consts attribute + It is used to retrieve constants via attribute access +""" def __init__(self, default=0): self.__default = default @@ -3126,7 +3861,9 @@ class Appcall__(object): def __get_consts(self): return self.__consts Consts = property(__get_consts) - """Use Appcall.Consts.CONST_NAME to access constants""" + """ + Use Appcall.Consts.CONST_NAME to access constants + """ @staticmethod def __name_or_ea(name_or_ea): @@ -3174,7 +3911,9 @@ class Appcall__(object): return Appcall_callable__(ea, result[1], result[2]) def __getattr__(self, name_or_ea): - """Allows you to call functions as if they were member functions (by returning a callable object)""" + """ + Allows you to call functions as if they were member functions (by returning a callable object) + """ # resolve and raise exception on error ea = self.__name_or_ea(name_or_ea) if ea == _idaapi.BADADDR: @@ -3202,7 +3941,9 @@ class Appcall__(object): @staticmethod def int64(v): - """Whenever a 64bit number is needed use this method to construct an object""" + """ + Whenever a 64bit number is needed use this method to construct an object + """ return PyIdc_cvt_int64__(v) @staticmethod @@ -3231,7 +3972,9 @@ class Appcall__(object): @staticmethod def obj(**kwds): - """Returns an empty object or objects with attributes as passed via its keywords arguments""" + """ + Returns an empty object or objects with attributes as passed via its keywords arguments + """ return object_t(**kwds) @staticmethod @@ -3244,7 +3987,9 @@ class Appcall__(object): @staticmethod def array(type_name): - """Defines an array type. Later you need to pack() / unpack()""" + """ + Defines an array type. Later you need to pack() / unpack() + """ return Appcall_array__(type_name) @staticmethod @@ -3264,19 +4009,25 @@ class Appcall__(object): @staticmethod def set_appcall_options(opt): - """Method to change the Appcall options globally (not per Appcall)""" + """ + Method to change the Appcall options globally (not per Appcall) + """ old_opt = Appcall__.get_appcall_options() _idaapi.cvar.inf.appcall_options = opt return old_opt @staticmethod def get_appcall_options(): - """Return the global Appcall options""" + """ + Return the global Appcall options + """ return _idaapi.cvar.inf.appcall_options @staticmethod def cleanup_appcall(tid = 0): - """Equivalent to IDC's CleanupAppcall()""" + """ + Equivalent to IDC's CleanupAppcall() + """ return _idaapi.cleanup_appcall(tid) Appcall = Appcall__() @@ -3289,38 +4040,56 @@ IDPOPT_PRI_DEFAULT = _idaapi.IDPOPT_PRI_DEFAULT IDPOPT_PRI_HIGH = _idaapi.IDPOPT_PRI_HIGH def cfg_get_cc_parm(*args): - """cfg_get_cc_parm(compid, name) -> char const *""" + """ + cfg_get_cc_parm(compid, name) -> char const * + """ return _idaapi.cfg_get_cc_parm(*args) def cfg_get_cc_header_path(*args): - """cfg_get_cc_header_path(compid) -> char const *""" + """ + cfg_get_cc_header_path(compid) -> char const * + """ return _idaapi.cfg_get_cc_header_path(*args) def cfg_get_cc_predefined_macros(*args): - """cfg_get_cc_predefined_macros(compid) -> char const *""" + """ + cfg_get_cc_predefined_macros(compid) -> char const * + """ return _idaapi.cfg_get_cc_predefined_macros(*args) def InstrIsSet(*args): - """InstrIsSet(icode, bit) -> bool""" + """ + InstrIsSet(icode, bit) -> bool + """ return _idaapi.InstrIsSet(*args) def is_call_insn(*args): - """is_call_insn(ea) -> bool""" + """ + is_call_insn(ea) -> bool + """ return _idaapi.is_call_insn(*args) def is_ret_insn(*args): - """is_ret_insn(ea, strict=True) -> bool""" + """ + is_ret_insn(ea, strict=True) -> bool + """ return _idaapi.is_ret_insn(*args) def is_indirect_jump_insn(*args): - """is_indirect_jump_insn(ea) -> bool""" + """ + is_indirect_jump_insn(ea) -> bool + """ return _idaapi.is_indirect_jump_insn(*args) def is_basic_block_end(*args): - """is_basic_block_end(call_insn_stops_block) -> bool""" + """ + is_basic_block_end(call_insn_stops_block) -> bool + """ return _idaapi.is_basic_block_end(*args) class asm_t(object): - """Proxy of C++ asm_t class""" + """ + Proxy of C++ asm_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr flag = _swig_property(_idaapi.asm_t_flag_get, _idaapi.asm_t_flag_set) @@ -3379,8 +4148,10 @@ class asm_t(object): a_3byte = _swig_property(_idaapi.asm_t_a_3byte_get, _idaapi.asm_t_a_3byte_set) a_rva = _swig_property(_idaapi.asm_t_a_rva_get, _idaapi.asm_t_a_rva_set) a_yword = _swig_property(_idaapi.asm_t_a_yword_get, _idaapi.asm_t_a_yword_set) - def __init__(self, *args): - """__init__(self) -> asm_t""" + def __init__(self, *args): + """ + __init__(self) -> asm_t + """ this = _idaapi.new_asm_t(*args) try: self.this.append(this) except: self.this = this @@ -3447,60 +4218,88 @@ AS2_YWORD = _idaapi.AS2_YWORD def str2regf(*args): - """str2regf(p) -> int""" + """ + str2regf(p) -> int + """ return _idaapi.str2regf(*args) def str2reg(*args): - """str2reg(p) -> int""" + """ + str2reg(p) -> int + """ return _idaapi.str2reg(*args) def is_align_insn(*args): - """is_align_insn(ea) -> int""" + """ + is_align_insn(ea) -> int + """ return _idaapi.is_align_insn(*args) def get_reg_name(*args): - """get_reg_name(reg, width, reghi=-1) -> ssize_t""" + """ + get_reg_name(reg, width, reghi=-1) -> ssize_t + """ return _idaapi.get_reg_name(*args) def get_reg_info2(*args): - """get_reg_info2(regname, bitrange) -> char const *""" + """ + get_reg_info2(regname, bitrange) -> char const * + """ return _idaapi.get_reg_info2(*args) class reg_info_t(object): - """Proxy of C++ reg_info_t class""" + """ + Proxy of C++ reg_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr reg = _swig_property(_idaapi.reg_info_t_reg_get, _idaapi.reg_info_t_reg_set) size = _swig_property(_idaapi.reg_info_t_size_get, _idaapi.reg_info_t_size_set) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.reg_info_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.reg_info_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.reg_info_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.reg_info_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.reg_info_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.reg_info_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.reg_info_t_compare(self, *args) - def __init__(self, *args): - """__init__(self) -> reg_info_t""" + def __init__(self, *args): + """ + __init__(self) -> reg_info_t + """ this = _idaapi.new_reg_info_t(*args) try: self.this.append(this) except: self.this = this @@ -3511,31 +4310,45 @@ reg_info_t_swigregister(reg_info_t) def parse_reg_name(*args): - """parse_reg_name(regname, ri) -> bool""" + """ + parse_reg_name(regname, ri) -> bool + """ return _idaapi.parse_reg_name(*args) def sizeof_ldbl(*args): - """sizeof_ldbl() -> size_t""" + """ + sizeof_ldbl() -> size_t + """ return _idaapi.sizeof_ldbl(*args) def intel_data(*args): - """intel_data(ea)""" + """ + intel_data(ea) + """ return _idaapi.intel_data(*args) def gen_spcdef(*args): - """gen_spcdef(ea, segtype) -> bool""" + """ + gen_spcdef(ea, segtype) -> bool + """ return _idaapi.gen_spcdef(*args) def gen_extern(*args): - """gen_extern(ea, name) -> bool""" + """ + gen_extern(ea, name) -> bool + """ return _idaapi.gen_extern(*args) def gen_abssym(*args): - """gen_abssym(ea, name) -> bool""" + """ + gen_abssym(ea, name) -> bool + """ return _idaapi.gen_abssym(*args) def gen_comvar(*args): - """gen_comvar(ea, name) -> bool""" + """ + gen_comvar(ea, name) -> bool + """ return _idaapi.gen_comvar(*args) SETPROC_COMPAT = _idaapi.SETPROC_COMPAT SETPROC_ALL = _idaapi.SETPROC_ALL @@ -3543,19 +4356,27 @@ SETPROC_USER = _idaapi.SETPROC_USER SETPROC_FATAL = _idaapi.SETPROC_FATAL def set_processor_type(*args): - """set_processor_type(procname, level) -> char *""" + """ + set_processor_type(procname, level) -> char * + """ return _idaapi.set_processor_type(*args) def get_idp_name(*args): - """get_idp_name() -> char *""" + """ + get_idp_name() -> char * + """ return _idaapi.get_idp_name(*args) def set_target_assembler(*args): - """set_target_assembler(asmnum) -> bool""" + """ + set_target_assembler(asmnum) -> bool + """ return _idaapi.set_target_assembler(*args) def create_custom_fixup(*args): - """create_custom_fixup(name) -> int""" + """ + create_custom_fixup(name) -> int + """ return _idaapi.create_custom_fixup(*args) byte_patched = _idaapi.byte_patched cmt_changed = _idaapi.cmt_changed @@ -3620,195 +4441,509 @@ extra_cmt_changed = _idaapi.extra_cmt_changed changing_struc = _idaapi.changing_struc changed_struc = _idaapi.changed_struc local_types_changed = _idaapi.local_types_changed -segm_attrs_changed = _idaapi.segm_attrs_changed def AssembleLine(*args): - """AssembleLine(ea, cs, ip, use32, line) -> PyObject *""" + """ + AssembleLine(ea, cs, ip, use32, line) -> PyObject * + + + Assemble an instruction to a string (display a warning if an error is found) + + @param ea: linear address of instruction + @param cs: cs of instruction + @param ip: ip of instruction + @param use32: is 32bit segment + @param line: line to assemble + @return: + - None on failure + - or a string containing the assembled instruction + """ return _idaapi.AssembleLine(*args) def assemble(*args): - """assemble(ea, cs, ip, use32, line) -> bool""" + """ + assemble(ea, cs, ip, use32, line) -> bool + + + Assemble an instruction into the database (display a warning if an error is found) + @param ea: linear address of instruction + @param cs: cs of instruction + @param ip: ip of instruction + @param use32: is 32bit segment? + @param line: line to assemble + + @return: Boolean. True on success. + """ return _idaapi.assemble(*args) def ph_get_id(*args): - """ph_get_id() -> size_t""" + """ + ph_get_id() -> size_t + + + Returns the 'ph.id' field + """ return _idaapi.ph_get_id(*args) def ph_get_version(*args): - """ph_get_version() -> size_t""" + """ + ph_get_version() -> size_t + + + Returns the 'ph.version' + """ return _idaapi.ph_get_version(*args) def ph_get_flag(*args): - """ph_get_flag() -> size_t""" + """ + ph_get_flag() -> size_t + + + Returns the 'ph.flag' + """ return _idaapi.ph_get_flag(*args) def ph_get_cnbits(*args): - """ph_get_cnbits() -> size_t""" + """ + ph_get_cnbits() -> size_t + + + Returns the 'ph.cnbits' + """ return _idaapi.ph_get_cnbits(*args) def ph_get_dnbits(*args): - """ph_get_dnbits() -> size_t""" + """ + ph_get_dnbits() -> size_t + + + Returns the 'ph.dnbits' + """ return _idaapi.ph_get_dnbits(*args) def ph_get_regFirstSreg(*args): - """ph_get_regFirstSreg() -> size_t""" + """ + ph_get_regFirstSreg() -> size_t + + + Returns the 'ph.regFirstSreg' + """ return _idaapi.ph_get_regFirstSreg(*args) def ph_get_regLastSreg(*args): - """ph_get_regLastSreg() -> size_t""" + """ + ph_get_regLastSreg() -> size_t + + + Returns the 'ph.regLastSreg' + """ return _idaapi.ph_get_regLastSreg(*args) def ph_get_segreg_size(*args): - """ph_get_segreg_size() -> size_t""" + """ + ph_get_segreg_size() -> size_t + + + Returns the 'ph.segreg_size' + """ return _idaapi.ph_get_segreg_size(*args) def ph_get_regCodeSreg(*args): - """ph_get_regCodeSreg() -> size_t""" + """ + ph_get_regCodeSreg() -> size_t + + + Returns the 'ph.regCodeSreg' + """ return _idaapi.ph_get_regCodeSreg(*args) def ph_get_regDataSreg(*args): - """ph_get_regDataSreg() -> size_t""" + """ + ph_get_regDataSreg() -> size_t + + + Returns the 'ph.regDataSreg' + """ return _idaapi.ph_get_regDataSreg(*args) def ph_get_high_fixup_bits(*args): - """ph_get_high_fixup_bits() -> size_t""" + """ + ph_get_high_fixup_bits() -> size_t + + + Returns the 'ph.high_fixup_bits' + """ return _idaapi.ph_get_high_fixup_bits(*args) def ph_get_icode_return(*args): - """ph_get_icode_return() -> size_t""" + """ + ph_get_icode_return() -> size_t + + + Returns the 'ph.icode_return' + """ return _idaapi.ph_get_icode_return(*args) def ph_get_instruc_start(*args): - """ph_get_instruc_start() -> size_t""" + """ + ph_get_instruc_start() -> size_t + + + Returns the 'ph.instruc_start' + """ return _idaapi.ph_get_instruc_start(*args) def ph_get_instruc_end(*args): - """ph_get_instruc_end() -> size_t""" + """ + ph_get_instruc_end() -> size_t + + + Returns the 'ph.instruc_end' + """ return _idaapi.ph_get_instruc_end(*args) def ph_get_tbyte_size(*args): - """ph_get_tbyte_size() -> size_t""" + """ + ph_get_tbyte_size() -> size_t + + + Returns the 'ph.tbyte_size' field as defined in he processor module + """ return _idaapi.ph_get_tbyte_size(*args) def ph_get_instruc(*args): - """ph_get_instruc() -> PyObject *""" + """ + ph_get_instruc() -> PyObject * + + + Returns a list of tuples (instruction_name, instruction_feature) containing the + instructions list as defined in he processor module + """ return _idaapi.ph_get_instruc(*args) def ph_get_regnames(*args): - """ph_get_regnames() -> PyObject *""" + """ + ph_get_regnames() -> PyObject * + + + Returns the list of register names as defined in the processor module + """ return _idaapi.ph_get_regnames(*args) def ph_get_operand_info(*args): - """ph_get_operand_info(ea, n) -> PyObject *""" + """ + ph_get_operand_info(ea, n) -> PyObject * + + + Returns the operand information given an ea and operand number. + + @param ea: address + @param n: operand number + + @return: Returns an idd_opinfo_t as a tuple: (modified, ea, reg_ival, regidx, value_size). + Please refer to idd_opinfo_t structure in the SDK. + """ return _idaapi.ph_get_operand_info(*args) class IDP_Hooks(object): - """Proxy of C++ IDP_Hooks class""" + """ + Proxy of C++ IDP_Hooks class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr __swig_destroy__ = _idaapi.delete_IDP_Hooks __del__ = lambda self : None; def hook(self, *args): - """hook(self) -> bool""" + """ + hook(self) -> bool + + + Creates an IDP hook + + @return: Boolean true on success + """ return _idaapi.IDP_Hooks_hook(self, *args) def unhook(self, *args): - """unhook(self) -> bool""" + """ + unhook(self) -> bool + + + Removes the IDP hook + @return: Boolean true on success + """ return _idaapi.IDP_Hooks_unhook(self, *args) def custom_ana(self, *args): - """custom_ana(self) -> bool""" + """ + custom_ana(self) -> bool + + + Analyzes and decodes an instruction at idaapi.cmd.ea + - cmd.itype must be set >= idaapi.CUSTOM_CMD_ITYPE + - cmd.size must be set to the instruction length + + @return: Boolean + - False if the instruction is not recognized + - True if the instruction was decoded. idaapi.cmd should be filled in that case. + """ return _idaapi.IDP_Hooks_custom_ana(self, *args) def custom_out(self, *args): - """custom_out(self) -> bool""" + """ + custom_out(self) -> bool + + + Outputs the instruction defined in idaapi.cmd + + @return: Boolean (whether this instruction can be outputted or not) + """ return _idaapi.IDP_Hooks_custom_out(self, *args) def custom_emu(self, *args): - """custom_emu(self) -> bool""" + """ + custom_emu(self) -> bool + + + Emulate instruction, create cross-references, plan to analyze + subsequent instructions, modify flags etc. Upon entrance to this function + all information about the instruction is in 'cmd' structure. + + @return: Boolean (whether this instruction has been emulated or not) + """ return _idaapi.IDP_Hooks_custom_emu(self, *args) def custom_outop(self, *args): - """custom_outop(self, py_op) -> bool""" + """ + custom_outop(self, py_op) -> bool + + + Notification to generate operand text. + If False was returned, then the standard operand output function will be called. + + The output buffer is inited with init_output_buffer() + and this notification may use out_...() functions to form the operand text + + @return: Boolean (whether the operand has been outputted or not) + """ return _idaapi.IDP_Hooks_custom_outop(self, *args) def custom_mnem(self, *args): - """custom_mnem(self) -> PyObject *""" + """ + custom_mnem(self) -> PyObject * + + + Prints the mnemonic of the instruction defined in idaapi.cmd + + @return: + - None: No mnemonic. IDA will use the default mnemonic value if present + - String: The desired mnemonic string + """ return _idaapi.IDP_Hooks_custom_mnem(self, *args) def is_sane_insn(self, *args): - """is_sane_insn(self, no_crefs) -> int""" + """ + is_sane_insn(self, no_crefs) -> int + + + is the instruction sane for the current file type? + @param no_crefs: + - 1: the instruction has no code refs to it. + ida just tries to convert unexplored bytes + to an instruction (but there is no other + reason to convert them into an instruction) + - 0: the instruction is created because + of some coderef, user request or another + weighty reason. + @return: 1-ok, <=0-no, the instruction isn't likely to appear in the program + """ return _idaapi.IDP_Hooks_is_sane_insn(self, *args) def may_be_func(self, *args): - """may_be_func(self, state) -> int""" + """ + may_be_func(self, state) -> int + + + Can a function start here? + @param state: autoanalysis phase + 0: creating functions + 1: creating chunks + + @return: integer (probability 0..100) + """ return _idaapi.IDP_Hooks_may_be_func(self, *args) def closebase(self, *args): - """closebase(self) -> int""" + """ + closebase(self) -> int + + + The database will be closed now + """ return _idaapi.IDP_Hooks_closebase(self, *args) def savebase(self, *args): - """savebase(self)""" + """ + savebase(self) + + + The database is being saved. Processor module should + """ return _idaapi.IDP_Hooks_savebase(self, *args) - def auto_empty_finally(self, *args): - """auto_empty_finally(self)""" - return _idaapi.IDP_Hooks_auto_empty_finally(self, *args) - def rename(self, *args): - """rename(self, ea, new_name) -> int""" + """ + rename(self, ea, new_name) -> int + + + The kernel is going to rename a byte. + + @param ea: Address + @param new_name: The new name + + @return: + - If returns value <=0, then the kernel should + not rename it. See also the 'renamed' event + """ return _idaapi.IDP_Hooks_rename(self, *args) def renamed(self, *args): - """renamed(self, ea, new_name, local_name)""" + """ + renamed(self, ea, new_name, local_name) + + + The kernel has renamed a byte + + @param ea: Address + @param new_name: The new name + @param local_name: Is local name + + @return: Ignored + """ return _idaapi.IDP_Hooks_renamed(self, *args) def undefine(self, *args): - """undefine(self, ea) -> int""" + """ + undefine(self, ea) -> int + + + An item in the database (insn or data) is being deleted + @param ea: Address + @return: + - returns: >0-ok, <=0-the kernel should stop + - if the return value is positive: + bit0 - ignored + bit1 - do not delete srareas at the item end + """ return _idaapi.IDP_Hooks_undefine(self, *args) def make_code(self, *args): - """make_code(self, ea, size) -> int""" + """ + make_code(self, ea, size) -> int + + + An instruction is being created + @param ea: Address + @param size: Instruction size + @return: 1-ok, <=0-the kernel should stop + """ return _idaapi.IDP_Hooks_make_code(self, *args) def make_data(self, *args): - """make_data(self, ea, flags, tid, len) -> int""" + """ + make_data(self, ea, flags, tid, len) -> int + + + A data item is being created + @param ea: Address + @param tid: type id + @param flags: item flags + @param len: data item size + @return: 1-ok, <=0-the kernel should stop + """ return _idaapi.IDP_Hooks_make_data(self, *args) def load_idasgn(self, *args): - """load_idasgn(self, short_sig_name)""" + """ + load_idasgn(self, short_sig_name) + + + FLIRT signature have been loaded for normal processing + (not for recognition of startup sequences) + @param short_sig_name: signature name + @return: Ignored + """ return _idaapi.IDP_Hooks_load_idasgn(self, *args) - def auto_empty(self, *args): - """auto_empty(self)""" - return _idaapi.IDP_Hooks_auto_empty(self, *args) - - def auto_queue_empty(self, *args): - """auto_queue_empty(self, type) -> int""" - return _idaapi.IDP_Hooks_auto_queue_empty(self, *args) - def add_func(self, *args): - """add_func(self, func)""" + """ + add_func(self, func) + + + The kernel has added a function + @param func: the func_t instance + @return: Ignored + """ return _idaapi.IDP_Hooks_add_func(self, *args) def del_func(self, *args): - """del_func(self, func) -> int""" + """ + del_func(self, func) -> int + + + The kernel is about to delete a function + @param func: the func_t instance + @return: 1-ok,<=0-do not delete + """ return _idaapi.IDP_Hooks_del_func(self, *args) def is_call_insn(self, *args): - """is_call_insn(self, arg0) -> int""" + """ + is_call_insn(self, arg0) -> int + + + Is the instruction a "call"? + + @param ea: instruction address + @return: 1-unknown, 0-no, 2-yes + """ return _idaapi.IDP_Hooks_is_call_insn(self, *args) def is_ret_insn(self, *args): - """is_ret_insn(self, arg0, arg1) -> int""" + """ + is_ret_insn(self, arg0, arg1) -> int + + + Is the instruction a "return"? + + @param ea: instruction address + @param strict: - True: report only ret instructions + False: include instructions like "leave" which begins the function epilog + @return: 1-unknown, 0-no, 2-yes + """ return _idaapi.IDP_Hooks_is_ret_insn(self, *args) def assemble(self, *args): - """assemble(self, arg0, arg1, arg2, arg3, arg4) -> PyObject *""" + """ + assemble(self, arg0, arg1, arg2, arg3, arg4) -> PyObject * + + + Assembles an instruction + + @param ea: linear address of instruction + @param cs: cs of instruction + @param ip: ip of instruction + @param use32: is 32bit segment? + @param line: line to assemble + + @return: - None to let the underlying processor module assemble the line + - or a string containing the assembled buffer + """ return _idaapi.IDP_Hooks_assemble(self, *args) - def __init__(self, *args): - """__init__(self) -> IDP_Hooks""" + def __init__(self, *args): + """ + __init__(self) -> IDP_Hooks + """ if self.__class__ == IDP_Hooks: _self = None else: @@ -3829,149 +4964,221 @@ AREACB_TYPE_SEGMENT = _idaapi.AREACB_TYPE_SEGMENT AREACB_TYPE_HIDDEN_AREA = _idaapi.AREACB_TYPE_HIDDEN_AREA AREACB_TYPE_SRAREA = _idaapi.AREACB_TYPE_SRAREA class IDB_Hooks(object): - """Proxy of C++ IDB_Hooks class""" + """ + Proxy of C++ IDB_Hooks class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr __swig_destroy__ = _idaapi.delete_IDB_Hooks __del__ = lambda self : None; def hook(self, *args): - """hook(self) -> bool""" + """ + hook(self) -> bool + """ return _idaapi.IDB_Hooks_hook(self, *args) def unhook(self, *args): - """unhook(self) -> bool""" + """ + unhook(self) -> bool + """ return _idaapi.IDB_Hooks_unhook(self, *args) def byte_patched(self, *args): - """byte_patched(self, arg0) -> int""" + """ + byte_patched(self, arg0) -> int + """ return _idaapi.IDB_Hooks_byte_patched(self, *args) def cmt_changed(self, *args): - """cmt_changed(self, arg0, arg1) -> int""" + """ + cmt_changed(self, arg0, arg1) -> int + """ return _idaapi.IDB_Hooks_cmt_changed(self, *args) def area_cmt_changed(self, *args): - """area_cmt_changed(self, arg0, arg1, arg2, arg3) -> int""" + """ + area_cmt_changed(self, arg0, arg1, arg2, arg3) -> int + """ return _idaapi.IDB_Hooks_area_cmt_changed(self, *args) def ti_changed(self, *args): - """ti_changed(self, arg0, arg1, arg2) -> int""" + """ + ti_changed(self, arg0, arg1, arg2) -> int + """ return _idaapi.IDB_Hooks_ti_changed(self, *args) def op_ti_changed(self, *args): - """op_ti_changed(self, arg0, arg1, arg2, arg3) -> int""" + """ + op_ti_changed(self, arg0, arg1, arg2, arg3) -> int + """ return _idaapi.IDB_Hooks_op_ti_changed(self, *args) def op_type_changed(self, *args): - """op_type_changed(self, arg0, arg1) -> int""" + """ + op_type_changed(self, arg0, arg1) -> int + """ return _idaapi.IDB_Hooks_op_type_changed(self, *args) def enum_created(self, *args): - """enum_created(self, arg0) -> int""" + """ + enum_created(self, arg0) -> int + """ return _idaapi.IDB_Hooks_enum_created(self, *args) def enum_deleted(self, *args): - """enum_deleted(self, arg0) -> int""" + """ + enum_deleted(self, arg0) -> int + """ return _idaapi.IDB_Hooks_enum_deleted(self, *args) def enum_bf_changed(self, *args): - """enum_bf_changed(self, arg0) -> int""" + """ + enum_bf_changed(self, arg0) -> int + """ return _idaapi.IDB_Hooks_enum_bf_changed(self, *args) def enum_renamed(self, *args): - """enum_renamed(self, arg0) -> int""" + """ + enum_renamed(self, arg0) -> int + """ return _idaapi.IDB_Hooks_enum_renamed(self, *args) def enum_cmt_changed(self, *args): - """enum_cmt_changed(self, arg0) -> int""" + """ + enum_cmt_changed(self, arg0) -> int + """ return _idaapi.IDB_Hooks_enum_cmt_changed(self, *args) def enum_member_created(self, *args): - """enum_member_created(self, arg0, cid) -> int""" + """ + enum_member_created(self, arg0, cid) -> int + """ return _idaapi.IDB_Hooks_enum_member_created(self, *args) def enum_member_deleted(self, *args): - """enum_member_deleted(self, arg0, cid) -> int""" + """ + enum_member_deleted(self, arg0, cid) -> int + """ return _idaapi.IDB_Hooks_enum_member_deleted(self, *args) def struc_created(self, *args): - """struc_created(self, arg0) -> int""" + """ + struc_created(self, arg0) -> int + """ return _idaapi.IDB_Hooks_struc_created(self, *args) def struc_deleted(self, *args): - """struc_deleted(self, arg0) -> int""" + """ + struc_deleted(self, arg0) -> int + """ return _idaapi.IDB_Hooks_struc_deleted(self, *args) def struc_renamed(self, *args): - """struc_renamed(self, arg0) -> int""" + """ + struc_renamed(self, arg0) -> int + """ return _idaapi.IDB_Hooks_struc_renamed(self, *args) def struc_expanded(self, *args): - """struc_expanded(self, arg0) -> int""" + """ + struc_expanded(self, arg0) -> int + """ return _idaapi.IDB_Hooks_struc_expanded(self, *args) def struc_cmt_changed(self, *args): - """struc_cmt_changed(self, arg0) -> int""" + """ + struc_cmt_changed(self, arg0) -> int + """ return _idaapi.IDB_Hooks_struc_cmt_changed(self, *args) def struc_member_created(self, *args): - """struc_member_created(self, arg0, arg1) -> int""" + """ + struc_member_created(self, arg0, arg1) -> int + """ return _idaapi.IDB_Hooks_struc_member_created(self, *args) def struc_member_deleted(self, *args): - """struc_member_deleted(self, arg0, arg1, arg2) -> int""" + """ + struc_member_deleted(self, arg0, arg1, arg2) -> int + """ return _idaapi.IDB_Hooks_struc_member_deleted(self, *args) def struc_member_renamed(self, *args): - """struc_member_renamed(self, arg0, arg1) -> int""" + """ + struc_member_renamed(self, arg0, arg1) -> int + """ return _idaapi.IDB_Hooks_struc_member_renamed(self, *args) def struc_member_changed(self, *args): - """struc_member_changed(self, arg0, arg1) -> int""" + """ + struc_member_changed(self, arg0, arg1) -> int + """ return _idaapi.IDB_Hooks_struc_member_changed(self, *args) def thunk_func_created(self, *args): - """thunk_func_created(self, arg0) -> int""" + """ + thunk_func_created(self, arg0) -> int + """ return _idaapi.IDB_Hooks_thunk_func_created(self, *args) def func_tail_appended(self, *args): - """func_tail_appended(self, arg0, arg1) -> int""" + """ + func_tail_appended(self, arg0, arg1) -> int + """ return _idaapi.IDB_Hooks_func_tail_appended(self, *args) def func_tail_removed(self, *args): - """func_tail_removed(self, arg0, arg1) -> int""" + """ + func_tail_removed(self, arg0, arg1) -> int + """ return _idaapi.IDB_Hooks_func_tail_removed(self, *args) def tail_owner_changed(self, *args): - """tail_owner_changed(self, arg0, arg1) -> int""" + """ + tail_owner_changed(self, arg0, arg1) -> int + """ return _idaapi.IDB_Hooks_tail_owner_changed(self, *args) def func_noret_changed(self, *args): - """func_noret_changed(self, arg0) -> int""" + """ + func_noret_changed(self, arg0) -> int + """ return _idaapi.IDB_Hooks_func_noret_changed(self, *args) def segm_added(self, *args): - """segm_added(self, arg0) -> int""" + """ + segm_added(self, arg0) -> int + """ return _idaapi.IDB_Hooks_segm_added(self, *args) def segm_deleted(self, *args): - """segm_deleted(self, arg0) -> int""" + """ + segm_deleted(self, arg0) -> int + """ return _idaapi.IDB_Hooks_segm_deleted(self, *args) def segm_start_changed(self, *args): - """segm_start_changed(self, arg0) -> int""" + """ + segm_start_changed(self, arg0) -> int + """ return _idaapi.IDB_Hooks_segm_start_changed(self, *args) def segm_end_changed(self, *args): - """segm_end_changed(self, arg0) -> int""" + """ + segm_end_changed(self, arg0) -> int + """ return _idaapi.IDB_Hooks_segm_end_changed(self, *args) def segm_moved(self, *args): - """segm_moved(self, arg0, arg1, arg2) -> int""" + """ + segm_moved(self, arg0, arg1, arg2) -> int + """ return _idaapi.IDB_Hooks_segm_moved(self, *args) - def __init__(self, *args): - """__init__(self) -> IDB_Hooks""" + def __init__(self, *args): + """ + __init__(self) -> IDB_Hooks + """ if self.__class__ == IDB_Hooks: _self = None else: @@ -3987,10 +5194,12 @@ IDB_Hooks_swigregister = _idaapi.IDB_Hooks_swigregister IDB_Hooks_swigregister(IDB_Hooks) class netnode(object): - """Proxy of C++ netnode class""" + """ + Proxy of C++ netnode class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> netnode __init__(self, num) -> netnode @@ -4007,163 +5216,237 @@ class netnode(object): return _idaapi.netnode_create(self, *args) def kill(self, *args): - """kill(self)""" + """ + kill(self) + """ return _idaapi.netnode_kill(self, *args) - def get_name(self, *args): - """get_name(self, buf) -> ssize_t""" - return _idaapi.netnode_get_name(self, *args) - def name(self, *args): - """name(self) -> ssize_t""" + """ + name(self) -> ssize_t + """ return _idaapi.netnode_name(self, *args) def rename(self, *args): - """rename(self, newname, namlen=0) -> bool""" + """ + rename(self, newname, namlen=0) -> bool + """ return _idaapi.netnode_rename(self, *args) def valobj(self, *args): - """valobj(self) -> ssize_t""" + """ + valobj(self) -> ssize_t + """ return _idaapi.netnode_valobj(self, *args) def valstr(self, *args): - """valstr(self) -> ssize_t""" + """ + valstr(self) -> ssize_t + """ return _idaapi.netnode_valstr(self, *args) def set(self, *args): - """set(self, value) -> bool""" + """ + set(self, value) -> bool + """ return _idaapi.netnode_set(self, *args) def delvalue(self, *args): - """delvalue(self) -> bool""" + """ + delvalue(self) -> bool + """ return _idaapi.netnode_delvalue(self, *args) def set_long(self, *args): - """set_long(self, x) -> bool""" + """ + set_long(self, x) -> bool + """ return _idaapi.netnode_set_long(self, *args) def value_exists(self, *args): - """value_exists(self) -> bool""" + """ + value_exists(self) -> bool + """ return _idaapi.netnode_value_exists(self, *args) def long_value(self, *args): - """long_value(self) -> nodeidx_t""" + """ + long_value(self) -> nodeidx_t + """ return _idaapi.netnode_long_value(self, *args) def altval(self, *args): - """altval(self, alt, tag=atag) -> nodeidx_t""" + """ + altval(self, alt, tag=atag) -> nodeidx_t + """ return _idaapi.netnode_altval(self, *args) def altset(self, *args): - """altset(self, alt, value, tag=atag) -> bool""" + """ + altset(self, alt, value, tag=atag) -> bool + """ return _idaapi.netnode_altset(self, *args) def alt1st(self, *args): - """alt1st(self, tag=atag) -> nodeidx_t""" + """ + alt1st(self, tag=atag) -> nodeidx_t + """ return _idaapi.netnode_alt1st(self, *args) def altnxt(self, *args): - """altnxt(self, cur, tag=atag) -> nodeidx_t""" + """ + altnxt(self, cur, tag=atag) -> nodeidx_t + """ return _idaapi.netnode_altnxt(self, *args) def altlast(self, *args): - """altlast(self, tag=atag) -> nodeidx_t""" + """ + altlast(self, tag=atag) -> nodeidx_t + """ return _idaapi.netnode_altlast(self, *args) def altprev(self, *args): - """altprev(self, cur, tag=atag) -> nodeidx_t""" + """ + altprev(self, cur, tag=atag) -> nodeidx_t + """ return _idaapi.netnode_altprev(self, *args) def altshift(self, *args): - """altshift(self, frm, to, size, tag=atag) -> size_t""" + """ + altshift(self, frm, to, size, tag=atag) -> size_t + """ return _idaapi.netnode_altshift(self, *args) def charval(self, *args): - """charval(self, alt, tag) -> uchar""" + """ + charval(self, alt, tag) -> uchar + """ return _idaapi.netnode_charval(self, *args) def charset(self, *args): - """charset(self, alt, val, tag) -> bool""" + """ + charset(self, alt, val, tag) -> bool + """ return _idaapi.netnode_charset(self, *args) def chardel(self, *args): - """chardel(self, alt, tag) -> bool""" + """ + chardel(self, alt, tag) -> bool + """ return _idaapi.netnode_chardel(self, *args) def char1st(self, *args): - """char1st(self, tag) -> nodeidx_t""" + """ + char1st(self, tag) -> nodeidx_t + """ return _idaapi.netnode_char1st(self, *args) def charnxt(self, *args): - """charnxt(self, cur, tag) -> nodeidx_t""" + """ + charnxt(self, cur, tag) -> nodeidx_t + """ return _idaapi.netnode_charnxt(self, *args) def charlast(self, *args): - """charlast(self, tag) -> nodeidx_t""" + """ + charlast(self, tag) -> nodeidx_t + """ return _idaapi.netnode_charlast(self, *args) def charprev(self, *args): - """charprev(self, cur, tag) -> nodeidx_t""" + """ + charprev(self, cur, tag) -> nodeidx_t + """ return _idaapi.netnode_charprev(self, *args) def charshift(self, *args): - """charshift(self, frm, to, size, tag) -> size_t""" + """ + charshift(self, frm, to, size, tag) -> size_t + """ return _idaapi.netnode_charshift(self, *args) def altval_idx8(self, *args): - """altval_idx8(self, alt, tag) -> nodeidx_t""" + """ + altval_idx8(self, alt, tag) -> nodeidx_t + """ return _idaapi.netnode_altval_idx8(self, *args) def altset_idx8(self, *args): - """altset_idx8(self, alt, val, tag) -> bool""" + """ + altset_idx8(self, alt, val, tag) -> bool + """ return _idaapi.netnode_altset_idx8(self, *args) def altdel_idx8(self, *args): - """altdel_idx8(self, alt, tag) -> bool""" + """ + altdel_idx8(self, alt, tag) -> bool + """ return _idaapi.netnode_altdel_idx8(self, *args) def alt1st_idx8(self, *args): - """alt1st_idx8(self, tag) -> nodeidx_t""" + """ + alt1st_idx8(self, tag) -> nodeidx_t + """ return _idaapi.netnode_alt1st_idx8(self, *args) def altnxt_idx8(self, *args): - """altnxt_idx8(self, cur, tag) -> nodeidx_t""" + """ + altnxt_idx8(self, cur, tag) -> nodeidx_t + """ return _idaapi.netnode_altnxt_idx8(self, *args) def altlast_idx8(self, *args): - """altlast_idx8(self, tag) -> nodeidx_t""" + """ + altlast_idx8(self, tag) -> nodeidx_t + """ return _idaapi.netnode_altlast_idx8(self, *args) def altprev_idx8(self, *args): - """altprev_idx8(self, cur, tag) -> nodeidx_t""" + """ + altprev_idx8(self, cur, tag) -> nodeidx_t + """ return _idaapi.netnode_altprev_idx8(self, *args) def charval_idx8(self, *args): - """charval_idx8(self, alt, tag) -> uchar""" + """ + charval_idx8(self, alt, tag) -> uchar + """ return _idaapi.netnode_charval_idx8(self, *args) def charset_idx8(self, *args): - """charset_idx8(self, alt, val, tag) -> bool""" + """ + charset_idx8(self, alt, val, tag) -> bool + """ return _idaapi.netnode_charset_idx8(self, *args) def chardel_idx8(self, *args): - """chardel_idx8(self, alt, tag) -> bool""" + """ + chardel_idx8(self, alt, tag) -> bool + """ return _idaapi.netnode_chardel_idx8(self, *args) def char1st_idx8(self, *args): - """char1st_idx8(self, tag) -> nodeidx_t""" + """ + char1st_idx8(self, tag) -> nodeidx_t + """ return _idaapi.netnode_char1st_idx8(self, *args) def charnxt_idx8(self, *args): - """charnxt_idx8(self, cur, tag) -> nodeidx_t""" + """ + charnxt_idx8(self, cur, tag) -> nodeidx_t + """ return _idaapi.netnode_charnxt_idx8(self, *args) def charlast_idx8(self, *args): - """charlast_idx8(self, tag) -> nodeidx_t""" + """ + charlast_idx8(self, tag) -> nodeidx_t + """ return _idaapi.netnode_charlast_idx8(self, *args) def charprev_idx8(self, *args): - """charprev_idx8(self, cur, tag) -> nodeidx_t""" + """ + charprev_idx8(self, cur, tag) -> nodeidx_t + """ return _idaapi.netnode_charprev_idx8(self, *args) def altdel(self, *args): @@ -4174,71 +5457,105 @@ class netnode(object): return _idaapi.netnode_altdel(self, *args) def altdel_all(self, *args): - """altdel_all(self, tag) -> bool""" + """ + altdel_all(self, tag) -> bool + """ return _idaapi.netnode_altdel_all(self, *args) def supval(self, *args): - """supval(self, alt, tag=stag) -> ssize_t""" + """ + supval(self, alt, tag=stag) -> ssize_t + """ return _idaapi.netnode_supval(self, *args) def supstr(self, *args): - """supstr(self, alt, tag=stag) -> ssize_t""" + """ + supstr(self, alt, tag=stag) -> ssize_t + """ return _idaapi.netnode_supstr(self, *args) def supset(self, *args): - """supset(self, alt, value, tag=stag) -> bool""" + """ + supset(self, alt, value, tag=stag) -> bool + """ return _idaapi.netnode_supset(self, *args) def sup1st(self, *args): - """sup1st(self, tag=stag) -> nodeidx_t""" + """ + sup1st(self, tag=stag) -> nodeidx_t + """ return _idaapi.netnode_sup1st(self, *args) def supnxt(self, *args): - """supnxt(self, cur, tag=stag) -> nodeidx_t""" + """ + supnxt(self, cur, tag=stag) -> nodeidx_t + """ return _idaapi.netnode_supnxt(self, *args) def suplast(self, *args): - """suplast(self, tag=stag) -> nodeidx_t""" + """ + suplast(self, tag=stag) -> nodeidx_t + """ return _idaapi.netnode_suplast(self, *args) def supprev(self, *args): - """supprev(self, cur, tag=stag) -> nodeidx_t""" + """ + supprev(self, cur, tag=stag) -> nodeidx_t + """ return _idaapi.netnode_supprev(self, *args) def supshift(self, *args): - """supshift(self, frm, to, size, tag=stag) -> size_t""" + """ + supshift(self, frm, to, size, tag=stag) -> size_t + """ return _idaapi.netnode_supshift(self, *args) def supval_idx8(self, *args): - """supval_idx8(self, alt, tag) -> ssize_t""" + """ + supval_idx8(self, alt, tag) -> ssize_t + """ return _idaapi.netnode_supval_idx8(self, *args) def supstr_idx8(self, *args): - """supstr_idx8(self, alt, tag) -> ssize_t""" + """ + supstr_idx8(self, alt, tag) -> ssize_t + """ return _idaapi.netnode_supstr_idx8(self, *args) def supset_idx8(self, *args): - """supset_idx8(self, alt, value, tag) -> bool""" + """ + supset_idx8(self, alt, value, tag) -> bool + """ return _idaapi.netnode_supset_idx8(self, *args) def supdel_idx8(self, *args): - """supdel_idx8(self, alt, tag) -> bool""" + """ + supdel_idx8(self, alt, tag) -> bool + """ return _idaapi.netnode_supdel_idx8(self, *args) def sup1st_idx8(self, *args): - """sup1st_idx8(self, tag) -> nodeidx_t""" + """ + sup1st_idx8(self, tag) -> nodeidx_t + """ return _idaapi.netnode_sup1st_idx8(self, *args) def supnxt_idx8(self, *args): - """supnxt_idx8(self, alt, tag) -> nodeidx_t""" + """ + supnxt_idx8(self, alt, tag) -> nodeidx_t + """ return _idaapi.netnode_supnxt_idx8(self, *args) def suplast_idx8(self, *args): - """suplast_idx8(self, tag) -> nodeidx_t""" + """ + suplast_idx8(self, tag) -> nodeidx_t + """ return _idaapi.netnode_suplast_idx8(self, *args) def supprev_idx8(self, *args): - """supprev_idx8(self, alt, tag) -> nodeidx_t""" + """ + supprev_idx8(self, alt, tag) -> nodeidx_t + """ return _idaapi.netnode_supprev_idx8(self, *args) def supdel(self, *args): @@ -4249,95 +5566,141 @@ class netnode(object): return _idaapi.netnode_supdel(self, *args) def supdel_all(self, *args): - """supdel_all(self, tag) -> bool""" + """ + supdel_all(self, tag) -> bool + """ return _idaapi.netnode_supdel_all(self, *args) def supdel_range(self, *args): - """supdel_range(self, idx1, idx2, tag) -> int""" + """ + supdel_range(self, idx1, idx2, tag) -> int + """ return _idaapi.netnode_supdel_range(self, *args) def supdel_range_idx8(self, *args): - """supdel_range_idx8(self, idx1, idx2, tag) -> int""" + """ + supdel_range_idx8(self, idx1, idx2, tag) -> int + """ return _idaapi.netnode_supdel_range_idx8(self, *args) def hashval(self, *args): - """hashval(self, idx, tag=htag) -> ssize_t""" + """ + hashval(self, idx, tag=htag) -> ssize_t + """ return _idaapi.netnode_hashval(self, *args) def hashstr(self, *args): - """hashstr(self, idx, tag=htag) -> ssize_t""" + """ + hashstr(self, idx, tag=htag) -> ssize_t + """ return _idaapi.netnode_hashstr(self, *args) def hashval_long(self, *args): - """hashval_long(self, idx, tag=htag) -> nodeidx_t""" + """ + hashval_long(self, idx, tag=htag) -> nodeidx_t + """ return _idaapi.netnode_hashval_long(self, *args) def hashset(self, *args): - """hashset(self, idx, value, tag=htag) -> bool""" + """ + hashset(self, idx, value, tag=htag) -> bool + """ return _idaapi.netnode_hashset(self, *args) def hashset_idx(self, *args): - """hashset_idx(self, idx, value, tag=htag) -> bool""" + """ + hashset_idx(self, idx, value, tag=htag) -> bool + """ return _idaapi.netnode_hashset_idx(self, *args) def hashdel(self, *args): - """hashdel(self, idx, tag=htag) -> bool""" + """ + hashdel(self, idx, tag=htag) -> bool + """ return _idaapi.netnode_hashdel(self, *args) def hash1st(self, *args): - """hash1st(self, tag=htag) -> ssize_t""" + """ + hash1st(self, tag=htag) -> ssize_t + """ return _idaapi.netnode_hash1st(self, *args) def hashnxt(self, *args): - """hashnxt(self, idx, tag=htag) -> ssize_t""" + """ + hashnxt(self, idx, tag=htag) -> ssize_t + """ return _idaapi.netnode_hashnxt(self, *args) def hashlast(self, *args): - """hashlast(self, tag=htag) -> ssize_t""" + """ + hashlast(self, tag=htag) -> ssize_t + """ return _idaapi.netnode_hashlast(self, *args) def hashprev(self, *args): - """hashprev(self, idx, tag=htag) -> ssize_t""" + """ + hashprev(self, idx, tag=htag) -> ssize_t + """ return _idaapi.netnode_hashprev(self, *args) def hashdel_all(self, *args): - """hashdel_all(self, tag=htag) -> bool""" + """ + hashdel_all(self, tag=htag) -> bool + """ return _idaapi.netnode_hashdel_all(self, *args) def blobsize(self, *args): - """blobsize(self, _start, tag) -> size_t""" + """ + blobsize(self, _start, tag) -> size_t + """ return _idaapi.netnode_blobsize(self, *args) def setblob(self, *args): - """setblob(self, buf, _start, tag) -> bool""" + """ + setblob(self, buf, _start, tag) -> bool + """ return _idaapi.netnode_setblob(self, *args) def delblob(self, *args): - """delblob(self, _start, tag) -> int""" + """ + delblob(self, _start, tag) -> int + """ return _idaapi.netnode_delblob(self, *args) def start(self, *args): - """start(self) -> bool""" + """ + start(self) -> bool + """ return _idaapi.netnode_start(self, *args) def end(self, *args): - """end(self) -> bool""" + """ + end(self) -> bool + """ return _idaapi.netnode_end(self, *args) def next(self, *args): - """next(self) -> bool""" + """ + next(self) -> bool + """ return _idaapi.netnode_next(self, *args) def prev(self, *args): - """prev(self) -> bool""" + """ + prev(self) -> bool + """ return _idaapi.netnode_prev(self, *args) def copyto(self, *args): - """copyto(self, target, count=1) -> size_t""" + """ + copyto(self, target, count=1) -> size_t + """ return _idaapi.netnode_copyto(self, *args) def moveto(self, *args): - """moveto(self, target, count=1) -> size_t""" + """ + moveto(self, target, count=1) -> size_t + """ return _idaapi.netnode_moveto(self, *args) def __eq__(self, *args): @@ -4355,27 +5718,35 @@ class netnode(object): return _idaapi.netnode___ne__(self, *args) def index(self, *args): - """index(self) -> nodeidx_t""" + """ + index(self) -> nodeidx_t + """ return _idaapi.netnode_index(self, *args) def getblob(self, *args): - """getblob(self, start, tag) -> PyObject *""" + """ + getblob(self, start, tag) -> PyObject * + """ return _idaapi.netnode_getblob(self, *args) def hashstr_buf(self, *args): - """hashstr_buf(self, idx, tag=htag) -> PyObject *""" + """ + hashstr_buf(self, idx, tag=htag) -> PyObject * + """ return _idaapi.netnode_hashstr_buf(self, *args) def hashset_buf(self, *args): - """hashset_buf(self, idx, py_str, tag=htag) -> bool""" + """ + hashset_buf(self, idx, py_str, tag=htag) -> bool + """ return _idaapi.netnode_hashset_buf(self, *args) __swig_destroy__ = _idaapi.delete_netnode __del__ = lambda self : None; netnode_swigregister = _idaapi.netnode_swigregister netnode_swigregister(netnode) +BTREE_PAGE_SIZE = cvar.BTREE_PAGE_SIZE MAXNAMESIZE = cvar.MAXNAMESIZE -MAX_NODENAME_SIZE = cvar.MAX_NODENAME_SIZE MAXSPECSIZE = cvar.MAXSPECSIZE atag = cvar.atag stag = cvar.stag @@ -4383,35 +5754,41 @@ htag = cvar.htag vtag = cvar.vtag ntag = cvar.ntag ltag = cvar.ltag - -def exist(*args): - """exist(n) -> bool""" - return _idaapi.exist(*args) NNBASE_OK = _idaapi.NNBASE_OK NNBASE_REPAIR = _idaapi.NNBASE_REPAIR NNBASE_IOERR = _idaapi.NNBASE_IOERR NNBASE_PAGE16 = _idaapi.NNBASE_PAGE16 class ids_array(object): - """Proxy of C++ wrapped_array_t<(tid_t,32)> class""" + """ + Proxy of C++ wrapped_array_t<(tid_t,32)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr data = _swig_property(_idaapi.ids_array_data_get) - def __init__(self, *args): - """__init__(self, data) -> ids_array""" + def __init__(self, *args): + """ + __init__(self, data) -> ids_array + """ this = _idaapi.new_ids_array(*args) try: self.this.append(this) except: self.this = this def __len__(self, *args): - """__len__(self) -> size_t""" + """ + __len__(self) -> size_t + """ return _idaapi.ids_array___len__(self, *args) def __getitem__(self, *args): - """__getitem__(self, i) -> unsigned int const &""" + """ + __getitem__(self, i) -> unsigned int const & + """ return _idaapi.ids_array___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, i, v)""" + """ + __setitem__(self, i, v) + """ return _idaapi.ids_array___setitem__(self, *args) __iter__ = _bounded_getitem_iterator @@ -4421,6 +5798,7 @@ class ids_array(object): ids_array_swigregister = _idaapi.ids_array_swigregister ids_array_swigregister(ids_array) +PATCH_TAG = _idaapi.PATCH_TAG NALT_SWITCH = _idaapi.NALT_SWITCH NALT_STRUCT = _idaapi.NALT_STRUCT NALT_AFLAGS = _idaapi.NALT_AFLAGS @@ -4461,7 +5839,6 @@ NSUP_OREF4 = _idaapi.NSUP_OREF4 NSUP_OREF5 = _idaapi.NSUP_OREF5 NSUP_XREFPOS = _idaapi.NSUP_XREFPOS NSUP_CUSTDT = _idaapi.NSUP_CUSTDT -NSUP_GROUPS = _idaapi.NSUP_GROUPS NSUP_POINTS = _idaapi.NSUP_POINTS NSUP_MANUAL = _idaapi.NSUP_MANUAL NSUP_TYPEINFO = _idaapi.NSUP_TYPEINFO @@ -4478,7 +5855,72 @@ NALT_DREF_FROM = _idaapi.NALT_DREF_FROM NSUP_GR_INFO = _idaapi.NSUP_GR_INFO NALT_GR_LAYX = _idaapi.NALT_GR_LAYX NSUP_GR_LAYT = _idaapi.NSUP_GR_LAYT -PATCH_TAG = _idaapi.PATCH_TAG + +def get_wide_value(*args): + """ + get_wide_value(ea) -> uint32 + """ + return _idaapi.get_wide_value(*args) + +def set_wide_value(*args): + """ + set_wide_value(ea, x) + """ + return _idaapi.set_wide_value(*args) + +def del_wide_value(*args): + """ + del_wide_value(ea) + """ + return _idaapi.del_wide_value(*args) + +def set_aflags0(*args): + """ + set_aflags0(ea, flags) + """ + return _idaapi.set_aflags0(*args) + +def get_aflags0(*args): + """ + get_aflags0(ea) -> uint32 + """ + return _idaapi.get_aflags0(*args) + +def del_aflags0(*args): + """ + del_aflags0(ea) + """ + return _idaapi.del_aflags0(*args) + +def set_aflags(*args): + """ + set_aflags(ea, flags) + """ + return _idaapi.set_aflags(*args) + +def set_abits(*args): + """ + set_abits(ea, bits) + """ + return _idaapi.set_abits(*args) + +def clr_abits(*args): + """ + clr_abits(ea, bits) + """ + return _idaapi.clr_abits(*args) + +def get_aflags(*args): + """ + get_aflags(ea) -> uint32 + """ + return _idaapi.get_aflags(*args) + +def del_aflags(*args): + """ + del_aflags(ea) + """ + return _idaapi.del_aflags(*args) AFL_LINNUM = _idaapi.AFL_LINNUM AFL_USERSP = _idaapi.AFL_USERSP AFL_PUBNAM = _idaapi.AFL_PUBNAM @@ -4509,370 +5951,600 @@ AFL_RETFP = _idaapi.AFL_RETFP AFL_USEMODSP = _idaapi.AFL_USEMODSP AFL_NOTCODE = _idaapi.AFL_NOTCODE -def set_aflags(*args): - """set_aflags(ea, flags)""" - return _idaapi.set_aflags(*args) - -def set_abits(*args): - """set_abits(ea, bits)""" - return _idaapi.set_abits(*args) - -def clr_abits(*args): - """clr_abits(ea, bits)""" - return _idaapi.clr_abits(*args) - -def get_aflags(*args): - """get_aflags(ea) -> uint32""" - return _idaapi.get_aflags(*args) - -def del_aflags(*args): - """del_aflags(ea)""" - return _idaapi.del_aflags(*args) - def is_hidden_item(*args): - """is_hidden_item(ea) -> bool""" + """ + is_hidden_item(ea) -> bool + """ return _idaapi.is_hidden_item(*args) def hide_item(*args): - """hide_item(ea)""" + """ + hide_item(ea) + """ return _idaapi.hide_item(*args) def unhide_item(*args): - """unhide_item(ea)""" + """ + unhide_item(ea) + """ return _idaapi.unhide_item(*args) def is_hidden_border(*args): - """is_hidden_border(ea) -> bool""" + """ + is_hidden_border(ea) -> bool + """ return _idaapi.is_hidden_border(*args) def hide_border(*args): - """hide_border(ea)""" + """ + hide_border(ea) + """ return _idaapi.hide_border(*args) def unhide_border(*args): - """unhide_border(ea)""" + """ + unhide_border(ea) + """ return _idaapi.unhide_border(*args) def uses_modsp(*args): - """uses_modsp(ea) -> bool""" + """ + uses_modsp(ea) -> bool + """ return _idaapi.uses_modsp(*args) def set_usemodsp(*args): - """set_usemodsp(ea)""" + """ + set_usemodsp(ea) + """ return _idaapi.set_usemodsp(*args) def clr_usemodsp(*args): - """clr_usemodsp(ea)""" + """ + clr_usemodsp(ea) + """ return _idaapi.clr_usemodsp(*args) def is_zstroff(*args): - """is_zstroff(ea) -> bool""" + """ + is_zstroff(ea) -> bool + """ return _idaapi.is_zstroff(*args) def set_zstroff(*args): - """set_zstroff(ea)""" + """ + set_zstroff(ea) + """ return _idaapi.set_zstroff(*args) def clr_zstroff(*args): - """clr_zstroff(ea)""" + """ + clr_zstroff(ea) + """ return _idaapi.clr_zstroff(*args) def is__bnot0(*args): - """is__bnot0(ea) -> bool""" + """ + is__bnot0(ea) -> bool + """ return _idaapi.is__bnot0(*args) def set__bnot0(*args): - """set__bnot0(ea)""" + """ + set__bnot0(ea) + """ return _idaapi.set__bnot0(*args) def clr__bnot0(*args): - """clr__bnot0(ea)""" + """ + clr__bnot0(ea) + """ return _idaapi.clr__bnot0(*args) def is__bnot1(*args): - """is__bnot1(ea) -> bool""" + """ + is__bnot1(ea) -> bool + """ return _idaapi.is__bnot1(*args) def set__bnot1(*args): - """set__bnot1(ea)""" + """ + set__bnot1(ea) + """ return _idaapi.set__bnot1(*args) def clr__bnot1(*args): - """clr__bnot1(ea)""" + """ + clr__bnot1(ea) + """ return _idaapi.clr__bnot1(*args) def is_libitem(*args): - """is_libitem(ea) -> bool""" + """ + is_libitem(ea) -> bool + """ return _idaapi.is_libitem(*args) def set_libitem(*args): - """set_libitem(ea)""" + """ + set_libitem(ea) + """ return _idaapi.set_libitem(*args) def clr_libitem(*args): - """clr_libitem(ea)""" + """ + clr_libitem(ea) + """ return _idaapi.clr_libitem(*args) def has_ti(*args): - """has_ti(ea) -> bool""" + """ + has_ti(ea) -> bool + """ return _idaapi.has_ti(*args) def set_has_ti(*args): - """set_has_ti(ea)""" + """ + set_has_ti(ea) + """ return _idaapi.set_has_ti(*args) def clr_has_ti(*args): - """clr_has_ti(ea)""" + """ + clr_has_ti(ea) + """ return _idaapi.clr_has_ti(*args) def has_ti0(*args): - """has_ti0(ea) -> bool""" + """ + has_ti0(ea) -> bool + """ return _idaapi.has_ti0(*args) def set_has_ti0(*args): - """set_has_ti0(ea)""" + """ + set_has_ti0(ea) + """ return _idaapi.set_has_ti0(*args) def clr_has_ti0(*args): - """clr_has_ti0(ea)""" + """ + clr_has_ti0(ea) + """ return _idaapi.clr_has_ti0(*args) def has_ti1(*args): - """has_ti1(ea) -> bool""" + """ + has_ti1(ea) -> bool + """ return _idaapi.has_ti1(*args) def set_has_ti1(*args): - """set_has_ti1(ea)""" + """ + set_has_ti1(ea) + """ return _idaapi.set_has_ti1(*args) def clr_has_ti1(*args): - """clr_has_ti1(ea)""" + """ + clr_has_ti1(ea) + """ return _idaapi.clr_has_ti1(*args) def has_lname(*args): - """has_lname(ea) -> bool""" + """ + has_lname(ea) -> bool + """ return _idaapi.has_lname(*args) def set_has_lname(*args): - """set_has_lname(ea)""" + """ + set_has_lname(ea) + """ return _idaapi.set_has_lname(*args) def clr_has_lname(*args): - """clr_has_lname(ea)""" + """ + clr_has_lname(ea) + """ return _idaapi.clr_has_lname(*args) def is_tilcmt(*args): - """is_tilcmt(ea) -> bool""" + """ + is_tilcmt(ea) -> bool + """ return _idaapi.is_tilcmt(*args) def set_tilcmt(*args): - """set_tilcmt(ea)""" + """ + set_tilcmt(ea) + """ return _idaapi.set_tilcmt(*args) def clr_tilcmt(*args): - """clr_tilcmt(ea)""" + """ + clr_tilcmt(ea) + """ return _idaapi.clr_tilcmt(*args) def is_usersp(*args): - """is_usersp(ea) -> bool""" + """ + is_usersp(ea) -> bool + """ return _idaapi.is_usersp(*args) def set_usersp(*args): - """set_usersp(ea)""" + """ + set_usersp(ea) + """ return _idaapi.set_usersp(*args) def clr_usersp(*args): - """clr_usersp(ea)""" + """ + clr_usersp(ea) + """ return _idaapi.clr_usersp(*args) def is_lzero0(*args): - """is_lzero0(ea) -> bool""" + """ + is_lzero0(ea) -> bool + """ return _idaapi.is_lzero0(*args) def set_lzero0(*args): - """set_lzero0(ea)""" + """ + set_lzero0(ea) + """ return _idaapi.set_lzero0(*args) def clr_lzero0(*args): - """clr_lzero0(ea)""" + """ + clr_lzero0(ea) + """ return _idaapi.clr_lzero0(*args) def is_lzero1(*args): - """is_lzero1(ea) -> bool""" + """ + is_lzero1(ea) -> bool + """ return _idaapi.is_lzero1(*args) def set_lzero1(*args): - """set_lzero1(ea)""" + """ + set_lzero1(ea) + """ return _idaapi.set_lzero1(*args) def clr_lzero1(*args): - """clr_lzero1(ea)""" + """ + clr_lzero1(ea) + """ return _idaapi.clr_lzero1(*args) def is_colored_item(*args): - """is_colored_item(ea) -> bool""" + """ + is_colored_item(ea) -> bool + """ return _idaapi.is_colored_item(*args) def set_colored_item(*args): - """set_colored_item(ea)""" + """ + set_colored_item(ea) + """ return _idaapi.set_colored_item(*args) def clr_colored_item(*args): - """clr_colored_item(ea)""" + """ + clr_colored_item(ea) + """ return _idaapi.clr_colored_item(*args) def is_terse_struc(*args): - """is_terse_struc(ea) -> bool""" + """ + is_terse_struc(ea) -> bool + """ return _idaapi.is_terse_struc(*args) def set_terse_struc(*args): - """set_terse_struc(ea)""" + """ + set_terse_struc(ea) + """ return _idaapi.set_terse_struc(*args) def clr_terse_struc(*args): - """clr_terse_struc(ea)""" + """ + clr_terse_struc(ea) + """ return _idaapi.clr_terse_struc(*args) def is__invsign0(*args): - """is__invsign0(ea) -> bool""" + """ + is__invsign0(ea) -> bool + """ return _idaapi.is__invsign0(*args) def set__invsign0(*args): - """set__invsign0(ea)""" + """ + set__invsign0(ea) + """ return _idaapi.set__invsign0(*args) def clr__invsign0(*args): - """clr__invsign0(ea)""" + """ + clr__invsign0(ea) + """ return _idaapi.clr__invsign0(*args) def is__invsign1(*args): - """is__invsign1(ea) -> bool""" + """ + is__invsign1(ea) -> bool + """ return _idaapi.is__invsign1(*args) def set__invsign1(*args): - """set__invsign1(ea)""" + """ + set__invsign1(ea) + """ return _idaapi.set__invsign1(*args) def clr__invsign1(*args): - """clr__invsign1(ea)""" + """ + clr__invsign1(ea) + """ return _idaapi.clr__invsign1(*args) def is_noret(*args): - """is_noret(ea) -> bool""" + """ + is_noret(ea) -> bool + """ return _idaapi.is_noret(*args) def set_noret(*args): - """set_noret(ea)""" + """ + set_noret(ea) + """ return _idaapi.set_noret(*args) def clr_noret(*args): - """clr_noret(ea)""" + """ + clr_noret(ea) + """ return _idaapi.clr_noret(*args) def is_fixed_spd(*args): - """is_fixed_spd(ea) -> bool""" + """ + is_fixed_spd(ea) -> bool + """ return _idaapi.is_fixed_spd(*args) def set_fixed_spd(*args): - """set_fixed_spd(ea)""" + """ + set_fixed_spd(ea) + """ return _idaapi.set_fixed_spd(*args) def clr_fixed_spd(*args): - """clr_fixed_spd(ea)""" + """ + clr_fixed_spd(ea) + """ return _idaapi.clr_fixed_spd(*args) def is_align_flow(*args): - """is_align_flow(ea) -> bool""" + """ + is_align_flow(ea) -> bool + """ return _idaapi.is_align_flow(*args) def set_align_flow(*args): - """set_align_flow(ea)""" + """ + set_align_flow(ea) + """ return _idaapi.set_align_flow(*args) def clr_align_flow(*args): - """clr_align_flow(ea)""" + """ + clr_align_flow(ea) + """ return _idaapi.clr_align_flow(*args) def is_userti(*args): - """is_userti(ea) -> bool""" + """ + is_userti(ea) -> bool + """ return _idaapi.is_userti(*args) def set_userti(*args): - """set_userti(ea)""" + """ + set_userti(ea) + """ return _idaapi.set_userti(*args) def clr_userti(*args): - """clr_userti(ea)""" + """ + clr_userti(ea) + """ return _idaapi.clr_userti(*args) def is_retfp(*args): - """is_retfp(ea) -> bool""" + """ + is_retfp(ea) -> bool + """ return _idaapi.is_retfp(*args) def set_retfp(*args): - """set_retfp(ea)""" + """ + set_retfp(ea) + """ return _idaapi.set_retfp(*args) def clr_retfp(*args): - """clr_retfp(ea)""" + """ + clr_retfp(ea) + """ return _idaapi.clr_retfp(*args) def is_notcode(*args): - """is_notcode(ea) -> bool""" + """ + is_notcode(ea) -> bool + """ return _idaapi.is_notcode(*args) def set_notcode(*args): - """set_notcode(ea)""" + """ + set_notcode(ea) + """ return _idaapi.set_notcode(*args) def clr_notcode(*args): - """clr_notcode(ea)""" + """ + clr_notcode(ea) + """ return _idaapi.clr_notcode(*args) def set_visible_item(*args): - """set_visible_item(ea, visible)""" + """ + set_visible_item(ea, visible) + """ return _idaapi.set_visible_item(*args) def is_visible_item(*args): - """is_visible_item(ea) -> bool""" + """ + is_visible_item(ea) -> bool + """ return _idaapi.is_visible_item(*args) def is_finally_visible_item(*args): - """is_finally_visible_item(ea) -> bool""" + """ + is_finally_visible_item(ea) -> bool + """ return _idaapi.is_finally_visible_item(*args) def set_source_linnum(*args): - """set_source_linnum(ea, lnnum)""" + """ + set_source_linnum(ea, lnnum) + """ return _idaapi.set_source_linnum(*args) def get_source_linnum(*args): - """get_source_linnum(ea) -> uval_t""" + """ + get_source_linnum(ea) -> uval_t + """ return _idaapi.get_source_linnum(*args) def del_source_linnum(*args): - """del_source_linnum(ea)""" + """ + del_source_linnum(ea) + """ return _idaapi.del_source_linnum(*args) def get_absbase(*args): - """get_absbase(ea) -> ea_t""" + """ + get_absbase(ea) -> ea_t + """ return _idaapi.get_absbase(*args) def set_absbase(*args): - """set_absbase(ea, x)""" + """ + set_absbase(ea, x) + """ return _idaapi.set_absbase(*args) def del_absbase(*args): - """del_absbase(ea)""" + """ + del_absbase(ea) + """ return _idaapi.del_absbase(*args) +def get_enum_id0(*args): + """ + get_enum_id0(ea) -> ea_t + """ + return _idaapi.get_enum_id0(*args) + +def set_enum_id0(*args): + """ + set_enum_id0(ea, x) + """ + return _idaapi.set_enum_id0(*args) + +def del_enum_id0(*args): + """ + del_enum_id0(ea) + """ + return _idaapi.del_enum_id0(*args) + +def get_enum_id1(*args): + """ + get_enum_id1(ea) -> ea_t + """ + return _idaapi.get_enum_id1(*args) + +def set_enum_id1(*args): + """ + set_enum_id1(ea, x) + """ + return _idaapi.set_enum_id1(*args) + +def del_enum_id1(*args): + """ + del_enum_id1(ea) + """ + return _idaapi.del_enum_id1(*args) + def get_ind_purged(*args): - """get_ind_purged(ea) -> ea_t""" + """ + get_ind_purged(ea) -> ea_t + """ return _idaapi.get_ind_purged(*args) +def set_ind_purged(*args): + """ + set_ind_purged(ea, x) + """ + return _idaapi.set_ind_purged(*args) + def del_ind_purged(*args): - """del_ind_purged(ea)""" + """ + del_ind_purged(ea) + """ return _idaapi.del_ind_purged(*args) + +def get_str_type(*args): + """ + get_str_type(ea) -> uint32 + """ + return _idaapi.get_str_type(*args) + +def set_str_type(*args): + """ + set_str_type(ea, x) + """ + return _idaapi.set_str_type(*args) + +def del_str_type(*args): + """ + del_str_type(ea) + """ + return _idaapi.del_str_type(*args) + +def get_str_type_code(*args): + """ + get_str_type_code(strtype) -> char + """ + return _idaapi.get_str_type_code(*args) ASCSTR_TERMCHR = _idaapi.ASCSTR_TERMCHR + +def get_str_term1(*args): + """ + get_str_term1(strtype) -> char + """ + return _idaapi.get_str_term1(*args) + +def get_str_term2(*args): + """ + get_str_term2(strtype) -> char + """ + return _idaapi.get_str_term2(*args) ASCSTR_PASCAL = _idaapi.ASCSTR_PASCAL ASCSTR_LEN2 = _idaapi.ASCSTR_LEN2 ASCSTR_UNICODE = _idaapi.ASCSTR_UNICODE @@ -4883,63 +6555,271 @@ ASCSTR_ULEN4 = _idaapi.ASCSTR_ULEN4 ASCSTR_UTF32 = _idaapi.ASCSTR_UTF32 ASCSTR_LAST = _idaapi.ASCSTR_LAST -def get_str_type_code(*args): - """get_str_type_code(strtype) -> char""" - return _idaapi.get_str_type_code(*args) - -def get_str_term1(*args): - """get_str_term1(strtype) -> char""" - return _idaapi.get_str_term1(*args) - -def get_str_term2(*args): - """get_str_term2(strtype) -> char""" - return _idaapi.get_str_term2(*args) - def is_unicode(*args): - """is_unicode(strtype) -> bool""" + """ + is_unicode(strtype) -> bool + """ return _idaapi.is_unicode(*args) def is_pascal(*args): - """is_pascal(strtype) -> bool""" + """ + is_pascal(strtype) -> bool + """ return _idaapi.is_pascal(*args) def get_str_encoding_idx(*args): - """get_str_encoding_idx(strtype) -> uchar""" + """ + get_str_encoding_idx(strtype) -> uchar + """ return _idaapi.get_str_encoding_idx(*args) STRENC_DEFAULT = _idaapi.STRENC_DEFAULT STRENC_NONE = _idaapi.STRENC_NONE def get_alignment(*args): - """get_alignment(ea) -> uint32""" + """ + get_alignment(ea) -> uint32 + """ return _idaapi.get_alignment(*args) def set_alignment(*args): - """set_alignment(ea, x)""" + """ + set_alignment(ea, x) + """ return _idaapi.set_alignment(*args) def del_alignment(*args): - """del_alignment(ea)""" + """ + del_alignment(ea) + """ return _idaapi.del_alignment(*args) +def _get_item_color(*args): + """ + _get_item_color(ea) -> uint32 + """ + return _idaapi._get_item_color(*args) + +def _set_item_color(*args): + """ + _set_item_color(ea, x) + """ + return _idaapi._set_item_color(*args) + +def _del_item_color(*args): + """ + _del_item_color(ea) + """ + return _idaapi._del_item_color(*args) + def set_item_color(*args): - """set_item_color(ea, color)""" + """ + set_item_color(ea, color) + """ return _idaapi.set_item_color(*args) def get_item_color(*args): - """get_item_color(ea) -> bgcolor_t""" + """ + get_item_color(ea) -> bgcolor_t + """ return _idaapi.get_item_color(*args) def del_item_color(*args): - """del_item_color(ea)""" + """ + del_item_color(ea) + """ return _idaapi.del_item_color(*args) + +def get_nalt_cmt(*args): + """ + get_nalt_cmt(ea) -> ssize_t + """ + return _idaapi.get_nalt_cmt(*args) + +def set_nalt_cmt(*args): + """ + set_nalt_cmt(ea, oi) + """ + return _idaapi.set_nalt_cmt(*args) + +def del_nalt_cmt(*args): + """ + del_nalt_cmt(ea) + """ + return _idaapi.del_nalt_cmt(*args) + +def get_nalt_rptcmt(*args): + """ + get_nalt_rptcmt(ea) -> ssize_t + """ + return _idaapi.get_nalt_rptcmt(*args) + +def set_nalt_rptcmt(*args): + """ + set_nalt_rptcmt(ea, oi) + """ + return _idaapi.set_nalt_rptcmt(*args) + +def del_nalt_rptcmt(*args): + """ + del_nalt_rptcmt(ea) + """ + return _idaapi.del_nalt_rptcmt(*args) + +def get_fop1(*args): + """ + get_fop1(ea) -> ssize_t + """ + return _idaapi.get_fop1(*args) + +def set_fop1(*args): + """ + set_fop1(ea, oi) + """ + return _idaapi.set_fop1(*args) + +def del_fop1(*args): + """ + del_fop1(ea) + """ + return _idaapi.del_fop1(*args) + +def get_fop2(*args): + """ + get_fop2(ea) -> ssize_t + """ + return _idaapi.get_fop2(*args) + +def set_fop2(*args): + """ + set_fop2(ea, oi) + """ + return _idaapi.set_fop2(*args) + +def del_fop2(*args): + """ + del_fop2(ea) + """ + return _idaapi.del_fop2(*args) + +def get_fop3(*args): + """ + get_fop3(ea) -> ssize_t + """ + return _idaapi.get_fop3(*args) + +def set_fop3(*args): + """ + set_fop3(ea, oi) + """ + return _idaapi.set_fop3(*args) + +def del_fop3(*args): + """ + del_fop3(ea) + """ + return _idaapi.del_fop3(*args) + +def get_fop4(*args): + """ + get_fop4(ea) -> ssize_t + """ + return _idaapi.get_fop4(*args) + +def set_fop4(*args): + """ + set_fop4(ea, oi) + """ + return _idaapi.set_fop4(*args) + +def del_fop4(*args): + """ + del_fop4(ea) + """ + return _idaapi.del_fop4(*args) + +def get_fop5(*args): + """ + get_fop5(ea) -> ssize_t + """ + return _idaapi.get_fop5(*args) + +def set_fop5(*args): + """ + set_fop5(ea, oi) + """ + return _idaapi.set_fop5(*args) + +def del_fop5(*args): + """ + del_fop5(ea) + """ + return _idaapi.del_fop5(*args) + +def get_fop6(*args): + """ + get_fop6(ea) -> ssize_t + """ + return _idaapi.get_fop6(*args) + +def set_fop6(*args): + """ + set_fop6(ea, oi) + """ + return _idaapi.set_fop6(*args) + +def del_fop6(*args): + """ + del_fop6(ea) + """ + return _idaapi.del_fop6(*args) + +def get_manual_insn0(*args): + """ + get_manual_insn0(ea, buf, bufsize) -> char * + """ + return _idaapi.get_manual_insn0(*args) + +def set_manual_insn0(*args): + """ + set_manual_insn0(ea, oi, size) + """ + return _idaapi.set_manual_insn0(*args) + +def del_manual_insn0(*args): + """ + del_manual_insn0(ea) + """ + return _idaapi.del_manual_insn0(*args) + +def get_graph_groups0(*args): + """ + get_graph_groups0(ea, buf, bufsize) -> uchar * + """ + return _idaapi.get_graph_groups0(*args) + +def set_graph_groups0(*args): + """ + set_graph_groups0(ea, oi, size) + """ + return _idaapi.set_graph_groups0(*args) + +def del_graph_groups0(*args): + """ + del_graph_groups0(ea) + """ + return _idaapi.del_graph_groups0(*args) class jumptable_info_t(object): - """Proxy of C++ jumptable_info_t class""" + """ + Proxy of C++ jumptable_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr table = _swig_property(_idaapi.jumptable_info_t_table_get, _idaapi.jumptable_info_t_table_set) size = _swig_property(_idaapi.jumptable_info_t_size_get, _idaapi.jumptable_info_t_size_set) - def __init__(self, *args): - """__init__(self) -> jumptable_info_t""" + def __init__(self, *args): + """ + __init__(self) -> jumptable_info_t + """ this = _idaapi.new_jumptable_info_t(*args) try: self.this.append(this) except: self.this = this @@ -4950,25 +6830,35 @@ jumptable_info_t_swigregister(jumptable_info_t) def get_jumptable_info(*args): - """get_jumptable_info(ea, buf, bufsize) -> ssize_t""" + """ + get_jumptable_info(ea, buf, bufsize) -> ssize_t + """ return _idaapi.get_jumptable_info(*args) def set_jumptable_info(*args): - """set_jumptable_info(ea, oi)""" + """ + set_jumptable_info(ea, oi) + """ return _idaapi.set_jumptable_info(*args) def del_jumptable_info(*args): - """del_jumptable_info(ea)""" + """ + del_jumptable_info(ea) + """ return _idaapi.del_jumptable_info(*args) class array_parameters_t(object): - """Proxy of C++ array_parameters_t class""" + """ + Proxy of C++ array_parameters_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr flags = _swig_property(_idaapi.array_parameters_t_flags_get, _idaapi.array_parameters_t_flags_set) lineitems = _swig_property(_idaapi.array_parameters_t_lineitems_get, _idaapi.array_parameters_t_lineitems_set) alignment = _swig_property(_idaapi.array_parameters_t_alignment_get, _idaapi.array_parameters_t_alignment_set) - def __init__(self, *args): - """__init__(self) -> array_parameters_t""" + def __init__(self, *args): + """ + __init__(self) -> array_parameters_t + """ this = _idaapi.new_array_parameters_t(*args) try: self.this.append(this) except: self.this = this @@ -4988,36 +6878,52 @@ AP_IDXBIN = _idaapi.AP_IDXBIN def get_array_parameters(*args): - """get_array_parameters(ea, buf, bufsize) -> ssize_t""" + """ + get_array_parameters(ea, buf, bufsize) -> ssize_t + """ return _idaapi.get_array_parameters(*args) def set_array_parameters(*args): - """set_array_parameters(ea, oi)""" + """ + set_array_parameters(ea, oi) + """ return _idaapi.set_array_parameters(*args) def del_array_parameters(*args): - """del_array_parameters(ea)""" + """ + del_array_parameters(ea) + """ return _idaapi.del_array_parameters(*args) def get_switch_parent(*args): - """get_switch_parent(ea) -> ea_t""" + """ + get_switch_parent(ea) -> ea_t + """ return _idaapi.get_switch_parent(*args) def set_switch_parent(*args): - """set_switch_parent(ea, x)""" + """ + set_switch_parent(ea, x) + """ return _idaapi.set_switch_parent(*args) def del_switch_parent(*args): - """del_switch_parent(ea)""" + """ + del_switch_parent(ea) + """ return _idaapi.del_switch_parent(*args) class custom_data_type_ids_t(object): - """Proxy of C++ custom_data_type_ids_t class""" + """ + Proxy of C++ custom_data_type_ids_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr dtid = _swig_property(_idaapi.custom_data_type_ids_t_dtid_get, _idaapi.custom_data_type_ids_t_dtid_set) fids = _swig_property(_idaapi.custom_data_type_ids_t_fids_get, _idaapi.custom_data_type_ids_t_fids_set) - def __init__(self, *args): - """__init__(self) -> custom_data_type_ids_t""" + def __init__(self, *args): + """ + __init__(self) -> custom_data_type_ids_t + """ this = _idaapi.new_custom_data_type_ids_t(*args) try: self.this.append(this) except: self.this = this @@ -5028,22 +6934,32 @@ custom_data_type_ids_t_swigregister(custom_data_type_ids_t) def get_custom_data_type_ids(*args): - """get_custom_data_type_ids(ea, cdis, bufsize) -> int""" + """ + get_custom_data_type_ids(ea, cdis, bufsize) -> int + """ return _idaapi.get_custom_data_type_ids(*args) def set_custom_data_type_ids(*args): - """set_custom_data_type_ids(ea, cdis)""" + """ + set_custom_data_type_ids(ea, cdis) + """ return _idaapi.set_custom_data_type_ids(*args) def del_custom_data_type_ids(*args): - """del_custom_data_type_ids(ea)""" + """ + del_custom_data_type_ids(ea) + """ return _idaapi.del_custom_data_type_ids(*args) def get_reftype_by_size(*args): - """get_reftype_by_size(size) -> reftype_t""" + """ + get_reftype_by_size(size) -> reftype_t + """ return _idaapi.get_reftype_by_size(*args) class refinfo_t(object): - """Proxy of C++ refinfo_t class""" + """ + Proxy of C++ refinfo_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr target = _swig_property(_idaapi.refinfo_t_target_get, _idaapi.refinfo_t_target_set) @@ -5051,43 +6967,63 @@ class refinfo_t(object): tdelta = _swig_property(_idaapi.refinfo_t_tdelta_get, _idaapi.refinfo_t_tdelta_set) flags = _swig_property(_idaapi.refinfo_t_flags_get, _idaapi.refinfo_t_flags_set) def type(self, *args): - """type(self) -> reftype_t""" + """ + type(self) -> reftype_t + """ return _idaapi.refinfo_t_type(self, *args) def no_base_xref(self, *args): - """no_base_xref(self) -> bool""" + """ + no_base_xref(self) -> bool + """ return _idaapi.refinfo_t_no_base_xref(self, *args) def is_pastend(self, *args): - """is_pastend(self) -> bool""" + """ + is_pastend(self) -> bool + """ return _idaapi.refinfo_t_is_pastend(self, *args) def is_rvaoff(self, *args): - """is_rvaoff(self) -> bool""" + """ + is_rvaoff(self) -> bool + """ return _idaapi.refinfo_t_is_rvaoff(self, *args) def is_custom(self, *args): - """is_custom(self) -> bool""" + """ + is_custom(self) -> bool + """ return _idaapi.refinfo_t_is_custom(self, *args) def is_subtract(self, *args): - """is_subtract(self) -> bool""" + """ + is_subtract(self) -> bool + """ return _idaapi.refinfo_t_is_subtract(self, *args) def is_signed(self, *args): - """is_signed(self) -> bool""" + """ + is_signed(self) -> bool + """ return _idaapi.refinfo_t_is_signed(self, *args) def set_type(self, *args): - """set_type(self, t)""" + """ + set_type(self, t) + """ return _idaapi.refinfo_t_set_type(self, *args) def init(self, *args): - """init(self, reft_and_flags, _base=0, _target=BADADDR, _tdelta=0)""" + """ + init(self, reft_and_flags, _base=0, _target=BADADDR, _tdelta=0) + """ return _idaapi.refinfo_t_init(self, *args) - def __init__(self, *args): - """__init__(self) -> refinfo_t""" + def __init__(self, *args): + """ + __init__(self) -> refinfo_t + """ this = _idaapi.new_refinfo_t(*args) try: self.this.append(this) except: self.this = this @@ -5116,20 +7052,26 @@ REFINFO_SIGNEDOP = _idaapi.REFINFO_SIGNEDOP MAXSTRUCPATH = _idaapi.MAXSTRUCPATH class strpath_t(object): - """Proxy of C++ strpath_t class""" + """ + Proxy of C++ strpath_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr len = _swig_property(_idaapi.strpath_t_len_get, _idaapi.strpath_t_len_set) ids = _swig_property(_idaapi.strpath_t_ids_get, _idaapi.strpath_t_ids_set) delta = _swig_property(_idaapi.strpath_t_delta_get, _idaapi.strpath_t_delta_set) def __getIds(self, *args): - """__getIds(self) -> ids_array""" + """ + __getIds(self) -> ids_array + """ return _idaapi.strpath_t___getIds(self, *args) ids = property(__getIds) - def __init__(self, *args): - """__init__(self) -> strpath_t""" + def __init__(self, *args): + """ + __init__(self) -> strpath_t + """ this = _idaapi.new_strpath_t(*args) try: self.this.append(this) except: self.this = this @@ -5139,13 +7081,17 @@ strpath_t_swigregister = _idaapi.strpath_t_swigregister strpath_t_swigregister(strpath_t) class enum_const_t(object): - """Proxy of C++ enum_const_t class""" + """ + Proxy of C++ enum_const_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr tid = _swig_property(_idaapi.enum_const_t_tid_get, _idaapi.enum_const_t_tid_set) serial = _swig_property(_idaapi.enum_const_t_serial_get, _idaapi.enum_const_t_serial_set) - def __init__(self, *args): - """__init__(self) -> enum_const_t""" + def __init__(self, *args): + """ + __init__(self) -> enum_const_t + """ this = _idaapi.new_enum_const_t(*args) try: self.this.append(this) except: self.this = this @@ -5155,7 +7101,9 @@ enum_const_t_swigregister = _idaapi.enum_const_t_swigregister enum_const_t_swigregister(enum_const_t) class opinfo_t(object): - """Proxy of C++ opinfo_t class""" + """ + Proxy of C++ opinfo_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr ri = _swig_property(_idaapi.opinfo_t_ri_get, _idaapi.opinfo_t_ri_set) @@ -5164,8 +7112,10 @@ class opinfo_t(object): strtype = _swig_property(_idaapi.opinfo_t_strtype_get, _idaapi.opinfo_t_strtype_set) ec = _swig_property(_idaapi.opinfo_t_ec_get, _idaapi.opinfo_t_ec_set) cd = _swig_property(_idaapi.opinfo_t_cd_get, _idaapi.opinfo_t_cd_set) - def __init__(self, *args): - """__init__(self) -> opinfo_t""" + def __init__(self, *args): + """ + __init__(self) -> opinfo_t + """ this = _idaapi.new_opinfo_t(*args) try: self.this.append(this) except: self.this = this @@ -5176,35 +7126,117 @@ opinfo_t_swigregister(opinfo_t) def set_refinfo_ex(*args): - """set_refinfo_ex(ea, n, ri) -> int""" + """ + set_refinfo_ex(ea, n, ri) -> int + """ return _idaapi.set_refinfo_ex(*args) def set_refinfo(*args): - """set_refinfo(ea, n, type, target=BADADDR, base=0, tdelta=0) -> int""" + """ + set_refinfo(ea, n, type, target=BADADDR, base=0, tdelta=0) -> int + """ return _idaapi.set_refinfo(*args) def get_refinfo(*args): - """get_refinfo(ea, n, ri) -> int""" + """ + get_refinfo(ea, n, ri) -> int + """ return _idaapi.get_refinfo(*args) def del_refinfo(*args): - """del_refinfo(ea, n) -> int""" + """ + del_refinfo(ea, n) -> int + """ return _idaapi.del_refinfo(*args) +def write_struc_path(*args): + """ + write_struc_path(node, idx, path, plen, delta) + """ + return _idaapi.write_struc_path(*args) + +def read_struc_path(*args): + """ + read_struc_path(node, idx, path, delta) -> int + """ + return _idaapi.read_struc_path(*args) + +def get_stroff0(*args): + """ + get_stroff0(ea, path, delta) -> int + """ + return _idaapi.get_stroff0(*args) + +def set_stroff0(*args): + """ + set_stroff0(ea, path, plen, delta) + """ + return _idaapi.set_stroff0(*args) + +def del_stroff0(*args): + """ + del_stroff0(ea) + """ + return _idaapi.del_stroff0(*args) + +def get_stroff1(*args): + """ + get_stroff1(ea, path, delta) -> int + """ + return _idaapi.get_stroff1(*args) + +def set_stroff1(*args): + """ + set_stroff1(ea, path, plen, delta) + """ + return _idaapi.set_stroff1(*args) + +def del_stroff1(*args): + """ + del_stroff1(ea) + """ + return _idaapi.del_stroff1(*args) + +def get__segtrans(*args): + """ + get__segtrans(ea, buf, bufsize) -> ssize_t + """ + return _idaapi.get__segtrans(*args) + +def set__segtrans(*args): + """ + set__segtrans(ea, oi, size) + """ + return _idaapi.set__segtrans(*args) + +def del__segtrans(*args): + """ + del__segtrans(ea) + """ + return _idaapi.del__segtrans(*args) + def get_tinfo2(*args): - """get_tinfo2(ea, tif) -> bool""" + """ + get_tinfo2(ea, tif) -> bool + """ return _idaapi.get_tinfo2(*args) def set_tinfo2(*args): - """set_tinfo2(ea, tif) -> bool""" + """ + set_tinfo2(ea, tif) -> bool + """ return _idaapi.set_tinfo2(*args) def get_op_tinfo2(*args): - """get_op_tinfo2(ea, n, tif) -> bool""" + """ + get_op_tinfo2(ea, n, tif) -> bool + """ return _idaapi.get_op_tinfo2(*args) def set_op_tinfo2(*args): - """set_op_tinfo2(ea, n, tif) -> bool""" + """ + set_op_tinfo2(ea, n, tif) -> bool + """ return _idaapi.set_op_tinfo2(*args) def del_tinfo2(*args): @@ -5233,129 +7265,274 @@ RIDX_SELECTED_EXTLANG = _idaapi.RIDX_SELECTED_EXTLANG RIDX_DBG_BINPATHS = _idaapi.RIDX_DBG_BINPATHS def get_input_file_path(*args): - """get_input_file_path() -> ssize_t""" + """ + get_input_file_path() -> ssize_t + """ return _idaapi.get_input_file_path(*args) def get_root_filename(*args): - """get_root_filename() -> ssize_t""" + """ + get_root_filename() -> ssize_t + """ return _idaapi.get_root_filename(*args) def set_root_filename(*args): - """set_root_filename(file)""" + """ + set_root_filename(file) + """ return _idaapi.set_root_filename(*args) def retrieve_input_file_crc32(*args): - """retrieve_input_file_crc32() -> uint32""" + """ + retrieve_input_file_crc32() -> uint32 + """ return _idaapi.retrieve_input_file_crc32(*args) def retrieve_input_file_md5(*args): - """retrieve_input_file_md5(hash) -> bool""" + """ + retrieve_input_file_md5(hash) -> bool + """ return _idaapi.retrieve_input_file_md5(*args) def get_asm_inc_file(*args): - """get_asm_inc_file() -> ssize_t""" + """ + get_asm_inc_file() -> ssize_t + """ return _idaapi.get_asm_inc_file(*args) def set_asm_inc_file(*args): - """set_asm_inc_file(file) -> bool""" + """ + set_asm_inc_file(file) -> bool + """ return _idaapi.set_asm_inc_file(*args) def get_imagebase(*args): - """get_imagebase() -> ea_t""" + """ + get_imagebase() -> ea_t + """ return _idaapi.get_imagebase(*args) def set_imagebase(*args): - """set_imagebase(base)""" + """ + set_imagebase(base) + """ return _idaapi.set_imagebase(*args) def get_ids_modnode(*args): - """get_ids_modnode() -> netnode""" + """ + get_ids_modnode() -> netnode + """ return _idaapi.get_ids_modnode(*args) def set_ids_modnode(*args): - """set_ids_modnode(id)""" + """ + set_ids_modnode(id) + """ return _idaapi.set_ids_modnode(*args) def get_auto_plugins(*args): - """get_auto_plugins() -> ssize_t""" + """ + get_auto_plugins() -> ssize_t + """ return _idaapi.get_auto_plugins(*args) def set_auto_plugins(*args): - """set_auto_plugins(list, listsize=0) -> bool""" + """ + set_auto_plugins(list, listsize=0) -> bool + """ return _idaapi.set_auto_plugins(*args) def dbg_get_input_path(*args): - """dbg_get_input_path() -> ssize_t""" + """ + dbg_get_input_path() -> ssize_t + """ return _idaapi.dbg_get_input_path(*args) def get_encodings_count(*args): - """get_encodings_count() -> int""" + """ + get_encodings_count() -> int + """ return _idaapi.get_encodings_count(*args) def get_encoding_name(*args): - """get_encoding_name(idx) -> char const *""" + """ + get_encoding_name(idx) -> char const * + """ return _idaapi.get_encoding_name(*args) def add_encoding(*args): - """add_encoding(encoding) -> int""" + """ + add_encoding(encoding) -> int + """ return _idaapi.add_encoding(*args) def del_encoding(*args): - """del_encoding(idx) -> bool""" + """ + del_encoding(idx) -> bool + """ return _idaapi.del_encoding(*args) def change_encoding_name(*args): - """change_encoding_name(idx, encoding) -> bool""" + """ + change_encoding_name(idx, encoding) -> bool + """ return _idaapi.change_encoding_name(*args) def get_default_encoding_idx(*args): - """get_default_encoding_idx(strtype) -> int""" + """ + get_default_encoding_idx(strtype) -> int + """ return _idaapi.get_default_encoding_idx(*args) def set_default_encoding_idx(*args): - """set_default_encoding_idx(strtype, idx) -> bool""" + """ + set_default_encoding_idx(strtype, idx) -> bool + """ return _idaapi.set_default_encoding_idx(*args) def encoding_from_strtype(*args): - """encoding_from_strtype(strtype) -> char const *""" + """ + encoding_from_strtype(strtype) -> char const * + """ return _idaapi.encoding_from_strtype(*args) def get_import_module_qty(*args): - """get_import_module_qty() -> uint""" + """ + get_import_module_qty() -> int + """ return _idaapi.get_import_module_qty(*args) def validate_idb_names(*args): - """validate_idb_names() -> int""" + """ + validate_idb_names() -> int + """ return _idaapi.validate_idb_names(*args) SWI_SHIFT1 = _idaapi.SWI_SHIFT1 +def get_switch_info(*args): + """ + get_switch_info(ea, buf, bufsize) -> ssize_t + """ + return _idaapi.get_switch_info(*args) + +def set_switch_info(*args): + """ + set_switch_info(ea, oi) + """ + return _idaapi.set_switch_info(*args) + +def del_switch_info(*args): + """ + del_switch_info(ea) + """ + return _idaapi.del_switch_info(*args) + +def get_ti(*args): + """ + get_ti(ea, buf, bufsize, fnames, fnsize) -> bool + """ + return _idaapi.get_ti(*args) + +def set_ti(*args): + """ + set_ti(ea, ti, fnames) -> bool + """ + return _idaapi.set_ti(*args) + +def get_op_tinfo(*args): + """ + get_op_tinfo(ea, n, type, fnames) -> bool + """ + return _idaapi.get_op_tinfo(*args) + +def set_op_tinfo(*args): + """ + set_op_tinfo(ea, n, ti, fnames) -> bool + """ + return _idaapi.set_op_tinfo(*args) + +def get_op_ti(*args): + """ + get_op_ti(ea, n, buf, bufsize, fnames, fnsize) -> bool + """ + return _idaapi.get_op_ti(*args) + +def set_op_ti(*args): + """ + set_op_ti(ea, n, ti, fnames) -> bool + """ + return _idaapi.set_op_ti(*args) + def get_tinfo(*args): - """get_tinfo(ea, type, fields) -> bool""" + """ + get_tinfo(ea, type, fields) -> bool + """ return _idaapi.get_tinfo(*args) def set_tinfo(*args): - """set_tinfo(ea, ti, fnames) -> bool""" + """ + set_tinfo(ea, ti, fnames) -> bool + """ return _idaapi.set_tinfo(*args) +def del_tinfo(*args): + """ + del_tinfo(ea, n) + del_tinfo(ea) + """ + return _idaapi.del_tinfo(*args) + def get_import_module_name(*args): - """get_import_module_name(mod_index) -> PyObject *""" + """ + get_import_module_name(mod_index) -> PyObject * + + + Returns the name of an imported module given its index + @return: None or the module name + """ return _idaapi.get_import_module_name(*args) def get_switch_info_ex(*args): - """get_switch_info_ex(ea) -> PyObject *""" + """ + get_switch_info_ex(ea) -> PyObject * + + + Returns the a switch_info_ex_t structure containing the information about the switch. + Please refer to the SDK sample 'uiswitch' + @return: None or switch_info_ex_t instance + """ return _idaapi.get_switch_info_ex(*args) def create_switch_xrefs(*args): - """create_switch_xrefs(insn_ea, py_swi) -> bool""" + """ + create_switch_xrefs(insn_ea, py_swi) -> bool + + + This function creates xrefs from the indirect jump. + + Usually there is no need to call this function directly because the kernel + will call it for switch tables + + Note: Custom switch information are not supported yet. + + @param insn_ea: address of the 'indirect jump' instruction + @param si: switch information + + @return: Boolean + """ return _idaapi.create_switch_xrefs(*args) class cases_and_targets_t(object): - """Proxy of C++ cases_and_targets_t class""" + """ + Proxy of C++ cases_and_targets_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr cases = _swig_property(_idaapi.cases_and_targets_t_cases_get, _idaapi.cases_and_targets_t_cases_set) targets = _swig_property(_idaapi.cases_and_targets_t_targets_get, _idaapi.cases_and_targets_t_targets_set) - def __init__(self, *args): - """__init__(self) -> cases_and_targets_t""" + def __init__(self, *args): + """ + __init__(self) -> cases_and_targets_t + """ this = _idaapi.new_cases_and_targets_t(*args) try: self.this.append(this) except: self.this = this @@ -5366,178 +7543,302 @@ cases_and_targets_t_swigregister(cases_and_targets_t) def create_switch_table(*args): - """create_switch_table(insn_ea, py_swi) -> bool""" + """ + create_switch_table(insn_ea, py_swi) -> bool + + + Create switch table from the switch information + + @param insn_ea: address of the 'indirect jump' instruction + @param si: switch information + + @return: Boolean + """ return _idaapi.create_switch_table(*args) def set_switch_info_ex(*args): - """set_switch_info_ex(ea, py_swi) -> bool""" + """ + set_switch_info_ex(ea, py_swi) -> bool + + + Saves the switch information in the database + Please refer to the SDK sample 'uiswitch' + @return: Boolean + """ return _idaapi.set_switch_info_ex(*args) def del_switch_info_ex(*args): - """del_switch_info_ex(ea)""" + """ + del_switch_info_ex(ea) + + + Deletes stored switch information + """ return _idaapi.del_switch_info_ex(*args) def enum_import_names(*args): - """enum_import_names(mod_index, py_cb) -> int""" + """ + enum_import_names(mod_index, py_cb) -> int + + + Enumerate imports from a specific module. + Please refer to ex_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) + """ return _idaapi.enum_import_names(*args) def switch_info_ex_t_create(*args): - """switch_info_ex_t_create() -> PyObject *""" + """ + switch_info_ex_t_create() -> PyObject * + """ return _idaapi.switch_info_ex_t_create(*args) def switch_info_ex_t_destroy(*args): - """switch_info_ex_t_destroy(py_obj) -> bool""" + """ + switch_info_ex_t_destroy(py_obj) -> bool + """ return _idaapi.switch_info_ex_t_destroy(*args) def switch_info_ex_t_assign(*args): - """switch_info_ex_t_assign(self, other) -> bool""" + """ + switch_info_ex_t_assign(self, other) -> bool + """ return _idaapi.switch_info_ex_t_assign(*args) def switch_info_ex_t_get_regdtyp(*args): - """switch_info_ex_t_get_regdtyp(self) -> PyObject *""" + """ + switch_info_ex_t_get_regdtyp(self) -> PyObject * + """ return _idaapi.switch_info_ex_t_get_regdtyp(*args) def switch_info_ex_t_set_regdtyp(*args): - """switch_info_ex_t_set_regdtyp(self, value)""" + """ + switch_info_ex_t_set_regdtyp(self, value) + """ return _idaapi.switch_info_ex_t_set_regdtyp(*args) def switch_info_ex_t_get_flags2(*args): - """switch_info_ex_t_get_flags2(self) -> PyObject *""" + """ + switch_info_ex_t_get_flags2(self) -> PyObject * + """ return _idaapi.switch_info_ex_t_get_flags2(*args) def switch_info_ex_t_set_flags2(*args): - """switch_info_ex_t_set_flags2(self, value)""" + """ + switch_info_ex_t_set_flags2(self, value) + """ return _idaapi.switch_info_ex_t_set_flags2(*args) def switch_info_ex_t_get_jcases(*args): - """switch_info_ex_t_get_jcases(self) -> PyObject *""" + """ + switch_info_ex_t_get_jcases(self) -> PyObject * + """ return _idaapi.switch_info_ex_t_get_jcases(*args) def switch_info_ex_t_set_jcases(*args): - """switch_info_ex_t_set_jcases(self, value)""" + """ + switch_info_ex_t_set_jcases(self, value) + """ return _idaapi.switch_info_ex_t_set_jcases(*args) def switch_info_ex_t_get_regnum(*args): - """switch_info_ex_t_get_regnum(self) -> PyObject *""" + """ + switch_info_ex_t_get_regnum(self) -> PyObject * + """ return _idaapi.switch_info_ex_t_get_regnum(*args) def switch_info_ex_t_set_regnum(*args): - """switch_info_ex_t_set_regnum(self, value)""" + """ + switch_info_ex_t_set_regnum(self, value) + """ return _idaapi.switch_info_ex_t_set_regnum(*args) def switch_info_ex_t_get_flags(*args): - """switch_info_ex_t_get_flags(self) -> PyObject *""" + """ + switch_info_ex_t_get_flags(self) -> PyObject * + """ return _idaapi.switch_info_ex_t_get_flags(*args) def switch_info_ex_t_set_flags(*args): - """switch_info_ex_t_set_flags(self, value)""" + """ + switch_info_ex_t_set_flags(self, value) + """ return _idaapi.switch_info_ex_t_set_flags(*args) def switch_info_ex_t_get_ncases(*args): - """switch_info_ex_t_get_ncases(self) -> PyObject *""" + """ + switch_info_ex_t_get_ncases(self) -> PyObject * + """ return _idaapi.switch_info_ex_t_get_ncases(*args) def switch_info_ex_t_set_ncases(*args): - """switch_info_ex_t_set_ncases(self, value)""" + """ + switch_info_ex_t_set_ncases(self, value) + """ return _idaapi.switch_info_ex_t_set_ncases(*args) def switch_info_ex_t_get_defjump(*args): - """switch_info_ex_t_get_defjump(self) -> PyObject *""" + """ + switch_info_ex_t_get_defjump(self) -> PyObject * + """ return _idaapi.switch_info_ex_t_get_defjump(*args) def switch_info_ex_t_set_defjump(*args): - """switch_info_ex_t_set_defjump(self, value)""" + """ + switch_info_ex_t_set_defjump(self, value) + """ return _idaapi.switch_info_ex_t_set_defjump(*args) def switch_info_ex_t_get_jumps(*args): - """switch_info_ex_t_get_jumps(self) -> PyObject *""" + """ + switch_info_ex_t_get_jumps(self) -> PyObject * + """ return _idaapi.switch_info_ex_t_get_jumps(*args) def switch_info_ex_t_set_jumps(*args): - """switch_info_ex_t_set_jumps(self, value)""" + """ + switch_info_ex_t_set_jumps(self, value) + """ return _idaapi.switch_info_ex_t_set_jumps(*args) def switch_info_ex_t_get_elbase(*args): - """switch_info_ex_t_get_elbase(self) -> PyObject *""" + """ + switch_info_ex_t_get_elbase(self) -> PyObject * + """ return _idaapi.switch_info_ex_t_get_elbase(*args) def switch_info_ex_t_set_elbase(*args): - """switch_info_ex_t_set_elbase(self, value)""" + """ + switch_info_ex_t_set_elbase(self, value) + """ return _idaapi.switch_info_ex_t_set_elbase(*args) def switch_info_ex_t_get_startea(*args): - """switch_info_ex_t_get_startea(self) -> PyObject *""" + """ + switch_info_ex_t_get_startea(self) -> PyObject * + """ return _idaapi.switch_info_ex_t_get_startea(*args) def switch_info_ex_t_set_startea(*args): - """switch_info_ex_t_set_startea(self, value)""" + """ + switch_info_ex_t_set_startea(self, value) + """ return _idaapi.switch_info_ex_t_set_startea(*args) def switch_info_ex_t_get_custom(*args): - """switch_info_ex_t_get_custom(self) -> PyObject *""" + """ + switch_info_ex_t_get_custom(self) -> PyObject * + """ return _idaapi.switch_info_ex_t_get_custom(*args) def switch_info_ex_t_set_custom(*args): - """switch_info_ex_t_set_custom(self, value)""" + """ + switch_info_ex_t_set_custom(self, value) + """ return _idaapi.switch_info_ex_t_set_custom(*args) def switch_info_ex_t_get_ind_lowcase(*args): - """switch_info_ex_t_get_ind_lowcase(self) -> PyObject *""" + """ + switch_info_ex_t_get_ind_lowcase(self) -> PyObject * + """ return _idaapi.switch_info_ex_t_get_ind_lowcase(*args) def switch_info_ex_t_set_ind_lowcase(*args): - """switch_info_ex_t_set_ind_lowcase(self, value)""" + """ + switch_info_ex_t_set_ind_lowcase(self, value) + """ return _idaapi.switch_info_ex_t_set_ind_lowcase(*args) def switch_info_ex_t_get_values_lowcase(*args): - """switch_info_ex_t_get_values_lowcase(self) -> PyObject *""" + """ + switch_info_ex_t_get_values_lowcase(self) -> PyObject * + """ return _idaapi.switch_info_ex_t_get_values_lowcase(*args) def switch_info_ex_t_set_values_lowcase(*args): - """switch_info_ex_t_set_values_lowcase(self, value)""" + """ + switch_info_ex_t_set_values_lowcase(self, value) + """ return _idaapi.switch_info_ex_t_set_values_lowcase(*args) # SWI_SPARSE = 0x1 -"""sparse switch ( value table present ) otherwise lowcase present""" +""" +sparse switch ( value table present ) otherwise lowcase present +""" SWI_V32 = 0x2 -"""32-bit values in table""" +""" +32-bit values in table +""" SWI_J32 = 0x4 -"""32-bit jump offsets""" +""" +32-bit jump offsets +""" SWI_VSPLIT = 0x8 -"""value table is split (only for 32-bit values)""" +""" +value table is split (only for 32-bit values) +""" SWI_DEFAULT = 0x10 -"""default case is present""" +""" +default case is present +""" SWI_END_IN_TBL = 0x20 -"""switchend in table (default entry)""" +""" +switchend in table (default entry) +""" SWI_JMP_INV = 0x40 -"""jumptable is inversed (last entry is for first entry in values table)""" +""" +jumptable is inversed (last entry is for first entry in values table) +""" SWI_SHIFT_MASK = 0x180 -"""use formula (element*shift + elbase) to find jump targets""" +""" +use formula (element*shift + elbase) to find jump targets +""" SWI_ELBASE = 0x200 -"""elbase is present (if not and shift!=0, endof(jumpea) is used)""" +""" +elbase is present (if not and shift!=0, endof(jumpea) is used) +""" SWI_JSIZE = 0x400 -"""jump offset expansion bit""" +""" +jump offset expansion bit +""" SWI_VSIZE = 0x800 -"""value table element size expansion bit""" +""" +value table element size expansion bit +""" SWI_SEPARATE = 0x1000 -"""do not create an array of individual dwords""" +""" +do not create an array of individual dwords +""" SWI_SIGNED = 0x2000 -"""jump table entries are signed""" +""" +jump table entries are signed +""" SWI_CUSTOM = 0x4000 -"""custom jump table - ph.create_switch_xrefs will be called to create code xrefs for the table. it must return 2. custom jump table must be created by the module""" +""" +custom jump table - ph.create_switch_xrefs will be called to create code xrefs for the table. it must return 2. custom jump table must be created by the module +""" SWI_EXTENDED = 0x8000 -"""this is switch_info_ex_t""" +""" +this is switch_info_ex_t +""" SWI2_INDIRECT = 0x0001 -"""value table elements are used as indexes into the jump table""" +""" +value table elements are used as indexes into the jump table +""" SWI2_SUBTRACT = 0x0002 -"""table values are subtracted from the elbase instead of being addded""" +""" +table values are subtracted from the elbase instead of being addded +""" # -------------------------------------------------------------------------- class switch_info_ex_t(py_clinked_object_t): @@ -5662,26 +7963,46 @@ class switch_info_ex_t(py_clinked_object_t): def __set_values_lowcase__(self, v): _idaapi.switch_info_ex_t_set_values_lowcase(self, v) regdtyp = property(__get_regdtyp__, __set_regdtyp__) - """size of the switch expression register as dtyp""" + """ + size of the switch expression register as dtyp + """ flags2 = property(__get_flags2__, __set_flags2__) jcases = property(__get_jcases__, __set_jcases__) - """number of entries in the jump table (SWI2_INDIRECT)""" + """ + number of entries in the jump table (SWI2_INDIRECT) + """ regnum = property(__get_regnum__, __set_regnum__) - """the switch expression as a register number""" + """ + the switch expression as a register number + """ flags = property(__get_flags__, __set_flags__) - """the switch expression as a register number""" + """ + the switch expression as a register number + """ ncases = property(__get_ncases__, __set_ncases__) - """number of cases (excluding default)""" + """ + number of cases (excluding default) + """ defjump = property(__get_defjump__, __set_defjump__) - """default jump address""" + """ + default jump address + """ jumps = property(__get_jumps__, __set_jumps__) - """jump table address""" + """ + jump table address + """ elbase = property(__get_elbase__, __set_elbase__) - """element base""" + """ + element base + """ startea = property(__get_startea__, __set_startea__) - """start of switch idiom""" + """ + start of switch idiom + """ custom = property(__get_custom__, __set_custom__) - """information for custom tables (filled and used by modules)""" + """ + information for custom tables (filled and used by modules) + """ ind_lowcase = property(__get_ind_lowcase__, __set_ind_lowcase__) values = property(__get_values_lowcase__, __set_values_lowcase__) lowcase = property(__get_values_lowcase__, __set_values_lowcase__) @@ -6829,26 +9150,6 @@ NN_vmsldt = _idaapi.NN_vmsldt NN_vmstr = _idaapi.NN_vmstr NN_vmsdte = _idaapi.NN_vmsdte NN_vpcext = _idaapi.NN_vpcext -NN_vfmaddsubps = _idaapi.NN_vfmaddsubps -NN_vfmaddsubpd = _idaapi.NN_vfmaddsubpd -NN_vfmsubaddps = _idaapi.NN_vfmsubaddps -NN_vfmsubaddpd = _idaapi.NN_vfmsubaddpd -NN_vfmaddps = _idaapi.NN_vfmaddps -NN_vfmaddpd = _idaapi.NN_vfmaddpd -NN_vfmaddss = _idaapi.NN_vfmaddss -NN_vfmaddsd = _idaapi.NN_vfmaddsd -NN_vfmsubps = _idaapi.NN_vfmsubps -NN_vfmsubpd = _idaapi.NN_vfmsubpd -NN_vfmsubss = _idaapi.NN_vfmsubss -NN_vfmsubsd = _idaapi.NN_vfmsubsd -NN_vfnmaddps = _idaapi.NN_vfnmaddps -NN_vfnmaddpd = _idaapi.NN_vfnmaddpd -NN_vfnmaddss = _idaapi.NN_vfnmaddss -NN_vfnmaddsd = _idaapi.NN_vfnmaddsd -NN_vfnmsubps = _idaapi.NN_vfnmsubps -NN_vfnmsubpd = _idaapi.NN_vfnmsubpd -NN_vfnmsubss = _idaapi.NN_vfnmsubss -NN_vfnmsubsd = _idaapi.NN_vfnmsubsd NN_last = _idaapi.NN_last I5_null = _idaapi.I5_null I5_aci = _idaapi.I5_aci @@ -10793,859 +13094,6 @@ MIPS_mflhxu = _idaapi.MIPS_mflhxu MIPS_mtlhx = _idaapi.MIPS_mtlhx MIPS_multp = _idaapi.MIPS_multp MIPS_pperm = _idaapi.MIPS_pperm -MIPS_jals = _idaapi.MIPS_jals -MIPS_lwp = _idaapi.MIPS_lwp -MIPS_ldp = _idaapi.MIPS_ldp -MIPS_lwm = _idaapi.MIPS_lwm -MIPS_ldm = _idaapi.MIPS_ldm -MIPS_swp = _idaapi.MIPS_swp -MIPS_sdp = _idaapi.MIPS_sdp -MIPS_swm = _idaapi.MIPS_swm -MIPS_sdm = _idaapi.MIPS_sdm -MIPS_bnezc = _idaapi.MIPS_bnezc -MIPS_bltzals = _idaapi.MIPS_bltzals -MIPS_beqzc = _idaapi.MIPS_beqzc -MIPS_bgezals = _idaapi.MIPS_bgezals -MIPS_jraddiusp = _idaapi.MIPS_jraddiusp -MIPS_jalrs = _idaapi.MIPS_jalrs -MIPS_jalrs_hb = _idaapi.MIPS_jalrs_hb -MIPS_movep = _idaapi.MIPS_movep -MIPS_dli = _idaapi.MIPS_dli -MIPS_insv = _idaapi.MIPS_insv -MIPS_dinsv = _idaapi.MIPS_dinsv -MIPS_bposge32 = _idaapi.MIPS_bposge32 -MIPS_bposge64 = _idaapi.MIPS_bposge64 -MIPS_addu_qb = _idaapi.MIPS_addu_qb -MIPS_addu_ph = _idaapi.MIPS_addu_ph -MIPS_addsc = _idaapi.MIPS_addsc -MIPS_subu_qb = _idaapi.MIPS_subu_qb -MIPS_subu_ph = _idaapi.MIPS_subu_ph -MIPS_addwc = _idaapi.MIPS_addwc -MIPS_addq_ph = _idaapi.MIPS_addq_ph -MIPS_modsub = _idaapi.MIPS_modsub -MIPS_subq_ph = _idaapi.MIPS_subq_ph -MIPS_addu_s_qb = _idaapi.MIPS_addu_s_qb -MIPS_addu_s_ph = _idaapi.MIPS_addu_s_ph -MIPS_raddu_w_qb = _idaapi.MIPS_raddu_w_qb -MIPS_muleq_s_w_phl = _idaapi.MIPS_muleq_s_w_phl -MIPS_subu_s_qb = _idaapi.MIPS_subu_s_qb -MIPS_subu_s_ph = _idaapi.MIPS_subu_s_ph -MIPS_muleq_s_w_phr = _idaapi.MIPS_muleq_s_w_phr -MIPS_muleu_s_ph_qbl = _idaapi.MIPS_muleu_s_ph_qbl -MIPS_addq_s_ph = _idaapi.MIPS_addq_s_ph -MIPS_addq_s_w = _idaapi.MIPS_addq_s_w -MIPS_mulq_s_ph = _idaapi.MIPS_mulq_s_ph -MIPS_muleu_s_ph_qbr = _idaapi.MIPS_muleu_s_ph_qbr -MIPS_subq_s_ph = _idaapi.MIPS_subq_s_ph -MIPS_subq_s_w = _idaapi.MIPS_subq_s_w -MIPS_mulq_rs_ph = _idaapi.MIPS_mulq_rs_ph -MIPS_addu_ob = _idaapi.MIPS_addu_ob -MIPS_subu_ob = _idaapi.MIPS_subu_ob -MIPS_addq_qh = _idaapi.MIPS_addq_qh -MIPS_addq_pw = _idaapi.MIPS_addq_pw -MIPS_subq_qh = _idaapi.MIPS_subq_qh -MIPS_subq_pw = _idaapi.MIPS_subq_pw -MIPS_addu_s_ob = _idaapi.MIPS_addu_s_ob -MIPS_raddu_l_ob = _idaapi.MIPS_raddu_l_ob -MIPS_muleq_s_pw_qhl = _idaapi.MIPS_muleq_s_pw_qhl -MIPS_subu_s_ob = _idaapi.MIPS_subu_s_ob -MIPS_muleq_s_pw_qhr = _idaapi.MIPS_muleq_s_pw_qhr -MIPS_muleu_s_qh_obl = _idaapi.MIPS_muleu_s_qh_obl -MIPS_addq_s_qh = _idaapi.MIPS_addq_s_qh -MIPS_addq_s_pw = _idaapi.MIPS_addq_s_pw -MIPS_muleu_s_qh_obr = _idaapi.MIPS_muleu_s_qh_obr -MIPS_subq_s_qh = _idaapi.MIPS_subq_s_qh -MIPS_subq_s_pw = _idaapi.MIPS_subq_s_pw -MIPS_mulq_rs_qh = _idaapi.MIPS_mulq_rs_qh -MIPS_cmpu_eq_qb = _idaapi.MIPS_cmpu_eq_qb -MIPS_cmp_eq_ph = _idaapi.MIPS_cmp_eq_ph -MIPS_cmpgdu_eq_qb = _idaapi.MIPS_cmpgdu_eq_qb -MIPS_cmpu_lt_qb = _idaapi.MIPS_cmpu_lt_qb -MIPS_cmp_lt_ph = _idaapi.MIPS_cmp_lt_ph -MIPS_cmpgdu_lt_qb = _idaapi.MIPS_cmpgdu_lt_qb -MIPS_cmpu_le_qb = _idaapi.MIPS_cmpu_le_qb -MIPS_cmp_le_ph = _idaapi.MIPS_cmp_le_ph -MIPS_cmpgdu_le_qb = _idaapi.MIPS_cmpgdu_le_qb -MIPS_pick_qb = _idaapi.MIPS_pick_qb -MIPS_pick_ph = _idaapi.MIPS_pick_ph -MIPS_cmpgu_eq_qb = _idaapi.MIPS_cmpgu_eq_qb -MIPS_precrq_qb_ph = _idaapi.MIPS_precrq_qb_ph -MIPS_precrq_ph_w = _idaapi.MIPS_precrq_ph_w -MIPS_cmpgu_lt_qb = _idaapi.MIPS_cmpgu_lt_qb -MIPS_precr_qb_ph = _idaapi.MIPS_precr_qb_ph -MIPS_precrq_rs_ph_w = _idaapi.MIPS_precrq_rs_ph_w -MIPS_cmpgu_le_qb = _idaapi.MIPS_cmpgu_le_qb -MIPS_packrl_ph = _idaapi.MIPS_packrl_ph -MIPS_precr_sra_ph_w = _idaapi.MIPS_precr_sra_ph_w -MIPS_precrqu_s_qb_ph = _idaapi.MIPS_precrqu_s_qb_ph -MIPS_precr_sra_r_ph_w = _idaapi.MIPS_precr_sra_r_ph_w -MIPS_cmpu_eq_ob = _idaapi.MIPS_cmpu_eq_ob -MIPS_cmp_eq_qh = _idaapi.MIPS_cmp_eq_qh -MIPS_cmp_eq_pw = _idaapi.MIPS_cmp_eq_pw -MIPS_cmpu_lt_ob = _idaapi.MIPS_cmpu_lt_ob -MIPS_cmp_lt_qh = _idaapi.MIPS_cmp_lt_qh -MIPS_cmp_lt_pw = _idaapi.MIPS_cmp_lt_pw -MIPS_cmpu_le_ob = _idaapi.MIPS_cmpu_le_ob -MIPS_cmp_le_qh = _idaapi.MIPS_cmp_le_qh -MIPS_cmp_le_pw = _idaapi.MIPS_cmp_le_pw -MIPS_pick_ob = _idaapi.MIPS_pick_ob -MIPS_pick_qh = _idaapi.MIPS_pick_qh -MIPS_pick_pw = _idaapi.MIPS_pick_pw -MIPS_cmpgu_eq_ob = _idaapi.MIPS_cmpgu_eq_ob -MIPS_precrq_ob_qh = _idaapi.MIPS_precrq_ob_qh -MIPS_precrq_qh_pw = _idaapi.MIPS_precrq_qh_pw -MIPS_precrq_pw_l = _idaapi.MIPS_precrq_pw_l -MIPS_cmpgu_lt_ob = _idaapi.MIPS_cmpgu_lt_ob -MIPS_precrq_rs_qh_pw = _idaapi.MIPS_precrq_rs_qh_pw -MIPS_cmpgu_le_ob = _idaapi.MIPS_cmpgu_le_ob -MIPS_packrl_pw = _idaapi.MIPS_packrl_pw -MIPS_precrqu_s_ob_qh = _idaapi.MIPS_precrqu_s_ob_qh -MIPS_absq_s_qb = _idaapi.MIPS_absq_s_qb -MIPS_absq_s_ph = _idaapi.MIPS_absq_s_ph -MIPS_absq_s_w = _idaapi.MIPS_absq_s_w -MIPS_repl_qb = _idaapi.MIPS_repl_qb -MIPS_repl_ph = _idaapi.MIPS_repl_ph -MIPS_replv_qb = _idaapi.MIPS_replv_qb -MIPS_replv_ph = _idaapi.MIPS_replv_ph -MIPS_bitrev = _idaapi.MIPS_bitrev -MIPS_precequ_ph_qbl = _idaapi.MIPS_precequ_ph_qbl -MIPS_preceq_w_phl = _idaapi.MIPS_preceq_w_phl -MIPS_preceu_ph_qbl = _idaapi.MIPS_preceu_ph_qbl -MIPS_precequ_ph_qbr = _idaapi.MIPS_precequ_ph_qbr -MIPS_preceq_w_phr = _idaapi.MIPS_preceq_w_phr -MIPS_preceu_ph_qbr = _idaapi.MIPS_preceu_ph_qbr -MIPS_precequ_ph_qbla = _idaapi.MIPS_precequ_ph_qbla -MIPS_preceu_ph_qbla = _idaapi.MIPS_preceu_ph_qbla -MIPS_precequ_ph_qbra = _idaapi.MIPS_precequ_ph_qbra -MIPS_preceu_ph_qbra = _idaapi.MIPS_preceu_ph_qbra -MIPS_absq_s_qh = _idaapi.MIPS_absq_s_qh -MIPS_absq_s_pw = _idaapi.MIPS_absq_s_pw -MIPS_repl_ob = _idaapi.MIPS_repl_ob -MIPS_repl_qh = _idaapi.MIPS_repl_qh -MIPS_repl_pw = _idaapi.MIPS_repl_pw -MIPS_replv_ob = _idaapi.MIPS_replv_ob -MIPS_replv_qh = _idaapi.MIPS_replv_qh -MIPS_replv_pw = _idaapi.MIPS_replv_pw -MIPS_precequ_pw_qhl = _idaapi.MIPS_precequ_pw_qhl -MIPS_preceq_pw_qhl = _idaapi.MIPS_preceq_pw_qhl -MIPS_preceq_s_l_pwl = _idaapi.MIPS_preceq_s_l_pwl -MIPS_preceu_qh_obl = _idaapi.MIPS_preceu_qh_obl -MIPS_precequ_pw_qhr = _idaapi.MIPS_precequ_pw_qhr -MIPS_preceq_pw_qhr = _idaapi.MIPS_preceq_pw_qhr -MIPS_preceq_s_l_pwr = _idaapi.MIPS_preceq_s_l_pwr -MIPS_preceu_qh_obr = _idaapi.MIPS_preceu_qh_obr -MIPS_precequ_pw_qhla = _idaapi.MIPS_precequ_pw_qhla -MIPS_preceq_pw_qhla = _idaapi.MIPS_preceq_pw_qhla -MIPS_preceu_qh_obla = _idaapi.MIPS_preceu_qh_obla -MIPS_precequ_pw_qhra = _idaapi.MIPS_precequ_pw_qhra -MIPS_preceq_pw_qhra = _idaapi.MIPS_preceq_pw_qhra -MIPS_preceu_qh_obra = _idaapi.MIPS_preceu_qh_obra -MIPS_shll_qb = _idaapi.MIPS_shll_qb -MIPS_shll_ph = _idaapi.MIPS_shll_ph -MIPS_shrl_qb = _idaapi.MIPS_shrl_qb -MIPS_shra_ph = _idaapi.MIPS_shra_ph -MIPS_shrl_ph = _idaapi.MIPS_shrl_ph -MIPS_shllv_qb = _idaapi.MIPS_shllv_qb -MIPS_shllv_ph = _idaapi.MIPS_shllv_ph -MIPS_shrlv_qb = _idaapi.MIPS_shrlv_qb -MIPS_shrav_ph = _idaapi.MIPS_shrav_ph -MIPS_shrlv_ph = _idaapi.MIPS_shrlv_ph -MIPS_shra_qb = _idaapi.MIPS_shra_qb -MIPS_shll_s_ph = _idaapi.MIPS_shll_s_ph -MIPS_shll_s_w = _idaapi.MIPS_shll_s_w -MIPS_shra_r_qb = _idaapi.MIPS_shra_r_qb -MIPS_shra_r_ph = _idaapi.MIPS_shra_r_ph -MIPS_shra_r_w = _idaapi.MIPS_shra_r_w -MIPS_shrav_qb = _idaapi.MIPS_shrav_qb -MIPS_shllv_s_ph = _idaapi.MIPS_shllv_s_ph -MIPS_shllv_s_w = _idaapi.MIPS_shllv_s_w -MIPS_shrav_r_qb = _idaapi.MIPS_shrav_r_qb -MIPS_shrav_r_ph = _idaapi.MIPS_shrav_r_ph -MIPS_shrav_r_w = _idaapi.MIPS_shrav_r_w -MIPS_shll_ob = _idaapi.MIPS_shll_ob -MIPS_shll_qh = _idaapi.MIPS_shll_qh -MIPS_shll_pw = _idaapi.MIPS_shll_pw -MIPS_shrl_ob = _idaapi.MIPS_shrl_ob -MIPS_shra_qh = _idaapi.MIPS_shra_qh -MIPS_shra_pw = _idaapi.MIPS_shra_pw -MIPS_shllv_ob = _idaapi.MIPS_shllv_ob -MIPS_shllv_qh = _idaapi.MIPS_shllv_qh -MIPS_shllv_pw = _idaapi.MIPS_shllv_pw -MIPS_shrlv_ob = _idaapi.MIPS_shrlv_ob -MIPS_shrav_qh = _idaapi.MIPS_shrav_qh -MIPS_shrav_pw = _idaapi.MIPS_shrav_pw -MIPS_shll_s_qh = _idaapi.MIPS_shll_s_qh -MIPS_shll_s_pw = _idaapi.MIPS_shll_s_pw -MIPS_shra_r_qh = _idaapi.MIPS_shra_r_qh -MIPS_shra_r_pw = _idaapi.MIPS_shra_r_pw -MIPS_shllv_s_qh = _idaapi.MIPS_shllv_s_qh -MIPS_shllv_s_pw = _idaapi.MIPS_shllv_s_pw -MIPS_shrav_r_qh = _idaapi.MIPS_shrav_r_qh -MIPS_shrav_r_pw = _idaapi.MIPS_shrav_r_pw -MIPS_lwx = _idaapi.MIPS_lwx -MIPS_ldx = _idaapi.MIPS_ldx -MIPS_lhx = _idaapi.MIPS_lhx -MIPS_lbux = _idaapi.MIPS_lbux -MIPS_dpa_w_ph = _idaapi.MIPS_dpa_w_ph -MIPS_dpax_w_ph = _idaapi.MIPS_dpax_w_ph -MIPS_maq_sa_w_phl = _idaapi.MIPS_maq_sa_w_phl -MIPS_dpaqx_s_w_ph = _idaapi.MIPS_dpaqx_s_w_ph -MIPS_dps_w_ph = _idaapi.MIPS_dps_w_ph -MIPS_dpsx_w_ph = _idaapi.MIPS_dpsx_w_ph -MIPS_dpsqx_s_w_ph = _idaapi.MIPS_dpsqx_s_w_ph -MIPS_mulsa_w_ph = _idaapi.MIPS_mulsa_w_ph -MIPS_maq_sa_w_phr = _idaapi.MIPS_maq_sa_w_phr -MIPS_dpaqx_sa_w_ph = _idaapi.MIPS_dpaqx_sa_w_ph -MIPS_dpau_h_qbl = _idaapi.MIPS_dpau_h_qbl -MIPS_dpsu_h_qbl = _idaapi.MIPS_dpsu_h_qbl -MIPS_dpsqx_sa_w_ph = _idaapi.MIPS_dpsqx_sa_w_ph -MIPS_dpaq_s_w_ph = _idaapi.MIPS_dpaq_s_w_ph -MIPS_dpaq_sa_l_w = _idaapi.MIPS_dpaq_sa_l_w -MIPS_maq_s_w_phl = _idaapi.MIPS_maq_s_w_phl -MIPS_dpsq_s_w_ph = _idaapi.MIPS_dpsq_s_w_ph -MIPS_dpsq_sa_l_w = _idaapi.MIPS_dpsq_sa_l_w -MIPS_mulsaq_s_w_ph = _idaapi.MIPS_mulsaq_s_w_ph -MIPS_maq_s_w_phr = _idaapi.MIPS_maq_s_w_phr -MIPS_dpau_h_qbr = _idaapi.MIPS_dpau_h_qbr -MIPS_dpsu_h_qbr = _idaapi.MIPS_dpsu_h_qbr -MIPS_maq_sa_w_qhll = _idaapi.MIPS_maq_sa_w_qhll -MIPS_maq_sa_w_qhlr = _idaapi.MIPS_maq_sa_w_qhlr -MIPS_dmadd = _idaapi.MIPS_dmadd -MIPS_dmsub = _idaapi.MIPS_dmsub -MIPS_maq_sa_w_qhrl = _idaapi.MIPS_maq_sa_w_qhrl -MIPS_dpau_h_obl = _idaapi.MIPS_dpau_h_obl -MIPS_dpsu_h_obl = _idaapi.MIPS_dpsu_h_obl -MIPS_maq_sa_w_qhrr = _idaapi.MIPS_maq_sa_w_qhrr -MIPS_dpaq_s_w_qh = _idaapi.MIPS_dpaq_s_w_qh -MIPS_dpaq_sa_l_pw = _idaapi.MIPS_dpaq_sa_l_pw -MIPS_maq_s_w_qhll = _idaapi.MIPS_maq_s_w_qhll -MIPS_maq_s_l_pwl = _idaapi.MIPS_maq_s_l_pwl -MIPS_dpsq_s_w_qh = _idaapi.MIPS_dpsq_s_w_qh -MIPS_dpsq_sa_l_pw = _idaapi.MIPS_dpsq_sa_l_pw -MIPS_maq_s_w_qhlr = _idaapi.MIPS_maq_s_w_qhlr -MIPS_dmaddu = _idaapi.MIPS_dmaddu -MIPS_mulsaq_s_w_qh = _idaapi.MIPS_mulsaq_s_w_qh -MIPS_mulsaq_s_l_pw = _idaapi.MIPS_mulsaq_s_l_pw -MIPS_maq_s_w_qhrl = _idaapi.MIPS_maq_s_w_qhrl -MIPS_maq_s_l_pwr = _idaapi.MIPS_maq_s_l_pwr -MIPS_dpau_h_obr = _idaapi.MIPS_dpau_h_obr -MIPS_dpsu_h_obr = _idaapi.MIPS_dpsu_h_obr -MIPS_maq_s_w_qhrr = _idaapi.MIPS_maq_s_w_qhrr -MIPS_dmsubu = _idaapi.MIPS_dmsubu -MIPS_extr_w = _idaapi.MIPS_extr_w -MIPS_extrv_w = _idaapi.MIPS_extrv_w -MIPS_extp = _idaapi.MIPS_extp -MIPS_extpdp = _idaapi.MIPS_extpdp -MIPS_rddsp = _idaapi.MIPS_rddsp -MIPS_shilo = _idaapi.MIPS_shilo -MIPS_extpv = _idaapi.MIPS_extpv -MIPS_extpdpv = _idaapi.MIPS_extpdpv -MIPS_wrdsp = _idaapi.MIPS_wrdsp -MIPS_shilov = _idaapi.MIPS_shilov -MIPS_extr_r_w = _idaapi.MIPS_extr_r_w -MIPS_extrv_r_w = _idaapi.MIPS_extrv_r_w -MIPS_extr_rs_w = _idaapi.MIPS_extr_rs_w -MIPS_extr_s_h = _idaapi.MIPS_extr_s_h -MIPS_extrv_rs_w = _idaapi.MIPS_extrv_rs_w -MIPS_extrv_s_h = _idaapi.MIPS_extrv_s_h -MIPS_mthlip = _idaapi.MIPS_mthlip -MIPS_dextr_w = _idaapi.MIPS_dextr_w -MIPS_dextr_l = _idaapi.MIPS_dextr_l -MIPS_dextrv_w = _idaapi.MIPS_dextrv_w -MIPS_dextrv_l = _idaapi.MIPS_dextrv_l -MIPS_dextp = _idaapi.MIPS_dextp -MIPS_dextpdp = _idaapi.MIPS_dextpdp -MIPS_dshilo = _idaapi.MIPS_dshilo -MIPS_dextpv = _idaapi.MIPS_dextpv -MIPS_dextpdpv = _idaapi.MIPS_dextpdpv -MIPS_dshilov = _idaapi.MIPS_dshilov -MIPS_dextr_r_w = _idaapi.MIPS_dextr_r_w -MIPS_dextr_r_l = _idaapi.MIPS_dextr_r_l -MIPS_dextrv_r_w = _idaapi.MIPS_dextrv_r_w -MIPS_dextrv_r_l = _idaapi.MIPS_dextrv_r_l -MIPS_dextr_rs_w = _idaapi.MIPS_dextr_rs_w -MIPS_dextr_s_h = _idaapi.MIPS_dextr_s_h -MIPS_dextr_rs_l = _idaapi.MIPS_dextr_rs_l -MIPS_dextrv_rs_w = _idaapi.MIPS_dextrv_rs_w -MIPS_dextrv_s_h = _idaapi.MIPS_dextrv_s_h -MIPS_dextrv_rs_l = _idaapi.MIPS_dextrv_rs_l -MIPS_dmthlip = _idaapi.MIPS_dmthlip -MIPS_adduh_qb = _idaapi.MIPS_adduh_qb -MIPS_addqh_ph = _idaapi.MIPS_addqh_ph -MIPS_addqh_w = _idaapi.MIPS_addqh_w -MIPS_subuh_qb = _idaapi.MIPS_subuh_qb -MIPS_subqh_ph = _idaapi.MIPS_subqh_ph -MIPS_subqh_w = _idaapi.MIPS_subqh_w -MIPS_adduh_r_qb = _idaapi.MIPS_adduh_r_qb -MIPS_addqh_r_ph = _idaapi.MIPS_addqh_r_ph -MIPS_addqh_r_w = _idaapi.MIPS_addqh_r_w -MIPS_subuh_r_qb = _idaapi.MIPS_subuh_r_qb -MIPS_subqh_r_ph = _idaapi.MIPS_subqh_r_ph -MIPS_subqh_r_w = _idaapi.MIPS_subqh_r_w -MIPS_mul_ph = _idaapi.MIPS_mul_ph -MIPS_mul_s_ph = _idaapi.MIPS_mul_s_ph -MIPS_mulq_s_w = _idaapi.MIPS_mulq_s_w -MIPS_mulq_rs_w = _idaapi.MIPS_mulq_rs_w -MIPS_append = _idaapi.MIPS_append -MIPS_balign = _idaapi.MIPS_balign -MIPS_prepend = _idaapi.MIPS_prepend -MIPS_laa = _idaapi.MIPS_laa -MIPS_laad = _idaapi.MIPS_laad -MIPS_lac = _idaapi.MIPS_lac -MIPS_lacd = _idaapi.MIPS_lacd -MIPS_lad = _idaapi.MIPS_lad -MIPS_ladd = _idaapi.MIPS_ladd -MIPS_lai = _idaapi.MIPS_lai -MIPS_laid = _idaapi.MIPS_laid -MIPS_las = _idaapi.MIPS_las -MIPS_lasd = _idaapi.MIPS_lasd -MIPS_law = _idaapi.MIPS_law -MIPS_lawd = _idaapi.MIPS_lawd -MIPS_lbx = _idaapi.MIPS_lbx -MIPS_lhux = _idaapi.MIPS_lhux -MIPS_lwux = _idaapi.MIPS_lwux -MIPS_qmac_00 = _idaapi.MIPS_qmac_00 -MIPS_qmac_01 = _idaapi.MIPS_qmac_01 -MIPS_qmac_02 = _idaapi.MIPS_qmac_02 -MIPS_qmac_03 = _idaapi.MIPS_qmac_03 -MIPS_qmacs_00 = _idaapi.MIPS_qmacs_00 -MIPS_qmacs_01 = _idaapi.MIPS_qmacs_01 -MIPS_qmacs_02 = _idaapi.MIPS_qmacs_02 -MIPS_qmacs_03 = _idaapi.MIPS_qmacs_03 -MIPS_zcb = _idaapi.MIPS_zcb -MIPS_zcbt = _idaapi.MIPS_zcbt -MIPS_msa_sll_b = _idaapi.MIPS_msa_sll_b -MIPS_msa_sll_h = _idaapi.MIPS_msa_sll_h -MIPS_msa_sll_w = _idaapi.MIPS_msa_sll_w -MIPS_msa_sll_d = _idaapi.MIPS_msa_sll_d -MIPS_msa_slli_b = _idaapi.MIPS_msa_slli_b -MIPS_msa_slli_h = _idaapi.MIPS_msa_slli_h -MIPS_msa_slli_w = _idaapi.MIPS_msa_slli_w -MIPS_msa_slli_d = _idaapi.MIPS_msa_slli_d -MIPS_msa_sra_b = _idaapi.MIPS_msa_sra_b -MIPS_msa_sra_h = _idaapi.MIPS_msa_sra_h -MIPS_msa_sra_w = _idaapi.MIPS_msa_sra_w -MIPS_msa_sra_d = _idaapi.MIPS_msa_sra_d -MIPS_msa_srai_b = _idaapi.MIPS_msa_srai_b -MIPS_msa_srai_h = _idaapi.MIPS_msa_srai_h -MIPS_msa_srai_w = _idaapi.MIPS_msa_srai_w -MIPS_msa_srai_d = _idaapi.MIPS_msa_srai_d -MIPS_msa_srl_b = _idaapi.MIPS_msa_srl_b -MIPS_msa_srl_h = _idaapi.MIPS_msa_srl_h -MIPS_msa_srl_w = _idaapi.MIPS_msa_srl_w -MIPS_msa_srl_d = _idaapi.MIPS_msa_srl_d -MIPS_msa_srli_b = _idaapi.MIPS_msa_srli_b -MIPS_msa_srli_h = _idaapi.MIPS_msa_srli_h -MIPS_msa_srli_w = _idaapi.MIPS_msa_srli_w -MIPS_msa_srli_d = _idaapi.MIPS_msa_srli_d -MIPS_msa_bclr_b = _idaapi.MIPS_msa_bclr_b -MIPS_msa_bclr_h = _idaapi.MIPS_msa_bclr_h -MIPS_msa_bclr_w = _idaapi.MIPS_msa_bclr_w -MIPS_msa_bclr_d = _idaapi.MIPS_msa_bclr_d -MIPS_msa_bclri_b = _idaapi.MIPS_msa_bclri_b -MIPS_msa_bclri_h = _idaapi.MIPS_msa_bclri_h -MIPS_msa_bclri_w = _idaapi.MIPS_msa_bclri_w -MIPS_msa_bclri_d = _idaapi.MIPS_msa_bclri_d -MIPS_msa_bset_b = _idaapi.MIPS_msa_bset_b -MIPS_msa_bset_h = _idaapi.MIPS_msa_bset_h -MIPS_msa_bset_w = _idaapi.MIPS_msa_bset_w -MIPS_msa_bset_d = _idaapi.MIPS_msa_bset_d -MIPS_msa_bseti_b = _idaapi.MIPS_msa_bseti_b -MIPS_msa_bseti_h = _idaapi.MIPS_msa_bseti_h -MIPS_msa_bseti_w = _idaapi.MIPS_msa_bseti_w -MIPS_msa_bseti_d = _idaapi.MIPS_msa_bseti_d -MIPS_msa_bneg_b = _idaapi.MIPS_msa_bneg_b -MIPS_msa_bneg_h = _idaapi.MIPS_msa_bneg_h -MIPS_msa_bneg_w = _idaapi.MIPS_msa_bneg_w -MIPS_msa_bneg_d = _idaapi.MIPS_msa_bneg_d -MIPS_msa_bnegi_b = _idaapi.MIPS_msa_bnegi_b -MIPS_msa_bnegi_h = _idaapi.MIPS_msa_bnegi_h -MIPS_msa_bnegi_w = _idaapi.MIPS_msa_bnegi_w -MIPS_msa_bnegi_d = _idaapi.MIPS_msa_bnegi_d -MIPS_msa_binsl_b = _idaapi.MIPS_msa_binsl_b -MIPS_msa_binsl_h = _idaapi.MIPS_msa_binsl_h -MIPS_msa_binsl_w = _idaapi.MIPS_msa_binsl_w -MIPS_msa_binsl_d = _idaapi.MIPS_msa_binsl_d -MIPS_msa_binsli_b = _idaapi.MIPS_msa_binsli_b -MIPS_msa_binsli_h = _idaapi.MIPS_msa_binsli_h -MIPS_msa_binsli_w = _idaapi.MIPS_msa_binsli_w -MIPS_msa_binsli_d = _idaapi.MIPS_msa_binsli_d -MIPS_msa_binsr_b = _idaapi.MIPS_msa_binsr_b -MIPS_msa_binsr_h = _idaapi.MIPS_msa_binsr_h -MIPS_msa_binsr_w = _idaapi.MIPS_msa_binsr_w -MIPS_msa_binsr_d = _idaapi.MIPS_msa_binsr_d -MIPS_msa_binsri_b = _idaapi.MIPS_msa_binsri_b -MIPS_msa_binsri_h = _idaapi.MIPS_msa_binsri_h -MIPS_msa_binsri_w = _idaapi.MIPS_msa_binsri_w -MIPS_msa_binsri_d = _idaapi.MIPS_msa_binsri_d -MIPS_msa_addv_b = _idaapi.MIPS_msa_addv_b -MIPS_msa_addv_h = _idaapi.MIPS_msa_addv_h -MIPS_msa_addv_w = _idaapi.MIPS_msa_addv_w -MIPS_msa_addv_d = _idaapi.MIPS_msa_addv_d -MIPS_msa_addvi_b = _idaapi.MIPS_msa_addvi_b -MIPS_msa_addvi_h = _idaapi.MIPS_msa_addvi_h -MIPS_msa_addvi_w = _idaapi.MIPS_msa_addvi_w -MIPS_msa_addvi_d = _idaapi.MIPS_msa_addvi_d -MIPS_msa_subv_b = _idaapi.MIPS_msa_subv_b -MIPS_msa_subv_h = _idaapi.MIPS_msa_subv_h -MIPS_msa_subv_w = _idaapi.MIPS_msa_subv_w -MIPS_msa_subv_d = _idaapi.MIPS_msa_subv_d -MIPS_msa_subvi_b = _idaapi.MIPS_msa_subvi_b -MIPS_msa_subvi_h = _idaapi.MIPS_msa_subvi_h -MIPS_msa_subvi_w = _idaapi.MIPS_msa_subvi_w -MIPS_msa_subvi_d = _idaapi.MIPS_msa_subvi_d -MIPS_msa_max_s_b = _idaapi.MIPS_msa_max_s_b -MIPS_msa_max_s_h = _idaapi.MIPS_msa_max_s_h -MIPS_msa_max_s_w = _idaapi.MIPS_msa_max_s_w -MIPS_msa_max_s_d = _idaapi.MIPS_msa_max_s_d -MIPS_msa_maxi_s_b = _idaapi.MIPS_msa_maxi_s_b -MIPS_msa_maxi_s_h = _idaapi.MIPS_msa_maxi_s_h -MIPS_msa_maxi_s_w = _idaapi.MIPS_msa_maxi_s_w -MIPS_msa_maxi_s_d = _idaapi.MIPS_msa_maxi_s_d -MIPS_msa_max_u_b = _idaapi.MIPS_msa_max_u_b -MIPS_msa_max_u_h = _idaapi.MIPS_msa_max_u_h -MIPS_msa_max_u_w = _idaapi.MIPS_msa_max_u_w -MIPS_msa_max_u_d = _idaapi.MIPS_msa_max_u_d -MIPS_msa_maxi_u_b = _idaapi.MIPS_msa_maxi_u_b -MIPS_msa_maxi_u_h = _idaapi.MIPS_msa_maxi_u_h -MIPS_msa_maxi_u_w = _idaapi.MIPS_msa_maxi_u_w -MIPS_msa_maxi_u_d = _idaapi.MIPS_msa_maxi_u_d -MIPS_msa_min_s_b = _idaapi.MIPS_msa_min_s_b -MIPS_msa_min_s_h = _idaapi.MIPS_msa_min_s_h -MIPS_msa_min_s_w = _idaapi.MIPS_msa_min_s_w -MIPS_msa_min_s_d = _idaapi.MIPS_msa_min_s_d -MIPS_msa_mini_s_b = _idaapi.MIPS_msa_mini_s_b -MIPS_msa_mini_s_h = _idaapi.MIPS_msa_mini_s_h -MIPS_msa_mini_s_w = _idaapi.MIPS_msa_mini_s_w -MIPS_msa_mini_s_d = _idaapi.MIPS_msa_mini_s_d -MIPS_msa_min_u_b = _idaapi.MIPS_msa_min_u_b -MIPS_msa_min_u_h = _idaapi.MIPS_msa_min_u_h -MIPS_msa_min_u_w = _idaapi.MIPS_msa_min_u_w -MIPS_msa_min_u_d = _idaapi.MIPS_msa_min_u_d -MIPS_msa_mini_u_b = _idaapi.MIPS_msa_mini_u_b -MIPS_msa_mini_u_h = _idaapi.MIPS_msa_mini_u_h -MIPS_msa_mini_u_w = _idaapi.MIPS_msa_mini_u_w -MIPS_msa_mini_u_d = _idaapi.MIPS_msa_mini_u_d -MIPS_msa_max_a_b = _idaapi.MIPS_msa_max_a_b -MIPS_msa_max_a_h = _idaapi.MIPS_msa_max_a_h -MIPS_msa_max_a_w = _idaapi.MIPS_msa_max_a_w -MIPS_msa_max_a_d = _idaapi.MIPS_msa_max_a_d -MIPS_msa_min_a_b = _idaapi.MIPS_msa_min_a_b -MIPS_msa_min_a_h = _idaapi.MIPS_msa_min_a_h -MIPS_msa_min_a_w = _idaapi.MIPS_msa_min_a_w -MIPS_msa_min_a_d = _idaapi.MIPS_msa_min_a_d -MIPS_msa_ceq_b = _idaapi.MIPS_msa_ceq_b -MIPS_msa_ceq_h = _idaapi.MIPS_msa_ceq_h -MIPS_msa_ceq_w = _idaapi.MIPS_msa_ceq_w -MIPS_msa_ceq_d = _idaapi.MIPS_msa_ceq_d -MIPS_msa_ceqi_b = _idaapi.MIPS_msa_ceqi_b -MIPS_msa_ceqi_h = _idaapi.MIPS_msa_ceqi_h -MIPS_msa_ceqi_w = _idaapi.MIPS_msa_ceqi_w -MIPS_msa_ceqi_d = _idaapi.MIPS_msa_ceqi_d -MIPS_msa_clt_s_b = _idaapi.MIPS_msa_clt_s_b -MIPS_msa_clt_s_h = _idaapi.MIPS_msa_clt_s_h -MIPS_msa_clt_s_w = _idaapi.MIPS_msa_clt_s_w -MIPS_msa_clt_s_d = _idaapi.MIPS_msa_clt_s_d -MIPS_msa_clti_s_b = _idaapi.MIPS_msa_clti_s_b -MIPS_msa_clti_s_h = _idaapi.MIPS_msa_clti_s_h -MIPS_msa_clti_s_w = _idaapi.MIPS_msa_clti_s_w -MIPS_msa_clti_s_d = _idaapi.MIPS_msa_clti_s_d -MIPS_msa_clt_u_b = _idaapi.MIPS_msa_clt_u_b -MIPS_msa_clt_u_h = _idaapi.MIPS_msa_clt_u_h -MIPS_msa_clt_u_w = _idaapi.MIPS_msa_clt_u_w -MIPS_msa_clt_u_d = _idaapi.MIPS_msa_clt_u_d -MIPS_msa_clti_u_b = _idaapi.MIPS_msa_clti_u_b -MIPS_msa_clti_u_h = _idaapi.MIPS_msa_clti_u_h -MIPS_msa_clti_u_w = _idaapi.MIPS_msa_clti_u_w -MIPS_msa_clti_u_d = _idaapi.MIPS_msa_clti_u_d -MIPS_msa_cle_s_b = _idaapi.MIPS_msa_cle_s_b -MIPS_msa_cle_s_h = _idaapi.MIPS_msa_cle_s_h -MIPS_msa_cle_s_w = _idaapi.MIPS_msa_cle_s_w -MIPS_msa_cle_s_d = _idaapi.MIPS_msa_cle_s_d -MIPS_msa_clei_s_b = _idaapi.MIPS_msa_clei_s_b -MIPS_msa_clei_s_h = _idaapi.MIPS_msa_clei_s_h -MIPS_msa_clei_s_w = _idaapi.MIPS_msa_clei_s_w -MIPS_msa_clei_s_d = _idaapi.MIPS_msa_clei_s_d -MIPS_msa_cle_u_b = _idaapi.MIPS_msa_cle_u_b -MIPS_msa_cle_u_h = _idaapi.MIPS_msa_cle_u_h -MIPS_msa_cle_u_w = _idaapi.MIPS_msa_cle_u_w -MIPS_msa_cle_u_d = _idaapi.MIPS_msa_cle_u_d -MIPS_msa_clei_u_b = _idaapi.MIPS_msa_clei_u_b -MIPS_msa_clei_u_h = _idaapi.MIPS_msa_clei_u_h -MIPS_msa_clei_u_w = _idaapi.MIPS_msa_clei_u_w -MIPS_msa_clei_u_d = _idaapi.MIPS_msa_clei_u_d -MIPS_msa_ld_b = _idaapi.MIPS_msa_ld_b -MIPS_msa_ld_h = _idaapi.MIPS_msa_ld_h -MIPS_msa_ld_w = _idaapi.MIPS_msa_ld_w -MIPS_msa_ld_d = _idaapi.MIPS_msa_ld_d -MIPS_msa_st_b = _idaapi.MIPS_msa_st_b -MIPS_msa_st_h = _idaapi.MIPS_msa_st_h -MIPS_msa_st_w = _idaapi.MIPS_msa_st_w -MIPS_msa_st_d = _idaapi.MIPS_msa_st_d -MIPS_msa_sat_s_b = _idaapi.MIPS_msa_sat_s_b -MIPS_msa_sat_s_h = _idaapi.MIPS_msa_sat_s_h -MIPS_msa_sat_s_w = _idaapi.MIPS_msa_sat_s_w -MIPS_msa_sat_s_d = _idaapi.MIPS_msa_sat_s_d -MIPS_msa_sat_u_b = _idaapi.MIPS_msa_sat_u_b -MIPS_msa_sat_u_h = _idaapi.MIPS_msa_sat_u_h -MIPS_msa_sat_u_w = _idaapi.MIPS_msa_sat_u_w -MIPS_msa_sat_u_d = _idaapi.MIPS_msa_sat_u_d -MIPS_msa_add_a_b = _idaapi.MIPS_msa_add_a_b -MIPS_msa_add_a_h = _idaapi.MIPS_msa_add_a_h -MIPS_msa_add_a_w = _idaapi.MIPS_msa_add_a_w -MIPS_msa_add_a_d = _idaapi.MIPS_msa_add_a_d -MIPS_msa_adds_a_b = _idaapi.MIPS_msa_adds_a_b -MIPS_msa_adds_a_h = _idaapi.MIPS_msa_adds_a_h -MIPS_msa_adds_a_w = _idaapi.MIPS_msa_adds_a_w -MIPS_msa_adds_a_d = _idaapi.MIPS_msa_adds_a_d -MIPS_msa_adds_s_b = _idaapi.MIPS_msa_adds_s_b -MIPS_msa_adds_s_h = _idaapi.MIPS_msa_adds_s_h -MIPS_msa_adds_s_w = _idaapi.MIPS_msa_adds_s_w -MIPS_msa_adds_s_d = _idaapi.MIPS_msa_adds_s_d -MIPS_msa_adds_u_b = _idaapi.MIPS_msa_adds_u_b -MIPS_msa_adds_u_h = _idaapi.MIPS_msa_adds_u_h -MIPS_msa_adds_u_w = _idaapi.MIPS_msa_adds_u_w -MIPS_msa_adds_u_d = _idaapi.MIPS_msa_adds_u_d -MIPS_msa_ave_s_b = _idaapi.MIPS_msa_ave_s_b -MIPS_msa_ave_s_h = _idaapi.MIPS_msa_ave_s_h -MIPS_msa_ave_s_w = _idaapi.MIPS_msa_ave_s_w -MIPS_msa_ave_s_d = _idaapi.MIPS_msa_ave_s_d -MIPS_msa_ave_u_b = _idaapi.MIPS_msa_ave_u_b -MIPS_msa_ave_u_h = _idaapi.MIPS_msa_ave_u_h -MIPS_msa_ave_u_w = _idaapi.MIPS_msa_ave_u_w -MIPS_msa_ave_u_d = _idaapi.MIPS_msa_ave_u_d -MIPS_msa_aver_s_b = _idaapi.MIPS_msa_aver_s_b -MIPS_msa_aver_s_h = _idaapi.MIPS_msa_aver_s_h -MIPS_msa_aver_s_w = _idaapi.MIPS_msa_aver_s_w -MIPS_msa_aver_s_d = _idaapi.MIPS_msa_aver_s_d -MIPS_msa_aver_u_b = _idaapi.MIPS_msa_aver_u_b -MIPS_msa_aver_u_h = _idaapi.MIPS_msa_aver_u_h -MIPS_msa_aver_u_w = _idaapi.MIPS_msa_aver_u_w -MIPS_msa_aver_u_d = _idaapi.MIPS_msa_aver_u_d -MIPS_msa_subs_s_b = _idaapi.MIPS_msa_subs_s_b -MIPS_msa_subs_s_h = _idaapi.MIPS_msa_subs_s_h -MIPS_msa_subs_s_w = _idaapi.MIPS_msa_subs_s_w -MIPS_msa_subs_s_d = _idaapi.MIPS_msa_subs_s_d -MIPS_msa_subs_u_b = _idaapi.MIPS_msa_subs_u_b -MIPS_msa_subs_u_h = _idaapi.MIPS_msa_subs_u_h -MIPS_msa_subs_u_w = _idaapi.MIPS_msa_subs_u_w -MIPS_msa_subs_u_d = _idaapi.MIPS_msa_subs_u_d -MIPS_msa_subsus_u_b = _idaapi.MIPS_msa_subsus_u_b -MIPS_msa_subsus_u_h = _idaapi.MIPS_msa_subsus_u_h -MIPS_msa_subsus_u_w = _idaapi.MIPS_msa_subsus_u_w -MIPS_msa_subsus_u_d = _idaapi.MIPS_msa_subsus_u_d -MIPS_msa_subsuu_s_b = _idaapi.MIPS_msa_subsuu_s_b -MIPS_msa_subsuu_s_h = _idaapi.MIPS_msa_subsuu_s_h -MIPS_msa_subsuu_s_w = _idaapi.MIPS_msa_subsuu_s_w -MIPS_msa_subsuu_s_d = _idaapi.MIPS_msa_subsuu_s_d -MIPS_msa_asub_s_b = _idaapi.MIPS_msa_asub_s_b -MIPS_msa_asub_s_h = _idaapi.MIPS_msa_asub_s_h -MIPS_msa_asub_s_w = _idaapi.MIPS_msa_asub_s_w -MIPS_msa_asub_s_d = _idaapi.MIPS_msa_asub_s_d -MIPS_msa_asub_u_b = _idaapi.MIPS_msa_asub_u_b -MIPS_msa_asub_u_h = _idaapi.MIPS_msa_asub_u_h -MIPS_msa_asub_u_w = _idaapi.MIPS_msa_asub_u_w -MIPS_msa_asub_u_d = _idaapi.MIPS_msa_asub_u_d -MIPS_msa_mulv_b = _idaapi.MIPS_msa_mulv_b -MIPS_msa_mulv_h = _idaapi.MIPS_msa_mulv_h -MIPS_msa_mulv_w = _idaapi.MIPS_msa_mulv_w -MIPS_msa_mulv_d = _idaapi.MIPS_msa_mulv_d -MIPS_msa_maddv_b = _idaapi.MIPS_msa_maddv_b -MIPS_msa_maddv_h = _idaapi.MIPS_msa_maddv_h -MIPS_msa_maddv_w = _idaapi.MIPS_msa_maddv_w -MIPS_msa_maddv_d = _idaapi.MIPS_msa_maddv_d -MIPS_msa_msubv_b = _idaapi.MIPS_msa_msubv_b -MIPS_msa_msubv_h = _idaapi.MIPS_msa_msubv_h -MIPS_msa_msubv_w = _idaapi.MIPS_msa_msubv_w -MIPS_msa_msubv_d = _idaapi.MIPS_msa_msubv_d -MIPS_msa_div_s_b = _idaapi.MIPS_msa_div_s_b -MIPS_msa_div_s_h = _idaapi.MIPS_msa_div_s_h -MIPS_msa_div_s_w = _idaapi.MIPS_msa_div_s_w -MIPS_msa_div_s_d = _idaapi.MIPS_msa_div_s_d -MIPS_msa_div_u_b = _idaapi.MIPS_msa_div_u_b -MIPS_msa_div_u_h = _idaapi.MIPS_msa_div_u_h -MIPS_msa_div_u_w = _idaapi.MIPS_msa_div_u_w -MIPS_msa_div_u_d = _idaapi.MIPS_msa_div_u_d -MIPS_msa_mod_s_b = _idaapi.MIPS_msa_mod_s_b -MIPS_msa_mod_s_h = _idaapi.MIPS_msa_mod_s_h -MIPS_msa_mod_s_w = _idaapi.MIPS_msa_mod_s_w -MIPS_msa_mod_s_d = _idaapi.MIPS_msa_mod_s_d -MIPS_msa_mod_u_b = _idaapi.MIPS_msa_mod_u_b -MIPS_msa_mod_u_h = _idaapi.MIPS_msa_mod_u_h -MIPS_msa_mod_u_w = _idaapi.MIPS_msa_mod_u_w -MIPS_msa_mod_u_d = _idaapi.MIPS_msa_mod_u_d -MIPS_msa_dotp_s_h = _idaapi.MIPS_msa_dotp_s_h -MIPS_msa_dotp_s_w = _idaapi.MIPS_msa_dotp_s_w -MIPS_msa_dotp_s_d = _idaapi.MIPS_msa_dotp_s_d -MIPS_msa_dotp_u_h = _idaapi.MIPS_msa_dotp_u_h -MIPS_msa_dotp_u_w = _idaapi.MIPS_msa_dotp_u_w -MIPS_msa_dotp_u_d = _idaapi.MIPS_msa_dotp_u_d -MIPS_msa_dpadd_s_h = _idaapi.MIPS_msa_dpadd_s_h -MIPS_msa_dpadd_s_w = _idaapi.MIPS_msa_dpadd_s_w -MIPS_msa_dpadd_s_d = _idaapi.MIPS_msa_dpadd_s_d -MIPS_msa_dpadd_u_h = _idaapi.MIPS_msa_dpadd_u_h -MIPS_msa_dpadd_u_w = _idaapi.MIPS_msa_dpadd_u_w -MIPS_msa_dpadd_u_d = _idaapi.MIPS_msa_dpadd_u_d -MIPS_msa_dpsub_s_h = _idaapi.MIPS_msa_dpsub_s_h -MIPS_msa_dpsub_s_w = _idaapi.MIPS_msa_dpsub_s_w -MIPS_msa_dpsub_s_d = _idaapi.MIPS_msa_dpsub_s_d -MIPS_msa_dpsub_u_h = _idaapi.MIPS_msa_dpsub_u_h -MIPS_msa_dpsub_u_w = _idaapi.MIPS_msa_dpsub_u_w -MIPS_msa_dpsub_u_d = _idaapi.MIPS_msa_dpsub_u_d -MIPS_msa_sld_b = _idaapi.MIPS_msa_sld_b -MIPS_msa_sld_h = _idaapi.MIPS_msa_sld_h -MIPS_msa_sld_w = _idaapi.MIPS_msa_sld_w -MIPS_msa_sld_d = _idaapi.MIPS_msa_sld_d -MIPS_msa_sldi_b = _idaapi.MIPS_msa_sldi_b -MIPS_msa_sldi_h = _idaapi.MIPS_msa_sldi_h -MIPS_msa_sldi_w = _idaapi.MIPS_msa_sldi_w -MIPS_msa_sldi_d = _idaapi.MIPS_msa_sldi_d -MIPS_msa_splat_b = _idaapi.MIPS_msa_splat_b -MIPS_msa_splat_h = _idaapi.MIPS_msa_splat_h -MIPS_msa_splat_w = _idaapi.MIPS_msa_splat_w -MIPS_msa_splat_d = _idaapi.MIPS_msa_splat_d -MIPS_msa_splati_b = _idaapi.MIPS_msa_splati_b -MIPS_msa_splati_h = _idaapi.MIPS_msa_splati_h -MIPS_msa_splati_w = _idaapi.MIPS_msa_splati_w -MIPS_msa_splati_d = _idaapi.MIPS_msa_splati_d -MIPS_msa_pckev_b = _idaapi.MIPS_msa_pckev_b -MIPS_msa_pckev_h = _idaapi.MIPS_msa_pckev_h -MIPS_msa_pckev_w = _idaapi.MIPS_msa_pckev_w -MIPS_msa_pckev_d = _idaapi.MIPS_msa_pckev_d -MIPS_msa_pckod_b = _idaapi.MIPS_msa_pckod_b -MIPS_msa_pckod_h = _idaapi.MIPS_msa_pckod_h -MIPS_msa_pckod_w = _idaapi.MIPS_msa_pckod_w -MIPS_msa_pckod_d = _idaapi.MIPS_msa_pckod_d -MIPS_msa_ilvl_b = _idaapi.MIPS_msa_ilvl_b -MIPS_msa_ilvl_h = _idaapi.MIPS_msa_ilvl_h -MIPS_msa_ilvl_w = _idaapi.MIPS_msa_ilvl_w -MIPS_msa_ilvl_d = _idaapi.MIPS_msa_ilvl_d -MIPS_msa_ilvr_b = _idaapi.MIPS_msa_ilvr_b -MIPS_msa_ilvr_h = _idaapi.MIPS_msa_ilvr_h -MIPS_msa_ilvr_w = _idaapi.MIPS_msa_ilvr_w -MIPS_msa_ilvr_d = _idaapi.MIPS_msa_ilvr_d -MIPS_msa_ilvev_b = _idaapi.MIPS_msa_ilvev_b -MIPS_msa_ilvev_h = _idaapi.MIPS_msa_ilvev_h -MIPS_msa_ilvev_w = _idaapi.MIPS_msa_ilvev_w -MIPS_msa_ilvev_d = _idaapi.MIPS_msa_ilvev_d -MIPS_msa_ilvod_b = _idaapi.MIPS_msa_ilvod_b -MIPS_msa_ilvod_h = _idaapi.MIPS_msa_ilvod_h -MIPS_msa_ilvod_w = _idaapi.MIPS_msa_ilvod_w -MIPS_msa_ilvod_d = _idaapi.MIPS_msa_ilvod_d -MIPS_msa_vshf_b = _idaapi.MIPS_msa_vshf_b -MIPS_msa_vshf_h = _idaapi.MIPS_msa_vshf_h -MIPS_msa_vshf_w = _idaapi.MIPS_msa_vshf_w -MIPS_msa_vshf_d = _idaapi.MIPS_msa_vshf_d -MIPS_msa_srar_b = _idaapi.MIPS_msa_srar_b -MIPS_msa_srar_h = _idaapi.MIPS_msa_srar_h -MIPS_msa_srar_w = _idaapi.MIPS_msa_srar_w -MIPS_msa_srar_d = _idaapi.MIPS_msa_srar_d -MIPS_msa_srari_b = _idaapi.MIPS_msa_srari_b -MIPS_msa_srari_h = _idaapi.MIPS_msa_srari_h -MIPS_msa_srari_w = _idaapi.MIPS_msa_srari_w -MIPS_msa_srari_d = _idaapi.MIPS_msa_srari_d -MIPS_msa_srlr_b = _idaapi.MIPS_msa_srlr_b -MIPS_msa_srlr_h = _idaapi.MIPS_msa_srlr_h -MIPS_msa_srlr_w = _idaapi.MIPS_msa_srlr_w -MIPS_msa_srlr_d = _idaapi.MIPS_msa_srlr_d -MIPS_msa_srlri_b = _idaapi.MIPS_msa_srlri_b -MIPS_msa_srlri_h = _idaapi.MIPS_msa_srlri_h -MIPS_msa_srlri_w = _idaapi.MIPS_msa_srlri_w -MIPS_msa_srlri_d = _idaapi.MIPS_msa_srlri_d -MIPS_msa_hadd_s_h = _idaapi.MIPS_msa_hadd_s_h -MIPS_msa_hadd_s_w = _idaapi.MIPS_msa_hadd_s_w -MIPS_msa_hadd_s_d = _idaapi.MIPS_msa_hadd_s_d -MIPS_msa_hadd_u_h = _idaapi.MIPS_msa_hadd_u_h -MIPS_msa_hadd_u_w = _idaapi.MIPS_msa_hadd_u_w -MIPS_msa_hadd_u_d = _idaapi.MIPS_msa_hadd_u_d -MIPS_msa_hsub_s_h = _idaapi.MIPS_msa_hsub_s_h -MIPS_msa_hsub_s_w = _idaapi.MIPS_msa_hsub_s_w -MIPS_msa_hsub_s_d = _idaapi.MIPS_msa_hsub_s_d -MIPS_msa_hsub_u_h = _idaapi.MIPS_msa_hsub_u_h -MIPS_msa_hsub_u_w = _idaapi.MIPS_msa_hsub_u_w -MIPS_msa_hsub_u_d = _idaapi.MIPS_msa_hsub_u_d -MIPS_msa_and_v = _idaapi.MIPS_msa_and_v -MIPS_msa_andi_b = _idaapi.MIPS_msa_andi_b -MIPS_msa_or_v = _idaapi.MIPS_msa_or_v -MIPS_msa_ori_b = _idaapi.MIPS_msa_ori_b -MIPS_msa_nor_v = _idaapi.MIPS_msa_nor_v -MIPS_msa_nori_b = _idaapi.MIPS_msa_nori_b -MIPS_msa_xor_v = _idaapi.MIPS_msa_xor_v -MIPS_msa_xori_b = _idaapi.MIPS_msa_xori_b -MIPS_msa_bmnz_v = _idaapi.MIPS_msa_bmnz_v -MIPS_msa_bmnzi_b = _idaapi.MIPS_msa_bmnzi_b -MIPS_msa_bmz_v = _idaapi.MIPS_msa_bmz_v -MIPS_msa_bmzi_b = _idaapi.MIPS_msa_bmzi_b -MIPS_msa_bsel_v = _idaapi.MIPS_msa_bsel_v -MIPS_msa_bseli_b = _idaapi.MIPS_msa_bseli_b -MIPS_msa_shf_b = _idaapi.MIPS_msa_shf_b -MIPS_msa_shf_h = _idaapi.MIPS_msa_shf_h -MIPS_msa_shf_w = _idaapi.MIPS_msa_shf_w -MIPS_msa_bnz_v = _idaapi.MIPS_msa_bnz_v -MIPS_msa_bz_v = _idaapi.MIPS_msa_bz_v -MIPS_msa_fill_b = _idaapi.MIPS_msa_fill_b -MIPS_msa_fill_h = _idaapi.MIPS_msa_fill_h -MIPS_msa_fill_w = _idaapi.MIPS_msa_fill_w -MIPS_msa_fill_d = _idaapi.MIPS_msa_fill_d -MIPS_msa_pcnt_b = _idaapi.MIPS_msa_pcnt_b -MIPS_msa_pcnt_h = _idaapi.MIPS_msa_pcnt_h -MIPS_msa_pcnt_w = _idaapi.MIPS_msa_pcnt_w -MIPS_msa_pcnt_d = _idaapi.MIPS_msa_pcnt_d -MIPS_msa_nloc_b = _idaapi.MIPS_msa_nloc_b -MIPS_msa_nloc_h = _idaapi.MIPS_msa_nloc_h -MIPS_msa_nloc_w = _idaapi.MIPS_msa_nloc_w -MIPS_msa_nloc_d = _idaapi.MIPS_msa_nloc_d -MIPS_msa_nlzc_b = _idaapi.MIPS_msa_nlzc_b -MIPS_msa_nlzc_h = _idaapi.MIPS_msa_nlzc_h -MIPS_msa_nlzc_w = _idaapi.MIPS_msa_nlzc_w -MIPS_msa_nlzc_d = _idaapi.MIPS_msa_nlzc_d -MIPS_msa_copy_s_b = _idaapi.MIPS_msa_copy_s_b -MIPS_msa_copy_s_h = _idaapi.MIPS_msa_copy_s_h -MIPS_msa_copy_s_w = _idaapi.MIPS_msa_copy_s_w -MIPS_msa_copy_s_d = _idaapi.MIPS_msa_copy_s_d -MIPS_msa_copy_u_b = _idaapi.MIPS_msa_copy_u_b -MIPS_msa_copy_u_h = _idaapi.MIPS_msa_copy_u_h -MIPS_msa_copy_u_w = _idaapi.MIPS_msa_copy_u_w -MIPS_msa_copy_u_d = _idaapi.MIPS_msa_copy_u_d -MIPS_msa_insert_b = _idaapi.MIPS_msa_insert_b -MIPS_msa_insert_h = _idaapi.MIPS_msa_insert_h -MIPS_msa_insert_w = _idaapi.MIPS_msa_insert_w -MIPS_msa_insert_d = _idaapi.MIPS_msa_insert_d -MIPS_msa_insve_b = _idaapi.MIPS_msa_insve_b -MIPS_msa_insve_h = _idaapi.MIPS_msa_insve_h -MIPS_msa_insve_w = _idaapi.MIPS_msa_insve_w -MIPS_msa_insve_d = _idaapi.MIPS_msa_insve_d -MIPS_msa_bnz_b = _idaapi.MIPS_msa_bnz_b -MIPS_msa_bnz_h = _idaapi.MIPS_msa_bnz_h -MIPS_msa_bnz_w = _idaapi.MIPS_msa_bnz_w -MIPS_msa_bnz_d = _idaapi.MIPS_msa_bnz_d -MIPS_msa_bz_b = _idaapi.MIPS_msa_bz_b -MIPS_msa_bz_h = _idaapi.MIPS_msa_bz_h -MIPS_msa_bz_w = _idaapi.MIPS_msa_bz_w -MIPS_msa_bz_d = _idaapi.MIPS_msa_bz_d -MIPS_msa_ldi_b = _idaapi.MIPS_msa_ldi_b -MIPS_msa_ldi_h = _idaapi.MIPS_msa_ldi_h -MIPS_msa_ldi_w = _idaapi.MIPS_msa_ldi_w -MIPS_msa_ldi_d = _idaapi.MIPS_msa_ldi_d -MIPS_msa_fcaf_w = _idaapi.MIPS_msa_fcaf_w -MIPS_msa_fcaf_d = _idaapi.MIPS_msa_fcaf_d -MIPS_msa_fcun_w = _idaapi.MIPS_msa_fcun_w -MIPS_msa_fcun_d = _idaapi.MIPS_msa_fcun_d -MIPS_msa_fceq_w = _idaapi.MIPS_msa_fceq_w -MIPS_msa_fceq_d = _idaapi.MIPS_msa_fceq_d -MIPS_msa_fcueq_w = _idaapi.MIPS_msa_fcueq_w -MIPS_msa_fcueq_d = _idaapi.MIPS_msa_fcueq_d -MIPS_msa_fclt_w = _idaapi.MIPS_msa_fclt_w -MIPS_msa_fclt_d = _idaapi.MIPS_msa_fclt_d -MIPS_msa_fcult_w = _idaapi.MIPS_msa_fcult_w -MIPS_msa_fcult_d = _idaapi.MIPS_msa_fcult_d -MIPS_msa_fcle_w = _idaapi.MIPS_msa_fcle_w -MIPS_msa_fcle_d = _idaapi.MIPS_msa_fcle_d -MIPS_msa_fcule_w = _idaapi.MIPS_msa_fcule_w -MIPS_msa_fcule_d = _idaapi.MIPS_msa_fcule_d -MIPS_msa_fsaf_w = _idaapi.MIPS_msa_fsaf_w -MIPS_msa_fsaf_d = _idaapi.MIPS_msa_fsaf_d -MIPS_msa_fsun_w = _idaapi.MIPS_msa_fsun_w -MIPS_msa_fsun_d = _idaapi.MIPS_msa_fsun_d -MIPS_msa_fseq_w = _idaapi.MIPS_msa_fseq_w -MIPS_msa_fseq_d = _idaapi.MIPS_msa_fseq_d -MIPS_msa_fsueq_w = _idaapi.MIPS_msa_fsueq_w -MIPS_msa_fsueq_d = _idaapi.MIPS_msa_fsueq_d -MIPS_msa_fslt_w = _idaapi.MIPS_msa_fslt_w -MIPS_msa_fslt_d = _idaapi.MIPS_msa_fslt_d -MIPS_msa_fsult_w = _idaapi.MIPS_msa_fsult_w -MIPS_msa_fsult_d = _idaapi.MIPS_msa_fsult_d -MIPS_msa_fsle_w = _idaapi.MIPS_msa_fsle_w -MIPS_msa_fsle_d = _idaapi.MIPS_msa_fsle_d -MIPS_msa_fsule_w = _idaapi.MIPS_msa_fsule_w -MIPS_msa_fsule_d = _idaapi.MIPS_msa_fsule_d -MIPS_msa_fadd_w = _idaapi.MIPS_msa_fadd_w -MIPS_msa_fadd_d = _idaapi.MIPS_msa_fadd_d -MIPS_msa_fsub_w = _idaapi.MIPS_msa_fsub_w -MIPS_msa_fsub_d = _idaapi.MIPS_msa_fsub_d -MIPS_msa_fmul_w = _idaapi.MIPS_msa_fmul_w -MIPS_msa_fmul_d = _idaapi.MIPS_msa_fmul_d -MIPS_msa_fdiv_w = _idaapi.MIPS_msa_fdiv_w -MIPS_msa_fdiv_d = _idaapi.MIPS_msa_fdiv_d -MIPS_msa_fmadd_w = _idaapi.MIPS_msa_fmadd_w -MIPS_msa_fmadd_d = _idaapi.MIPS_msa_fmadd_d -MIPS_msa_fmsub_w = _idaapi.MIPS_msa_fmsub_w -MIPS_msa_fmsub_d = _idaapi.MIPS_msa_fmsub_d -MIPS_msa_fexp2_w = _idaapi.MIPS_msa_fexp2_w -MIPS_msa_fexp2_d = _idaapi.MIPS_msa_fexp2_d -MIPS_msa_fexdo_h = _idaapi.MIPS_msa_fexdo_h -MIPS_msa_fexdo_w = _idaapi.MIPS_msa_fexdo_w -MIPS_msa_ftq_h = _idaapi.MIPS_msa_ftq_h -MIPS_msa_ftq_w = _idaapi.MIPS_msa_ftq_w -MIPS_msa_fmin_w = _idaapi.MIPS_msa_fmin_w -MIPS_msa_fmin_d = _idaapi.MIPS_msa_fmin_d -MIPS_msa_fmin_a_w = _idaapi.MIPS_msa_fmin_a_w -MIPS_msa_fmin_a_d = _idaapi.MIPS_msa_fmin_a_d -MIPS_msa_fmax_w = _idaapi.MIPS_msa_fmax_w -MIPS_msa_fmax_d = _idaapi.MIPS_msa_fmax_d -MIPS_msa_fmax_a_w = _idaapi.MIPS_msa_fmax_a_w -MIPS_msa_fmax_a_d = _idaapi.MIPS_msa_fmax_a_d -MIPS_msa_fcor_w = _idaapi.MIPS_msa_fcor_w -MIPS_msa_fcor_d = _idaapi.MIPS_msa_fcor_d -MIPS_msa_fcune_w = _idaapi.MIPS_msa_fcune_w -MIPS_msa_fcune_d = _idaapi.MIPS_msa_fcune_d -MIPS_msa_fcne_w = _idaapi.MIPS_msa_fcne_w -MIPS_msa_fcne_d = _idaapi.MIPS_msa_fcne_d -MIPS_msa_mul_q_h = _idaapi.MIPS_msa_mul_q_h -MIPS_msa_mul_q_w = _idaapi.MIPS_msa_mul_q_w -MIPS_msa_madd_q_h = _idaapi.MIPS_msa_madd_q_h -MIPS_msa_madd_q_w = _idaapi.MIPS_msa_madd_q_w -MIPS_msa_msub_q_h = _idaapi.MIPS_msa_msub_q_h -MIPS_msa_msub_q_w = _idaapi.MIPS_msa_msub_q_w -MIPS_msa_fsor_w = _idaapi.MIPS_msa_fsor_w -MIPS_msa_fsor_d = _idaapi.MIPS_msa_fsor_d -MIPS_msa_fsune_w = _idaapi.MIPS_msa_fsune_w -MIPS_msa_fsune_d = _idaapi.MIPS_msa_fsune_d -MIPS_msa_fsne_w = _idaapi.MIPS_msa_fsne_w -MIPS_msa_fsne_d = _idaapi.MIPS_msa_fsne_d -MIPS_msa_mulr_q_h = _idaapi.MIPS_msa_mulr_q_h -MIPS_msa_mulr_q_w = _idaapi.MIPS_msa_mulr_q_w -MIPS_msa_maddr_q_h = _idaapi.MIPS_msa_maddr_q_h -MIPS_msa_maddr_q_w = _idaapi.MIPS_msa_maddr_q_w -MIPS_msa_msubr_q_h = _idaapi.MIPS_msa_msubr_q_h -MIPS_msa_msubr_q_w = _idaapi.MIPS_msa_msubr_q_w -MIPS_msa_fclass_w = _idaapi.MIPS_msa_fclass_w -MIPS_msa_fclass_d = _idaapi.MIPS_msa_fclass_d -MIPS_msa_ftrunc_s_w = _idaapi.MIPS_msa_ftrunc_s_w -MIPS_msa_ftrunc_s_d = _idaapi.MIPS_msa_ftrunc_s_d -MIPS_msa_ftrunc_u_w = _idaapi.MIPS_msa_ftrunc_u_w -MIPS_msa_ftrunc_u_d = _idaapi.MIPS_msa_ftrunc_u_d -MIPS_msa_fsqrt_w = _idaapi.MIPS_msa_fsqrt_w -MIPS_msa_fsqrt_d = _idaapi.MIPS_msa_fsqrt_d -MIPS_msa_frsqrt_w = _idaapi.MIPS_msa_frsqrt_w -MIPS_msa_frsqrt_d = _idaapi.MIPS_msa_frsqrt_d -MIPS_msa_frcp_w = _idaapi.MIPS_msa_frcp_w -MIPS_msa_frcp_d = _idaapi.MIPS_msa_frcp_d -MIPS_msa_frint_w = _idaapi.MIPS_msa_frint_w -MIPS_msa_frint_d = _idaapi.MIPS_msa_frint_d -MIPS_msa_flog2_w = _idaapi.MIPS_msa_flog2_w -MIPS_msa_flog2_d = _idaapi.MIPS_msa_flog2_d -MIPS_msa_fexupl_w = _idaapi.MIPS_msa_fexupl_w -MIPS_msa_fexupl_d = _idaapi.MIPS_msa_fexupl_d -MIPS_msa_fexupr_w = _idaapi.MIPS_msa_fexupr_w -MIPS_msa_fexupr_d = _idaapi.MIPS_msa_fexupr_d -MIPS_msa_ffql_w = _idaapi.MIPS_msa_ffql_w -MIPS_msa_ffql_d = _idaapi.MIPS_msa_ffql_d -MIPS_msa_ffqr_w = _idaapi.MIPS_msa_ffqr_w -MIPS_msa_ffqr_d = _idaapi.MIPS_msa_ffqr_d -MIPS_msa_ftint_s_w = _idaapi.MIPS_msa_ftint_s_w -MIPS_msa_ftint_s_d = _idaapi.MIPS_msa_ftint_s_d -MIPS_msa_ftint_u_w = _idaapi.MIPS_msa_ftint_u_w -MIPS_msa_ftint_u_d = _idaapi.MIPS_msa_ftint_u_d -MIPS_msa_ffint_s_w = _idaapi.MIPS_msa_ffint_s_w -MIPS_msa_ffint_s_d = _idaapi.MIPS_msa_ffint_s_d -MIPS_msa_ffint_u_w = _idaapi.MIPS_msa_ffint_u_w -MIPS_msa_ffint_u_d = _idaapi.MIPS_msa_ffint_u_d -MIPS_msa_ctcmsa = _idaapi.MIPS_msa_ctcmsa -MIPS_msa_cfcmsa = _idaapi.MIPS_msa_cfcmsa -MIPS_msa_move_v = _idaapi.MIPS_msa_move_v -MIPS_lsa = _idaapi.MIPS_lsa -MIPS_dlsa = _idaapi.MIPS_dlsa MIPS_last = _idaapi.MIPS_last H8_null = _idaapi.H8_null H8_add = _idaapi.H8_add @@ -12485,140 +13933,6 @@ DSP56_zero = _idaapi.DSP56_zero DSP56_swi = _idaapi.DSP56_swi DSP56_pmov = _idaapi.DSP56_pmov DSP56_last = _idaapi.DSP56_last -DSP96_null = _idaapi.DSP96_null -DSP96_abs = _idaapi.DSP96_abs -DSP96_add = _idaapi.DSP96_add -DSP96_addc = _idaapi.DSP96_addc -DSP96_and = _idaapi.DSP96_and -DSP96_andc = _idaapi.DSP96_andc -DSP96_andi = _idaapi.DSP96_andi -DSP96_asl = _idaapi.DSP96_asl -DSP96_asr = _idaapi.DSP96_asr -DSP96_bcc = _idaapi.DSP96_bcc -DSP96_bccd = _idaapi.DSP96_bccd -DSP96_bchg = _idaapi.DSP96_bchg -DSP96_bclr = _idaapi.DSP96_bclr -DSP96_bfind = _idaapi.DSP96_bfind -DSP96_bra = _idaapi.DSP96_bra -DSP96_brclr = _idaapi.DSP96_brclr -DSP96_brset = _idaapi.DSP96_brset -DSP96_bscc = _idaapi.DSP96_bscc -DSP96_bsccd = _idaapi.DSP96_bsccd -DSP96_bsclr = _idaapi.DSP96_bsclr -DSP96_bset = _idaapi.DSP96_bset -DSP96_bsr = _idaapi.DSP96_bsr -DSP96_bsrd = _idaapi.DSP96_bsrd -DSP96_bsset = _idaapi.DSP96_bsset -DSP96_btst = _idaapi.DSP96_btst -DSP96_clr = _idaapi.DSP96_clr -DSP96_cmp = _idaapi.DSP96_cmp -DSP96_cmpg = _idaapi.DSP96_cmpg -DSP96_debugcc = _idaapi.DSP96_debugcc -DSP96_dec = _idaapi.DSP96_dec -DSP96_do = _idaapi.DSP96_do -DSP96_dor = _idaapi.DSP96_dor -DSP96_enddo = _idaapi.DSP96_enddo -DSP96_eor = _idaapi.DSP96_eor -DSP96_ext = _idaapi.DSP96_ext -DSP96_extb = _idaapi.DSP96_extb -DSP96_fabs = _idaapi.DSP96_fabs -DSP96_fadd = _idaapi.DSP96_fadd -DSP96_faddsub = _idaapi.DSP96_faddsub -DSP96_fbcc = _idaapi.DSP96_fbcc -DSP96_fbccd = _idaapi.DSP96_fbccd -DSP96_fbscc = _idaapi.DSP96_fbscc -DSP96_fbsccd = _idaapi.DSP96_fbsccd -DSP96_fclr = _idaapi.DSP96_fclr -DSP96_fcmp = _idaapi.DSP96_fcmp -DSP96_fcmpg = _idaapi.DSP96_fcmpg -DSP96_fcmpm = _idaapi.DSP96_fcmpm -DSP96_fcopys = _idaapi.DSP96_fcopys -DSP96_fdebugcc = _idaapi.DSP96_fdebugcc -DSP96_fgetman = _idaapi.DSP96_fgetman -DSP96_fint = _idaapi.DSP96_fint -DSP96_fjcc = _idaapi.DSP96_fjcc -DSP96_fjccd = _idaapi.DSP96_fjccd -DSP96_fjscc = _idaapi.DSP96_fjscc -DSP96_fjsccd = _idaapi.DSP96_fjsccd -DSP96_float = _idaapi.DSP96_float -DSP96_floatu = _idaapi.DSP96_floatu -DSP96_floor = _idaapi.DSP96_floor -DSP96_fmove = _idaapi.DSP96_fmove -DSP96_fmpyfadd = _idaapi.DSP96_fmpyfadd -DSP96_fmpyfaddsub = _idaapi.DSP96_fmpyfaddsub -DSP96_fmpyfsub = _idaapi.DSP96_fmpyfsub -DSP96_fmpy = _idaapi.DSP96_fmpy -DSP96_fneg = _idaapi.DSP96_fneg -DSP96_fscale = _idaapi.DSP96_fscale -DSP96_fseedd = _idaapi.DSP96_fseedd -DSP96_fseedr = _idaapi.DSP96_fseedr -DSP96_fsub = _idaapi.DSP96_fsub -DSP96_ftfr = _idaapi.DSP96_ftfr -DSP96_ftrapcc = _idaapi.DSP96_ftrapcc -DSP96_ftst = _idaapi.DSP96_ftst -DSP96_getexp = _idaapi.DSP96_getexp -DSP96_illegal = _idaapi.DSP96_illegal -DSP96_inc = _idaapi.DSP96_inc -DSP96_int = _idaapi.DSP96_int -DSP96_intrz = _idaapi.DSP96_intrz -DSP96_intu = _idaapi.DSP96_intu -DSP96_inturz = _idaapi.DSP96_inturz -DSP96_jcc = _idaapi.DSP96_jcc -DSP96_jccd = _idaapi.DSP96_jccd -DSP96_jclr = _idaapi.DSP96_jclr -DSP96_join = _idaapi.DSP96_join -DSP96_joinb = _idaapi.DSP96_joinb -DSP96_jscc = _idaapi.DSP96_jscc -DSP96_jsccd = _idaapi.DSP96_jsccd -DSP96_jsclr = _idaapi.DSP96_jsclr -DSP96_jset = _idaapi.DSP96_jset -DSP96_jsset = _idaapi.DSP96_jsset -DSP96_lea = _idaapi.DSP96_lea -DSP96_lra = _idaapi.DSP96_lra -DSP96_lsl = _idaapi.DSP96_lsl -DSP96_lsr = _idaapi.DSP96_lsr -DSP96_move = _idaapi.DSP96_move -DSP96_movec = _idaapi.DSP96_movec -DSP96_movei = _idaapi.DSP96_movei -DSP96_movem = _idaapi.DSP96_movem -DSP96_movep = _idaapi.DSP96_movep -DSP96_moves = _idaapi.DSP96_moves -DSP96_moveta = _idaapi.DSP96_moveta -DSP96_mpys = _idaapi.DSP96_mpys -DSP96_mpyu = _idaapi.DSP96_mpyu -DSP96_neg = _idaapi.DSP96_neg -DSP96_negc = _idaapi.DSP96_negc -DSP96_nop = _idaapi.DSP96_nop -DSP96_not = _idaapi.DSP96_not -DSP96_or = _idaapi.DSP96_or -DSP96_orc = _idaapi.DSP96_orc -DSP96_ori = _idaapi.DSP96_ori -DSP96_rep = _idaapi.DSP96_rep -DSP96_reset = _idaapi.DSP96_reset -DSP96_rol = _idaapi.DSP96_rol -DSP96_ror = _idaapi.DSP96_ror -DSP96_rti = _idaapi.DSP96_rti -DSP96_rtr = _idaapi.DSP96_rtr -DSP96_rts = _idaapi.DSP96_rts -DSP96_setw = _idaapi.DSP96_setw -DSP96_split = _idaapi.DSP96_split -DSP96_splitb = _idaapi.DSP96_splitb -DSP96_stop = _idaapi.DSP96_stop -DSP96_sub = _idaapi.DSP96_sub -DSP96_subc = _idaapi.DSP96_subc -DSP96_tfr = _idaapi.DSP96_tfr -DSP96_trapcc = _idaapi.DSP96_trapcc -DSP96_tst = _idaapi.DSP96_tst -DSP96_wait = _idaapi.DSP96_wait -DSP96_last = _idaapi.DSP96_last -PM96_NoMove = _idaapi.PM96_NoMove -PM96_R2R = _idaapi.PM96_R2R -PM96_Update = _idaapi.PM96_Update -PM96_XYMem = _idaapi.PM96_XYMem -PM96_XYmemR = _idaapi.PM96_XYmemR -PM96_Long = _idaapi.PM96_Long -PM96_XY = _idaapi.PM96_XY -PM96_IFcc = _idaapi.PM96_IFcc C166_null = _idaapi.C166_null C166_add = _idaapi.C166_add C166_addb = _idaapi.C166_addb @@ -18592,912 +19906,6 @@ PPC_lmvdsrrw = _idaapi.PPC_lmvdsrrw PPC_stmvdsrrw = _idaapi.PPC_stmvdsrrw PPC_lmvmcsrrw = _idaapi.PPC_lmvmcsrrw PPC_stmvmcsrrw = _idaapi.PPC_stmvmcsrrw -PPC_evdotpwcssi = _idaapi.PPC_evdotpwcssi -PPC_evdotpwcsmi = _idaapi.PPC_evdotpwcsmi -PPC_evdotpwcssfr = _idaapi.PPC_evdotpwcssfr -PPC_evdotpwcssf = _idaapi.PPC_evdotpwcssf -PPC_evdotpwgasmf = _idaapi.PPC_evdotpwgasmf -PPC_evdotpwxgasmf = _idaapi.PPC_evdotpwxgasmf -PPC_evdotpwgasmfr = _idaapi.PPC_evdotpwgasmfr -PPC_evdotpwxgasmfr = _idaapi.PPC_evdotpwxgasmfr -PPC_evdotpwgssmf = _idaapi.PPC_evdotpwgssmf -PPC_evdotpwxgssmf = _idaapi.PPC_evdotpwxgssmf -PPC_evdotpwgssmfr = _idaapi.PPC_evdotpwgssmfr -PPC_evdotpwxgssmfr = _idaapi.PPC_evdotpwxgssmfr -PPC_evdotpwcssiaaw3 = _idaapi.PPC_evdotpwcssiaaw3 -PPC_evdotpwcsmiaaw3 = _idaapi.PPC_evdotpwcsmiaaw3 -PPC_evdotpwcssfraaw3 = _idaapi.PPC_evdotpwcssfraaw3 -PPC_evdotpwcssfaaw3 = _idaapi.PPC_evdotpwcssfaaw3 -PPC_evdotpwgasmfaa3 = _idaapi.PPC_evdotpwgasmfaa3 -PPC_evdotpwxgasmfaa3 = _idaapi.PPC_evdotpwxgasmfaa3 -PPC_evdotpwgasmfraa3 = _idaapi.PPC_evdotpwgasmfraa3 -PPC_evdotpwxgasmfraa3 = _idaapi.PPC_evdotpwxgasmfraa3 -PPC_evdotpwgssmfaa3 = _idaapi.PPC_evdotpwgssmfaa3 -PPC_evdotpwxgssmfaa3 = _idaapi.PPC_evdotpwxgssmfaa3 -PPC_evdotpwgssmfraa3 = _idaapi.PPC_evdotpwgssmfraa3 -PPC_evdotpwxgssmfraa3 = _idaapi.PPC_evdotpwxgssmfraa3 -PPC_evdotpwcssia = _idaapi.PPC_evdotpwcssia -PPC_evdotpwcsmia = _idaapi.PPC_evdotpwcsmia -PPC_evdotpwcssfra = _idaapi.PPC_evdotpwcssfra -PPC_evdotpwcssfa = _idaapi.PPC_evdotpwcssfa -PPC_evdotpwgasmfa = _idaapi.PPC_evdotpwgasmfa -PPC_evdotpwxgasmfa = _idaapi.PPC_evdotpwxgasmfa -PPC_evdotpwgasmfra = _idaapi.PPC_evdotpwgasmfra -PPC_evdotpwxgasmfra = _idaapi.PPC_evdotpwxgasmfra -PPC_evdotpwgssmfa = _idaapi.PPC_evdotpwgssmfa -PPC_evdotpwxgssmfa = _idaapi.PPC_evdotpwxgssmfa -PPC_evdotpwgssmfra = _idaapi.PPC_evdotpwgssmfra -PPC_evdotpwxgssmfra = _idaapi.PPC_evdotpwxgssmfra -PPC_evdotpwcssiaaw = _idaapi.PPC_evdotpwcssiaaw -PPC_evdotpwcsmiaaw = _idaapi.PPC_evdotpwcsmiaaw -PPC_evdotpwcssfraaw = _idaapi.PPC_evdotpwcssfraaw -PPC_evdotpwcssfaaw = _idaapi.PPC_evdotpwcssfaaw -PPC_evdotpwgasmfaa = _idaapi.PPC_evdotpwgasmfaa -PPC_evdotpwxgasmfaa = _idaapi.PPC_evdotpwxgasmfaa -PPC_evdotpwgasmfraa = _idaapi.PPC_evdotpwgasmfraa -PPC_evdotpwxgasmfraa = _idaapi.PPC_evdotpwxgasmfraa -PPC_evdotpwgssmfaa = _idaapi.PPC_evdotpwgssmfaa -PPC_evdotpwxgssmfaa = _idaapi.PPC_evdotpwxgssmfaa -PPC_evdotpwgssmfraa = _idaapi.PPC_evdotpwgssmfraa -PPC_evdotpwxgssmfraa = _idaapi.PPC_evdotpwxgssmfraa -PPC_evdotphihcssi = _idaapi.PPC_evdotphihcssi -PPC_evdotplohcssi = _idaapi.PPC_evdotplohcssi -PPC_evdotphihcssf = _idaapi.PPC_evdotphihcssf -PPC_evdotplohcssf = _idaapi.PPC_evdotplohcssf -PPC_evdotphihcsmi = _idaapi.PPC_evdotphihcsmi -PPC_evdotplohcsmi = _idaapi.PPC_evdotplohcsmi -PPC_evdotphihcssfr = _idaapi.PPC_evdotphihcssfr -PPC_evdotplohcssfr = _idaapi.PPC_evdotplohcssfr -PPC_evdotphihcssiaaw3 = _idaapi.PPC_evdotphihcssiaaw3 -PPC_evdotplohcssiaaw3 = _idaapi.PPC_evdotplohcssiaaw3 -PPC_evdotphihcssfaaw3 = _idaapi.PPC_evdotphihcssfaaw3 -PPC_evdotplohcssfaaw3 = _idaapi.PPC_evdotplohcssfaaw3 -PPC_evdotphihcsmiaaw3 = _idaapi.PPC_evdotphihcsmiaaw3 -PPC_evdotplohcsmiaaw3 = _idaapi.PPC_evdotplohcsmiaaw3 -PPC_evdotphihcssfraaw3 = _idaapi.PPC_evdotphihcssfraaw3 -PPC_evdotplohcssfraaw3 = _idaapi.PPC_evdotplohcssfraaw3 -PPC_evdotphihcssia = _idaapi.PPC_evdotphihcssia -PPC_evdotplohcssia = _idaapi.PPC_evdotplohcssia -PPC_evdotphihcssfa = _idaapi.PPC_evdotphihcssfa -PPC_evdotplohcssfa = _idaapi.PPC_evdotplohcssfa -PPC_evdotphihcsmia = _idaapi.PPC_evdotphihcsmia -PPC_evdotplohcsmia = _idaapi.PPC_evdotplohcsmia -PPC_evdotphihcssfra = _idaapi.PPC_evdotphihcssfra -PPC_evdotplohcssfra = _idaapi.PPC_evdotplohcssfra -PPC_evdotphihcssiaaw = _idaapi.PPC_evdotphihcssiaaw -PPC_evdotplohcssiaaw = _idaapi.PPC_evdotplohcssiaaw -PPC_evdotphihcssfaaw = _idaapi.PPC_evdotphihcssfaaw -PPC_evdotplohcssfaaw = _idaapi.PPC_evdotplohcssfaaw -PPC_evdotphihcsmiaaw = _idaapi.PPC_evdotphihcsmiaaw -PPC_evdotplohcsmiaaw = _idaapi.PPC_evdotplohcsmiaaw -PPC_evdotphihcssfraaw = _idaapi.PPC_evdotphihcssfraaw -PPC_evdotplohcssfraaw = _idaapi.PPC_evdotplohcssfraaw -PPC_evdotphausi = _idaapi.PPC_evdotphausi -PPC_evdotphassi = _idaapi.PPC_evdotphassi -PPC_evdotphasusi = _idaapi.PPC_evdotphasusi -PPC_evdotphassf = _idaapi.PPC_evdotphassf -PPC_evdotphsssf = _idaapi.PPC_evdotphsssf -PPC_evdotphaumi = _idaapi.PPC_evdotphaumi -PPC_evdotphasmi = _idaapi.PPC_evdotphasmi -PPC_evdotphasumi = _idaapi.PPC_evdotphasumi -PPC_evdotphassfr = _idaapi.PPC_evdotphassfr -PPC_evdotphssmi = _idaapi.PPC_evdotphssmi -PPC_evdotphsssfr = _idaapi.PPC_evdotphsssfr -PPC_evdotphausiaaw3 = _idaapi.PPC_evdotphausiaaw3 -PPC_evdotphassiaaw3 = _idaapi.PPC_evdotphassiaaw3 -PPC_evdotphasusiaaw3 = _idaapi.PPC_evdotphasusiaaw3 -PPC_evdotphassfaaw3 = _idaapi.PPC_evdotphassfaaw3 -PPC_evdotphsssiaaw3 = _idaapi.PPC_evdotphsssiaaw3 -PPC_evdotphsssfaaw3 = _idaapi.PPC_evdotphsssfaaw3 -PPC_evdotphaumiaaw3 = _idaapi.PPC_evdotphaumiaaw3 -PPC_evdotphasmiaaw3 = _idaapi.PPC_evdotphasmiaaw3 -PPC_evdotphasumiaaw3 = _idaapi.PPC_evdotphasumiaaw3 -PPC_evdotphassfraaw3 = _idaapi.PPC_evdotphassfraaw3 -PPC_evdotphssmiaaw3 = _idaapi.PPC_evdotphssmiaaw3 -PPC_evdotphsssfraaw3 = _idaapi.PPC_evdotphsssfraaw3 -PPC_evdotphausia = _idaapi.PPC_evdotphausia -PPC_evdotphassia = _idaapi.PPC_evdotphassia -PPC_evdotphasusia = _idaapi.PPC_evdotphasusia -PPC_evdotphassfa = _idaapi.PPC_evdotphassfa -PPC_evdotphsssfa = _idaapi.PPC_evdotphsssfa -PPC_evdotphaumia = _idaapi.PPC_evdotphaumia -PPC_evdotphasmia = _idaapi.PPC_evdotphasmia -PPC_evdotphasumia = _idaapi.PPC_evdotphasumia -PPC_evdotphassfra = _idaapi.PPC_evdotphassfra -PPC_evdotphssmia = _idaapi.PPC_evdotphssmia -PPC_evdotphsssfra = _idaapi.PPC_evdotphsssfra -PPC_evdotphausiaaw = _idaapi.PPC_evdotphausiaaw -PPC_evdotphassiaaw = _idaapi.PPC_evdotphassiaaw -PPC_evdotphasusiaaw = _idaapi.PPC_evdotphasusiaaw -PPC_evdotphassfaaw = _idaapi.PPC_evdotphassfaaw -PPC_evdotphsssiaaw = _idaapi.PPC_evdotphsssiaaw -PPC_evdotphsssfaaw = _idaapi.PPC_evdotphsssfaaw -PPC_evdotphaumiaaw = _idaapi.PPC_evdotphaumiaaw -PPC_evdotphasmiaaw = _idaapi.PPC_evdotphasmiaaw -PPC_evdotphasumiaaw = _idaapi.PPC_evdotphasumiaaw -PPC_evdotphassfraaw = _idaapi.PPC_evdotphassfraaw -PPC_evdotphssmiaaw = _idaapi.PPC_evdotphssmiaaw -PPC_evdotphsssfraaw = _idaapi.PPC_evdotphsssfraaw -PPC_evdotp4hgaumi = _idaapi.PPC_evdotp4hgaumi -PPC_evdotp4hgasmi = _idaapi.PPC_evdotp4hgasmi -PPC_evdotp4hgasumi = _idaapi.PPC_evdotp4hgasumi -PPC_evdotp4hgasmf = _idaapi.PPC_evdotp4hgasmf -PPC_evdotp4hgssmi = _idaapi.PPC_evdotp4hgssmi -PPC_evdotp4hgssmf = _idaapi.PPC_evdotp4hgssmf -PPC_evdotp4hxgasmi = _idaapi.PPC_evdotp4hxgasmi -PPC_evdotp4hxgasmf = _idaapi.PPC_evdotp4hxgasmf -PPC_evdotpbaumi = _idaapi.PPC_evdotpbaumi -PPC_evdotpbasmi = _idaapi.PPC_evdotpbasmi -PPC_evdotpbasumi = _idaapi.PPC_evdotpbasumi -PPC_evdotp4hxgssmi = _idaapi.PPC_evdotp4hxgssmi -PPC_evdotp4hxgssmf = _idaapi.PPC_evdotp4hxgssmf -PPC_evdotp4hgaumiaa3 = _idaapi.PPC_evdotp4hgaumiaa3 -PPC_evdotp4hgasmiaa3 = _idaapi.PPC_evdotp4hgasmiaa3 -PPC_evdotp4hgasumiaa3 = _idaapi.PPC_evdotp4hgasumiaa3 -PPC_evdotp4hgasmfaa3 = _idaapi.PPC_evdotp4hgasmfaa3 -PPC_evdotp4hgssmiaa3 = _idaapi.PPC_evdotp4hgssmiaa3 -PPC_evdotp4hgssmfaa3 = _idaapi.PPC_evdotp4hgssmfaa3 -PPC_evdotp4hxgasmiaa3 = _idaapi.PPC_evdotp4hxgasmiaa3 -PPC_evdotp4hxgasmfaa3 = _idaapi.PPC_evdotp4hxgasmfaa3 -PPC_evdotpbaumiaaw3 = _idaapi.PPC_evdotpbaumiaaw3 -PPC_evdotpbasmiaaw3 = _idaapi.PPC_evdotpbasmiaaw3 -PPC_evdotpbasumiaaw3 = _idaapi.PPC_evdotpbasumiaaw3 -PPC_evdotp4hxgssmiaa3 = _idaapi.PPC_evdotp4hxgssmiaa3 -PPC_evdotp4hxgssmfaa3 = _idaapi.PPC_evdotp4hxgssmfaa3 -PPC_evdotp4hgaumia = _idaapi.PPC_evdotp4hgaumia -PPC_evdotp4hgasmia = _idaapi.PPC_evdotp4hgasmia -PPC_evdotp4hgasumia = _idaapi.PPC_evdotp4hgasumia -PPC_evdotp4hgasmfa = _idaapi.PPC_evdotp4hgasmfa -PPC_evdotp4hgssmia = _idaapi.PPC_evdotp4hgssmia -PPC_evdotp4hgssmfa = _idaapi.PPC_evdotp4hgssmfa -PPC_evdotp4hxgasmia = _idaapi.PPC_evdotp4hxgasmia -PPC_evdotp4hxgasmfa = _idaapi.PPC_evdotp4hxgasmfa -PPC_evdotpbaumia = _idaapi.PPC_evdotpbaumia -PPC_evdotpbasmia = _idaapi.PPC_evdotpbasmia -PPC_evdotpbasumia = _idaapi.PPC_evdotpbasumia -PPC_evdotp4hxgssmia = _idaapi.PPC_evdotp4hxgssmia -PPC_evdotp4hxgssmfa = _idaapi.PPC_evdotp4hxgssmfa -PPC_evdotp4hgaumiaa = _idaapi.PPC_evdotp4hgaumiaa -PPC_evdotp4hgasmiaa = _idaapi.PPC_evdotp4hgasmiaa -PPC_evdotp4hgasumiaa = _idaapi.PPC_evdotp4hgasumiaa -PPC_evdotp4hgasmfaa = _idaapi.PPC_evdotp4hgasmfaa -PPC_evdotp4hgssmiaa = _idaapi.PPC_evdotp4hgssmiaa -PPC_evdotp4hgssmfaa = _idaapi.PPC_evdotp4hgssmfaa -PPC_evdotp4hxgasmiaa = _idaapi.PPC_evdotp4hxgasmiaa -PPC_evdotp4hxgasmfaa = _idaapi.PPC_evdotp4hxgasmfaa -PPC_evdotpbaumiaaw = _idaapi.PPC_evdotpbaumiaaw -PPC_evdotpbasmiaaw = _idaapi.PPC_evdotpbasmiaaw -PPC_evdotpbasumiaaw = _idaapi.PPC_evdotpbasumiaaw -PPC_evdotp4hxgssmiaa = _idaapi.PPC_evdotp4hxgssmiaa -PPC_evdotp4hxgssmfaa = _idaapi.PPC_evdotp4hxgssmfaa -PPC_evdotpwausi = _idaapi.PPC_evdotpwausi -PPC_evdotpwassi = _idaapi.PPC_evdotpwassi -PPC_evdotpwasusi = _idaapi.PPC_evdotpwasusi -PPC_evdotpwaumi = _idaapi.PPC_evdotpwaumi -PPC_evdotpwasmi = _idaapi.PPC_evdotpwasmi -PPC_evdotpwasumi = _idaapi.PPC_evdotpwasumi -PPC_evdotpwssmi = _idaapi.PPC_evdotpwssmi -PPC_evdotpwausiaa3 = _idaapi.PPC_evdotpwausiaa3 -PPC_evdotpwassiaa3 = _idaapi.PPC_evdotpwassiaa3 -PPC_evdotpwasusiaa3 = _idaapi.PPC_evdotpwasusiaa3 -PPC_evdotpwsssiaa3 = _idaapi.PPC_evdotpwsssiaa3 -PPC_evdotpwaumiaa3 = _idaapi.PPC_evdotpwaumiaa3 -PPC_evdotpwasmiaa3 = _idaapi.PPC_evdotpwasmiaa3 -PPC_evdotpwasumiaa3 = _idaapi.PPC_evdotpwasumiaa3 -PPC_evdotpwssmiaa3 = _idaapi.PPC_evdotpwssmiaa3 -PPC_evdotpwausia = _idaapi.PPC_evdotpwausia -PPC_evdotpwassia = _idaapi.PPC_evdotpwassia -PPC_evdotpwasusia = _idaapi.PPC_evdotpwasusia -PPC_evdotpwaumia = _idaapi.PPC_evdotpwaumia -PPC_evdotpwasmia = _idaapi.PPC_evdotpwasmia -PPC_evdotpwasumia = _idaapi.PPC_evdotpwasumia -PPC_evdotpwssmia = _idaapi.PPC_evdotpwssmia -PPC_evdotpwausiaa = _idaapi.PPC_evdotpwausiaa -PPC_evdotpwassiaa = _idaapi.PPC_evdotpwassiaa -PPC_evdotpwasusiaa = _idaapi.PPC_evdotpwasusiaa -PPC_evdotpwsssiaa = _idaapi.PPC_evdotpwsssiaa -PPC_evdotpwaumiaa = _idaapi.PPC_evdotpwaumiaa -PPC_evdotpwasmiaa = _idaapi.PPC_evdotpwasmiaa -PPC_evdotpwasumiaa = _idaapi.PPC_evdotpwasumiaa -PPC_evdotpwssmiaa = _idaapi.PPC_evdotpwssmiaa -PPC_evaddih = _idaapi.PPC_evaddih -PPC_evaddib = _idaapi.PPC_evaddib -PPC_evsubifh = _idaapi.PPC_evsubifh -PPC_evsubifb = _idaapi.PPC_evsubifb -PPC_evabsb = _idaapi.PPC_evabsb -PPC_evabsh = _idaapi.PPC_evabsh -PPC_evabsd = _idaapi.PPC_evabsd -PPC_evabss = _idaapi.PPC_evabss -PPC_evabsbs = _idaapi.PPC_evabsbs -PPC_evabshs = _idaapi.PPC_evabshs -PPC_evabsds = _idaapi.PPC_evabsds -PPC_evnegwo = _idaapi.PPC_evnegwo -PPC_evnegb = _idaapi.PPC_evnegb -PPC_evnegbo = _idaapi.PPC_evnegbo -PPC_evnegh = _idaapi.PPC_evnegh -PPC_evnegho = _idaapi.PPC_evnegho -PPC_evnegd = _idaapi.PPC_evnegd -PPC_evnegs = _idaapi.PPC_evnegs -PPC_evnegwos = _idaapi.PPC_evnegwos -PPC_evnegbs = _idaapi.PPC_evnegbs -PPC_evnegbos = _idaapi.PPC_evnegbos -PPC_evneghs = _idaapi.PPC_evneghs -PPC_evneghos = _idaapi.PPC_evneghos -PPC_evnegds = _idaapi.PPC_evnegds -PPC_evextzb = _idaapi.PPC_evextzb -PPC_evextsbh = _idaapi.PPC_evextsbh -PPC_evextsw = _idaapi.PPC_evextsw -PPC_evrndhb = _idaapi.PPC_evrndhb -PPC_evrnddw = _idaapi.PPC_evrnddw -PPC_evrndwhus = _idaapi.PPC_evrndwhus -PPC_evrndwhss = _idaapi.PPC_evrndwhss -PPC_evrndhbus = _idaapi.PPC_evrndhbus -PPC_evrndhbss = _idaapi.PPC_evrndhbss -PPC_evrnddwus = _idaapi.PPC_evrnddwus -PPC_evrnddwss = _idaapi.PPC_evrnddwss -PPC_evrndwnh = _idaapi.PPC_evrndwnh -PPC_evrndhnb = _idaapi.PPC_evrndhnb -PPC_evrnddnw = _idaapi.PPC_evrnddnw -PPC_evrndwnhus = _idaapi.PPC_evrndwnhus -PPC_evrndwnhss = _idaapi.PPC_evrndwnhss -PPC_evrndhnbus = _idaapi.PPC_evrndhnbus -PPC_evrndhnbss = _idaapi.PPC_evrndhnbss -PPC_evrnddnwus = _idaapi.PPC_evrnddnwus -PPC_evrnddnwss = _idaapi.PPC_evrnddnwss -PPC_evcntlzh = _idaapi.PPC_evcntlzh -PPC_evcntlsh = _idaapi.PPC_evcntlsh -PPC_evpopcntb = _idaapi.PPC_evpopcntb -PPC_circinc = _idaapi.PPC_circinc -PPC_evunpkhibui = _idaapi.PPC_evunpkhibui -PPC_evunpkhibsi = _idaapi.PPC_evunpkhibsi -PPC_evunpkhihui = _idaapi.PPC_evunpkhihui -PPC_evunpkhihsi = _idaapi.PPC_evunpkhihsi -PPC_evunpklobui = _idaapi.PPC_evunpklobui -PPC_evunpklobsi = _idaapi.PPC_evunpklobsi -PPC_evunpklohui = _idaapi.PPC_evunpklohui -PPC_evunpklohsi = _idaapi.PPC_evunpklohsi -PPC_evunpklohf = _idaapi.PPC_evunpklohf -PPC_evunpkhihf = _idaapi.PPC_evunpkhihf -PPC_evunpklowgsf = _idaapi.PPC_evunpklowgsf -PPC_evunpkhiwgsf = _idaapi.PPC_evunpkhiwgsf -PPC_evsatsduw = _idaapi.PPC_evsatsduw -PPC_evsatsdsw = _idaapi.PPC_evsatsdsw -PPC_evsatshub = _idaapi.PPC_evsatshub -PPC_evsatshsb = _idaapi.PPC_evsatshsb -PPC_evsatuwuh = _idaapi.PPC_evsatuwuh -PPC_evsatswsh = _idaapi.PPC_evsatswsh -PPC_evsatswuh = _idaapi.PPC_evsatswuh -PPC_evsatuhub = _idaapi.PPC_evsatuhub -PPC_evsatuduw = _idaapi.PPC_evsatuduw -PPC_evsatuwsw = _idaapi.PPC_evsatuwsw -PPC_evsatshuh = _idaapi.PPC_evsatshuh -PPC_evsatuhsh = _idaapi.PPC_evsatuhsh -PPC_evsatswuw = _idaapi.PPC_evsatswuw -PPC_evsatswgsdf = _idaapi.PPC_evsatswgsdf -PPC_evsatsbub = _idaapi.PPC_evsatsbub -PPC_evsatubsb = _idaapi.PPC_evsatubsb -PPC_evmaxhpuw = _idaapi.PPC_evmaxhpuw -PPC_evmaxhpsw = _idaapi.PPC_evmaxhpsw -PPC_evmaxbpuh = _idaapi.PPC_evmaxbpuh -PPC_evmaxbpsh = _idaapi.PPC_evmaxbpsh -PPC_evmaxwpud = _idaapi.PPC_evmaxwpud -PPC_evmaxwpsd = _idaapi.PPC_evmaxwpsd -PPC_evminhpuw = _idaapi.PPC_evminhpuw -PPC_evminhpsw = _idaapi.PPC_evminhpsw -PPC_evminbpuh = _idaapi.PPC_evminbpuh -PPC_evminbpsh = _idaapi.PPC_evminbpsh -PPC_evminwpud = _idaapi.PPC_evminwpud -PPC_evminwpsd = _idaapi.PPC_evminwpsd -PPC_evmaxmagws = _idaapi.PPC_evmaxmagws -PPC_evsl = _idaapi.PPC_evsl -PPC_evsli = _idaapi.PPC_evsli -PPC_evsplatie = _idaapi.PPC_evsplatie -PPC_evsplatib = _idaapi.PPC_evsplatib -PPC_evsplatibe = _idaapi.PPC_evsplatibe -PPC_evsplatih = _idaapi.PPC_evsplatih -PPC_evsplatihe = _idaapi.PPC_evsplatihe -PPC_evsplatid = _idaapi.PPC_evsplatid -PPC_evsplatia = _idaapi.PPC_evsplatia -PPC_evsplatiea = _idaapi.PPC_evsplatiea -PPC_evsplatiba = _idaapi.PPC_evsplatiba -PPC_evsplatibea = _idaapi.PPC_evsplatibea -PPC_evsplatiha = _idaapi.PPC_evsplatiha -PPC_evsplatihea = _idaapi.PPC_evsplatihea -PPC_evsplatida = _idaapi.PPC_evsplatida -PPC_evsplatfio = _idaapi.PPC_evsplatfio -PPC_evsplatfib = _idaapi.PPC_evsplatfib -PPC_evsplatfibo = _idaapi.PPC_evsplatfibo -PPC_evsplatfih = _idaapi.PPC_evsplatfih -PPC_evsplatfiho = _idaapi.PPC_evsplatfiho -PPC_evsplatfid = _idaapi.PPC_evsplatfid -PPC_evsplatfia = _idaapi.PPC_evsplatfia -PPC_evsplatfioa = _idaapi.PPC_evsplatfioa -PPC_evsplatfiba = _idaapi.PPC_evsplatfiba -PPC_evsplatfiboa = _idaapi.PPC_evsplatfiboa -PPC_evsplatfiha = _idaapi.PPC_evsplatfiha -PPC_evsplatfihoa = _idaapi.PPC_evsplatfihoa -PPC_evsplatfida = _idaapi.PPC_evsplatfida -PPC_evcmpgtdu = _idaapi.PPC_evcmpgtdu -PPC_evcmpgtds = _idaapi.PPC_evcmpgtds -PPC_evcmpltdu = _idaapi.PPC_evcmpltdu -PPC_evcmpltds = _idaapi.PPC_evcmpltds -PPC_evcmpeqd = _idaapi.PPC_evcmpeqd -PPC_evswapbhilo = _idaapi.PPC_evswapbhilo -PPC_evswapblohi = _idaapi.PPC_evswapblohi -PPC_evswaphhilo = _idaapi.PPC_evswaphhilo -PPC_evswaphlohi = _idaapi.PPC_evswaphlohi -PPC_evswaphe = _idaapi.PPC_evswaphe -PPC_evswaphhi = _idaapi.PPC_evswaphhi -PPC_evswaphlo = _idaapi.PPC_evswaphlo -PPC_evswapho = _idaapi.PPC_evswapho -PPC_evinsb = _idaapi.PPC_evinsb -PPC_evxtrb = _idaapi.PPC_evxtrb -PPC_evsplath = _idaapi.PPC_evsplath -PPC_evsplatb = _idaapi.PPC_evsplatb -PPC_evinsh = _idaapi.PPC_evinsh -PPC_evclrbe = _idaapi.PPC_evclrbe -PPC_evclrbo = _idaapi.PPC_evclrbo -PPC_evxtrh = _idaapi.PPC_evxtrh -PPC_evclrh = _idaapi.PPC_evclrh -PPC_evselbitm0 = _idaapi.PPC_evselbitm0 -PPC_evselbitm1 = _idaapi.PPC_evselbitm1 -PPC_evselbit = _idaapi.PPC_evselbit -PPC_evperm = _idaapi.PPC_evperm -PPC_evperm2 = _idaapi.PPC_evperm2 -PPC_evperm3 = _idaapi.PPC_evperm3 -PPC_evxtrd = _idaapi.PPC_evxtrd -PPC_evsrbu = _idaapi.PPC_evsrbu -PPC_evsrbs = _idaapi.PPC_evsrbs -PPC_evsrbiu = _idaapi.PPC_evsrbiu -PPC_evsrbis = _idaapi.PPC_evsrbis -PPC_evslb = _idaapi.PPC_evslb -PPC_evrlb = _idaapi.PPC_evrlb -PPC_evslbi = _idaapi.PPC_evslbi -PPC_evrlbi = _idaapi.PPC_evrlbi -PPC_evsrhu = _idaapi.PPC_evsrhu -PPC_evsrhs = _idaapi.PPC_evsrhs -PPC_evsrhiu = _idaapi.PPC_evsrhiu -PPC_evsrhis = _idaapi.PPC_evsrhis -PPC_evslh = _idaapi.PPC_evslh -PPC_evrlh = _idaapi.PPC_evrlh -PPC_evslhi = _idaapi.PPC_evslhi -PPC_evrlhi = _idaapi.PPC_evrlhi -PPC_evsru = _idaapi.PPC_evsru -PPC_evsrs = _idaapi.PPC_evsrs -PPC_evsriu = _idaapi.PPC_evsriu -PPC_evsris = _idaapi.PPC_evsris -PPC_evlvsl = _idaapi.PPC_evlvsl -PPC_evlvsr = _idaapi.PPC_evlvsr -PPC_evsroiu = _idaapi.PPC_evsroiu -PPC_evsloi = _idaapi.PPC_evsloi -PPC_evsrois = _idaapi.PPC_evsrois -PPC_evldbx = _idaapi.PPC_evldbx -PPC_evldb = _idaapi.PPC_evldb -PPC_evlhhsplathx = _idaapi.PPC_evlhhsplathx -PPC_evlhhsplath = _idaapi.PPC_evlhhsplath -PPC_evlwbsplatwx = _idaapi.PPC_evlwbsplatwx -PPC_evlwbsplatw = _idaapi.PPC_evlwbsplatw -PPC_evlwhsplatwx = _idaapi.PPC_evlwhsplatwx -PPC_evlwhsplatw = _idaapi.PPC_evlwhsplatw -PPC_evlbbsplatbx = _idaapi.PPC_evlbbsplatbx -PPC_evlbbsplatb = _idaapi.PPC_evlbbsplatb -PPC_evstdbx = _idaapi.PPC_evstdbx -PPC_evstdb = _idaapi.PPC_evstdb -PPC_evlwbex = _idaapi.PPC_evlwbex -PPC_evlwbe = _idaapi.PPC_evlwbe -PPC_evlwboux = _idaapi.PPC_evlwboux -PPC_evlwbou = _idaapi.PPC_evlwbou -PPC_evlwbosx = _idaapi.PPC_evlwbosx -PPC_evlwbos = _idaapi.PPC_evlwbos -PPC_evstwbex = _idaapi.PPC_evstwbex -PPC_evstwbe = _idaapi.PPC_evstwbe -PPC_evstwbox = _idaapi.PPC_evstwbox -PPC_evstwbo = _idaapi.PPC_evstwbo -PPC_evstwbx = _idaapi.PPC_evstwbx -PPC_evstwb = _idaapi.PPC_evstwb -PPC_evsthbx = _idaapi.PPC_evsthbx -PPC_evsthb = _idaapi.PPC_evsthb -PPC_evlddmx = _idaapi.PPC_evlddmx -PPC_evlddu = _idaapi.PPC_evlddu -PPC_evldwmx = _idaapi.PPC_evldwmx -PPC_evldwu = _idaapi.PPC_evldwu -PPC_evldhmx = _idaapi.PPC_evldhmx -PPC_evldhu = _idaapi.PPC_evldhu -PPC_evldbmx = _idaapi.PPC_evldbmx -PPC_evldbu = _idaapi.PPC_evldbu -PPC_evlhhesplatmx = _idaapi.PPC_evlhhesplatmx -PPC_evlhhesplatu = _idaapi.PPC_evlhhesplatu -PPC_evlhhsplathmx = _idaapi.PPC_evlhhsplathmx -PPC_evlhhsplathu = _idaapi.PPC_evlhhsplathu -PPC_evlhhousplatmx = _idaapi.PPC_evlhhousplatmx -PPC_evlhhousplatu = _idaapi.PPC_evlhhousplatu -PPC_evlhhossplatmx = _idaapi.PPC_evlhhossplatmx -PPC_evlhhossplatu = _idaapi.PPC_evlhhossplatu -PPC_evlwhemx = _idaapi.PPC_evlwhemx -PPC_evlwheu = _idaapi.PPC_evlwheu -PPC_evlwbsplatwmx = _idaapi.PPC_evlwbsplatwmx -PPC_evlwbsplatwu = _idaapi.PPC_evlwbsplatwu -PPC_evlwhoumx = _idaapi.PPC_evlwhoumx -PPC_evlwhouu = _idaapi.PPC_evlwhouu -PPC_evlwhosmx = _idaapi.PPC_evlwhosmx -PPC_evlwhosu = _idaapi.PPC_evlwhosu -PPC_evlwwsplatmx = _idaapi.PPC_evlwwsplatmx -PPC_evlwwsplatu = _idaapi.PPC_evlwwsplatu -PPC_evlwhsplatwmx = _idaapi.PPC_evlwhsplatwmx -PPC_evlwhsplatwu = _idaapi.PPC_evlwhsplatwu -PPC_evlwhsplatmx = _idaapi.PPC_evlwhsplatmx -PPC_evlwhsplatu = _idaapi.PPC_evlwhsplatu -PPC_evlbbsplatbmx = _idaapi.PPC_evlbbsplatbmx -PPC_evlbbsplatbu = _idaapi.PPC_evlbbsplatbu -PPC_evstddmx = _idaapi.PPC_evstddmx -PPC_evstddu = _idaapi.PPC_evstddu -PPC_evstdwmx = _idaapi.PPC_evstdwmx -PPC_evstdwu = _idaapi.PPC_evstdwu -PPC_evstdhmx = _idaapi.PPC_evstdhmx -PPC_evstdhu = _idaapi.PPC_evstdhu -PPC_evstdbmx = _idaapi.PPC_evstdbmx -PPC_evstdbu = _idaapi.PPC_evstdbu -PPC_evlwbemx = _idaapi.PPC_evlwbemx -PPC_evlwbeu = _idaapi.PPC_evlwbeu -PPC_evlwboumx = _idaapi.PPC_evlwboumx -PPC_evlwbouu = _idaapi.PPC_evlwbouu -PPC_evlwbosmx = _idaapi.PPC_evlwbosmx -PPC_evlwbosu = _idaapi.PPC_evlwbosu -PPC_evstwhemx = _idaapi.PPC_evstwhemx -PPC_evstwheu = _idaapi.PPC_evstwheu -PPC_evstwbemx = _idaapi.PPC_evstwbemx -PPC_evstwbeu = _idaapi.PPC_evstwbeu -PPC_evstwhomx = _idaapi.PPC_evstwhomx -PPC_evstwhou = _idaapi.PPC_evstwhou -PPC_evstwbomx = _idaapi.PPC_evstwbomx -PPC_evstwbou = _idaapi.PPC_evstwbou -PPC_evstwwemx = _idaapi.PPC_evstwwemx -PPC_evstwweu = _idaapi.PPC_evstwweu -PPC_evstwbmx = _idaapi.PPC_evstwbmx -PPC_evstwbu = _idaapi.PPC_evstwbu -PPC_evstwwomx = _idaapi.PPC_evstwwomx -PPC_evstwwou = _idaapi.PPC_evstwwou -PPC_evsthbmx = _idaapi.PPC_evsthbmx -PPC_evsthbu = _idaapi.PPC_evsthbu -PPC_evmhusi = _idaapi.PPC_evmhusi -PPC_evmhssi = _idaapi.PPC_evmhssi -PPC_evmhsusi = _idaapi.PPC_evmhsusi -PPC_evmhssf = _idaapi.PPC_evmhssf -PPC_evmhumi = _idaapi.PPC_evmhumi -PPC_evmhssfr = _idaapi.PPC_evmhssfr -PPC_evmhesumi = _idaapi.PPC_evmhesumi -PPC_evmhosumi = _idaapi.PPC_evmhosumi -PPC_evmbeumi = _idaapi.PPC_evmbeumi -PPC_evmbesmi = _idaapi.PPC_evmbesmi -PPC_evmbesumi = _idaapi.PPC_evmbesumi -PPC_evmboumi = _idaapi.PPC_evmboumi -PPC_evmbosmi = _idaapi.PPC_evmbosmi -PPC_evmbosumi = _idaapi.PPC_evmbosumi -PPC_evmhesumia = _idaapi.PPC_evmhesumia -PPC_evmhosumia = _idaapi.PPC_evmhosumia -PPC_evmbeumia = _idaapi.PPC_evmbeumia -PPC_evmbesmia = _idaapi.PPC_evmbesmia -PPC_evmbesumia = _idaapi.PPC_evmbesumia -PPC_evmboumia = _idaapi.PPC_evmboumia -PPC_evmbosmia = _idaapi.PPC_evmbosmia -PPC_evmbosumia = _idaapi.PPC_evmbosumia -PPC_evmwusiw = _idaapi.PPC_evmwusiw -PPC_evmwssiw = _idaapi.PPC_evmwssiw -PPC_evmwhssfr = _idaapi.PPC_evmwhssfr -PPC_evmwehgsmfr = _idaapi.PPC_evmwehgsmfr -PPC_evmwehgsmf = _idaapi.PPC_evmwehgsmf -PPC_evmwohgsmfr = _idaapi.PPC_evmwohgsmfr -PPC_evmwohgsmf = _idaapi.PPC_evmwohgsmf -PPC_evmwhssfra = _idaapi.PPC_evmwhssfra -PPC_evmwehgsmfra = _idaapi.PPC_evmwehgsmfra -PPC_evmwehgsmfa = _idaapi.PPC_evmwehgsmfa -PPC_evmwohgsmfra = _idaapi.PPC_evmwohgsmfra -PPC_evmwohgsmfa = _idaapi.PPC_evmwohgsmfa -PPC_evaddusiaa = _idaapi.PPC_evaddusiaa -PPC_evaddssiaa = _idaapi.PPC_evaddssiaa -PPC_evsubfusiaa = _idaapi.PPC_evsubfusiaa -PPC_evsubfssiaa = _idaapi.PPC_evsubfssiaa -PPC_evaddsmiaa = _idaapi.PPC_evaddsmiaa -PPC_evsubfsmiaa = _idaapi.PPC_evsubfsmiaa -PPC_evaddh = _idaapi.PPC_evaddh -PPC_evaddhss = _idaapi.PPC_evaddhss -PPC_evsubfh = _idaapi.PPC_evsubfh -PPC_evsubfhss = _idaapi.PPC_evsubfhss -PPC_evaddhx = _idaapi.PPC_evaddhx -PPC_evaddhxss = _idaapi.PPC_evaddhxss -PPC_evsubfhx = _idaapi.PPC_evsubfhx -PPC_evsubfhxss = _idaapi.PPC_evsubfhxss -PPC_evaddd = _idaapi.PPC_evaddd -PPC_evadddss = _idaapi.PPC_evadddss -PPC_evsubfd = _idaapi.PPC_evsubfd -PPC_evsubfdss = _idaapi.PPC_evsubfdss -PPC_evaddb = _idaapi.PPC_evaddb -PPC_evaddbss = _idaapi.PPC_evaddbss -PPC_evsubfb = _idaapi.PPC_evsubfb -PPC_evsubfbss = _idaapi.PPC_evsubfbss -PPC_evaddsubfh = _idaapi.PPC_evaddsubfh -PPC_evaddsubfhss = _idaapi.PPC_evaddsubfhss -PPC_evsubfaddh = _idaapi.PPC_evsubfaddh -PPC_evsubfaddhss = _idaapi.PPC_evsubfaddhss -PPC_evaddsubfhx = _idaapi.PPC_evaddsubfhx -PPC_evaddsubfhxss = _idaapi.PPC_evaddsubfhxss -PPC_evsubfaddhx = _idaapi.PPC_evsubfaddhx -PPC_evsubfaddhxss = _idaapi.PPC_evsubfaddhxss -PPC_evadddus = _idaapi.PPC_evadddus -PPC_evaddbus = _idaapi.PPC_evaddbus -PPC_evsubfdus = _idaapi.PPC_evsubfdus -PPC_evsubfbus = _idaapi.PPC_evsubfbus -PPC_evaddwus = _idaapi.PPC_evaddwus -PPC_evaddwxus = _idaapi.PPC_evaddwxus -PPC_evsubfwus = _idaapi.PPC_evsubfwus -PPC_evsubfwxus = _idaapi.PPC_evsubfwxus -PPC_evadd2subf2h = _idaapi.PPC_evadd2subf2h -PPC_evadd2subf2hss = _idaapi.PPC_evadd2subf2hss -PPC_evsubf2add2h = _idaapi.PPC_evsubf2add2h -PPC_evsubf2add2hss = _idaapi.PPC_evsubf2add2hss -PPC_evaddhus = _idaapi.PPC_evaddhus -PPC_evaddhxus = _idaapi.PPC_evaddhxus -PPC_evsubfhus = _idaapi.PPC_evsubfhus -PPC_evsubfhxus = _idaapi.PPC_evsubfhxus -PPC_evaddwss = _idaapi.PPC_evaddwss -PPC_evsubfwss = _idaapi.PPC_evsubfwss -PPC_evaddwx = _idaapi.PPC_evaddwx -PPC_evaddwxss = _idaapi.PPC_evaddwxss -PPC_evsubfwx = _idaapi.PPC_evsubfwx -PPC_evsubfwxss = _idaapi.PPC_evsubfwxss -PPC_evaddsubfw = _idaapi.PPC_evaddsubfw -PPC_evaddsubfwss = _idaapi.PPC_evaddsubfwss -PPC_evsubfaddw = _idaapi.PPC_evsubfaddw -PPC_evsubfaddwss = _idaapi.PPC_evsubfaddwss -PPC_evaddsubfwx = _idaapi.PPC_evaddsubfwx -PPC_evaddsubfwxss = _idaapi.PPC_evaddsubfwxss -PPC_evsubfaddwx = _idaapi.PPC_evsubfaddwx -PPC_evsubfaddwxss = _idaapi.PPC_evsubfaddwxss -PPC_evmar = _idaapi.PPC_evmar -PPC_evsumwu = _idaapi.PPC_evsumwu -PPC_evsumws = _idaapi.PPC_evsumws -PPC_evsum4bu = _idaapi.PPC_evsum4bu -PPC_evsum4bs = _idaapi.PPC_evsum4bs -PPC_evsum2hu = _idaapi.PPC_evsum2hu -PPC_evsum2hs = _idaapi.PPC_evsum2hs -PPC_evdiff2his = _idaapi.PPC_evdiff2his -PPC_evsum2his = _idaapi.PPC_evsum2his -PPC_evsumwua = _idaapi.PPC_evsumwua -PPC_evsumwsa = _idaapi.PPC_evsumwsa -PPC_evsum4bua = _idaapi.PPC_evsum4bua -PPC_evsum4bsa = _idaapi.PPC_evsum4bsa -PPC_evsum2hua = _idaapi.PPC_evsum2hua -PPC_evsum2hsa = _idaapi.PPC_evsum2hsa -PPC_evdiff2hisa = _idaapi.PPC_evdiff2hisa -PPC_evsum2hisa = _idaapi.PPC_evsum2hisa -PPC_evsumwuaa = _idaapi.PPC_evsumwuaa -PPC_evsumwsaa = _idaapi.PPC_evsumwsaa -PPC_evsum4buaaw = _idaapi.PPC_evsum4buaaw -PPC_evsum4bsaaw = _idaapi.PPC_evsum4bsaaw -PPC_evsum2huaaw = _idaapi.PPC_evsum2huaaw -PPC_evsum2hsaaw = _idaapi.PPC_evsum2hsaaw -PPC_evdiff2hisaaw = _idaapi.PPC_evdiff2hisaaw -PPC_evsum2hisaaw = _idaapi.PPC_evsum2hisaaw -PPC_evdivwsf = _idaapi.PPC_evdivwsf -PPC_evdivwuf = _idaapi.PPC_evdivwuf -PPC_evdivs = _idaapi.PPC_evdivs -PPC_evdivu = _idaapi.PPC_evdivu -PPC_evaddwegsi = _idaapi.PPC_evaddwegsi -PPC_evaddwegsf = _idaapi.PPC_evaddwegsf -PPC_evsubfwegsi = _idaapi.PPC_evsubfwegsi -PPC_evsubfwegsf = _idaapi.PPC_evsubfwegsf -PPC_evaddwogsi = _idaapi.PPC_evaddwogsi -PPC_evaddwogsf = _idaapi.PPC_evaddwogsf -PPC_evsubfwogsi = _idaapi.PPC_evsubfwogsi -PPC_evsubfwogsf = _idaapi.PPC_evsubfwogsf -PPC_evaddhhiuw = _idaapi.PPC_evaddhhiuw -PPC_evaddhhisw = _idaapi.PPC_evaddhhisw -PPC_evsubfhhiuw = _idaapi.PPC_evsubfhhiuw -PPC_evsubfhhisw = _idaapi.PPC_evsubfhhisw -PPC_evaddhlouw = _idaapi.PPC_evaddhlouw -PPC_evaddhlosw = _idaapi.PPC_evaddhlosw -PPC_evsubfhlouw = _idaapi.PPC_evsubfhlouw -PPC_evsubfhlosw = _idaapi.PPC_evsubfhlosw -PPC_evmhesusiaaw = _idaapi.PPC_evmhesusiaaw -PPC_evmhosusiaaw = _idaapi.PPC_evmhosusiaaw -PPC_evmhesumiaaw = _idaapi.PPC_evmhesumiaaw -PPC_evmhosumiaaw = _idaapi.PPC_evmhosumiaaw -PPC_evmbeusiaah = _idaapi.PPC_evmbeusiaah -PPC_evmbessiaah = _idaapi.PPC_evmbessiaah -PPC_evmbesusiaah = _idaapi.PPC_evmbesusiaah -PPC_evmbousiaah = _idaapi.PPC_evmbousiaah -PPC_evmbossiaah = _idaapi.PPC_evmbossiaah -PPC_evmbosusiaah = _idaapi.PPC_evmbosusiaah -PPC_evmbeumiaah = _idaapi.PPC_evmbeumiaah -PPC_evmbesmiaah = _idaapi.PPC_evmbesmiaah -PPC_evmbesumiaah = _idaapi.PPC_evmbesumiaah -PPC_evmboumiaah = _idaapi.PPC_evmboumiaah -PPC_evmbosmiaah = _idaapi.PPC_evmbosmiaah -PPC_evmbosumiaah = _idaapi.PPC_evmbosumiaah -PPC_evmwlusiaaw3 = _idaapi.PPC_evmwlusiaaw3 -PPC_evmwlssiaaw3 = _idaapi.PPC_evmwlssiaaw3 -PPC_evmwhssfraaw3 = _idaapi.PPC_evmwhssfraaw3 -PPC_evmwhssfaaw3 = _idaapi.PPC_evmwhssfaaw3 -PPC_evmwhssfraaw = _idaapi.PPC_evmwhssfraaw -PPC_evmwhssfaaw = _idaapi.PPC_evmwhssfaaw -PPC_evmwlumiaaw3 = _idaapi.PPC_evmwlumiaaw3 -PPC_evmwlsmiaaw3 = _idaapi.PPC_evmwlsmiaaw3 -PPC_evmwusiaa = _idaapi.PPC_evmwusiaa -PPC_evmwssiaa = _idaapi.PPC_evmwssiaa -PPC_evmwehgsmfraa = _idaapi.PPC_evmwehgsmfraa -PPC_evmwehgsmfaa = _idaapi.PPC_evmwehgsmfaa -PPC_evmwohgsmfraa = _idaapi.PPC_evmwohgsmfraa -PPC_evmwohgsmfaa = _idaapi.PPC_evmwohgsmfaa -PPC_evmhesusianw = _idaapi.PPC_evmhesusianw -PPC_evmhosusianw = _idaapi.PPC_evmhosusianw -PPC_evmhesumianw = _idaapi.PPC_evmhesumianw -PPC_evmhosumianw = _idaapi.PPC_evmhosumianw -PPC_evmbeusianh = _idaapi.PPC_evmbeusianh -PPC_evmbessianh = _idaapi.PPC_evmbessianh -PPC_evmbesusianh = _idaapi.PPC_evmbesusianh -PPC_evmbousianh = _idaapi.PPC_evmbousianh -PPC_evmbossianh = _idaapi.PPC_evmbossianh -PPC_evmbosusianh = _idaapi.PPC_evmbosusianh -PPC_evmbeumianh = _idaapi.PPC_evmbeumianh -PPC_evmbesmianh = _idaapi.PPC_evmbesmianh -PPC_evmbesumianh = _idaapi.PPC_evmbesumianh -PPC_evmboumianh = _idaapi.PPC_evmboumianh -PPC_evmbosmianh = _idaapi.PPC_evmbosmianh -PPC_evmbosumianh = _idaapi.PPC_evmbosumianh -PPC_evmwlusianw3 = _idaapi.PPC_evmwlusianw3 -PPC_evmwlssianw3 = _idaapi.PPC_evmwlssianw3 -PPC_evmwhssfranw3 = _idaapi.PPC_evmwhssfranw3 -PPC_evmwhssfanw3 = _idaapi.PPC_evmwhssfanw3 -PPC_evmwhssfranw = _idaapi.PPC_evmwhssfranw -PPC_evmwhssfanw = _idaapi.PPC_evmwhssfanw -PPC_evmwlumianw3 = _idaapi.PPC_evmwlumianw3 -PPC_evmwlsmianw3 = _idaapi.PPC_evmwlsmianw3 -PPC_evmwusian = _idaapi.PPC_evmwusian -PPC_evmwssian = _idaapi.PPC_evmwssian -PPC_evmwehgsmfran = _idaapi.PPC_evmwehgsmfran -PPC_evmwehgsmfan = _idaapi.PPC_evmwehgsmfan -PPC_evmwohgsmfran = _idaapi.PPC_evmwohgsmfran -PPC_evmwohgsmfan = _idaapi.PPC_evmwohgsmfan -PPC_evseteqb = _idaapi.PPC_evseteqb -PPC_evseteqh = _idaapi.PPC_evseteqh -PPC_evseteqw = _idaapi.PPC_evseteqw -PPC_evsetgthu = _idaapi.PPC_evsetgthu -PPC_evsetgths = _idaapi.PPC_evsetgths -PPC_evsetgtwu = _idaapi.PPC_evsetgtwu -PPC_evsetgtws = _idaapi.PPC_evsetgtws -PPC_evsetgtbu = _idaapi.PPC_evsetgtbu -PPC_evsetgtbs = _idaapi.PPC_evsetgtbs -PPC_evsetltbu = _idaapi.PPC_evsetltbu -PPC_evsetltbs = _idaapi.PPC_evsetltbs -PPC_evsetlthu = _idaapi.PPC_evsetlthu -PPC_evsetlths = _idaapi.PPC_evsetlths -PPC_evsetltwu = _idaapi.PPC_evsetltwu -PPC_evsetltws = _idaapi.PPC_evsetltws -PPC_evsaduw = _idaapi.PPC_evsaduw -PPC_evsadsw = _idaapi.PPC_evsadsw -PPC_evsad4ub = _idaapi.PPC_evsad4ub -PPC_evsad4sb = _idaapi.PPC_evsad4sb -PPC_evsad2uh = _idaapi.PPC_evsad2uh -PPC_evsad2sh = _idaapi.PPC_evsad2sh -PPC_evsaduwa = _idaapi.PPC_evsaduwa -PPC_evsadswa = _idaapi.PPC_evsadswa -PPC_evsad4uba = _idaapi.PPC_evsad4uba -PPC_evsad4sba = _idaapi.PPC_evsad4sba -PPC_evsad2uha = _idaapi.PPC_evsad2uha -PPC_evsad2sha = _idaapi.PPC_evsad2sha -PPC_evabsdifuw = _idaapi.PPC_evabsdifuw -PPC_evabsdifsw = _idaapi.PPC_evabsdifsw -PPC_evabsdifub = _idaapi.PPC_evabsdifub -PPC_evabsdifsb = _idaapi.PPC_evabsdifsb -PPC_evabsdifuh = _idaapi.PPC_evabsdifuh -PPC_evabsdifsh = _idaapi.PPC_evabsdifsh -PPC_evsaduwaa = _idaapi.PPC_evsaduwaa -PPC_evsadswaa = _idaapi.PPC_evsadswaa -PPC_evsad4ubaaw = _idaapi.PPC_evsad4ubaaw -PPC_evsad4sbaaw = _idaapi.PPC_evsad4sbaaw -PPC_evsad2uhaaw = _idaapi.PPC_evsad2uhaaw -PPC_evsad2shaaw = _idaapi.PPC_evsad2shaaw -PPC_evpkshubs = _idaapi.PPC_evpkshubs -PPC_evpkshsbs = _idaapi.PPC_evpkshsbs -PPC_evpkswuhs = _idaapi.PPC_evpkswuhs -PPC_evpkswshs = _idaapi.PPC_evpkswshs -PPC_evpkuhubs = _idaapi.PPC_evpkuhubs -PPC_evpkuwuhs = _idaapi.PPC_evpkuwuhs -PPC_evpkswshilvs = _idaapi.PPC_evpkswshilvs -PPC_evpkswgshefrs = _idaapi.PPC_evpkswgshefrs -PPC_evpkswshfrs = _idaapi.PPC_evpkswshfrs -PPC_evpkswshilvfrs = _idaapi.PPC_evpkswshilvfrs -PPC_evpksdswfrs = _idaapi.PPC_evpksdswfrs -PPC_evpksdshefrs = _idaapi.PPC_evpksdshefrs -PPC_evpkuduws = _idaapi.PPC_evpkuduws -PPC_evpksdsws = _idaapi.PPC_evpksdsws -PPC_evpkswgswfrs = _idaapi.PPC_evpkswgswfrs -PPC_evilveh = _idaapi.PPC_evilveh -PPC_evilveoh = _idaapi.PPC_evilveoh -PPC_evilvhih = _idaapi.PPC_evilvhih -PPC_evilvhiloh = _idaapi.PPC_evilvhiloh -PPC_evilvloh = _idaapi.PPC_evilvloh -PPC_evilvlohih = _idaapi.PPC_evilvlohih -PPC_evilvoeh = _idaapi.PPC_evilvoeh -PPC_evilvoh = _idaapi.PPC_evilvoh -PPC_evdlveb = _idaapi.PPC_evdlveb -PPC_evdlveh = _idaapi.PPC_evdlveh -PPC_evdlveob = _idaapi.PPC_evdlveob -PPC_evdlveoh = _idaapi.PPC_evdlveoh -PPC_evdlvob = _idaapi.PPC_evdlvob -PPC_evdlvoh = _idaapi.PPC_evdlvoh -PPC_evdlvoeb = _idaapi.PPC_evdlvoeb -PPC_evdlvoeh = _idaapi.PPC_evdlvoeh -PPC_evmaxbu = _idaapi.PPC_evmaxbu -PPC_evmaxbs = _idaapi.PPC_evmaxbs -PPC_evmaxhu = _idaapi.PPC_evmaxhu -PPC_evmaxhs = _idaapi.PPC_evmaxhs -PPC_evmaxwu = _idaapi.PPC_evmaxwu -PPC_evmaxws = _idaapi.PPC_evmaxws -PPC_evmaxdu = _idaapi.PPC_evmaxdu -PPC_evmaxds = _idaapi.PPC_evmaxds -PPC_evminbu = _idaapi.PPC_evminbu -PPC_evminbs = _idaapi.PPC_evminbs -PPC_evminhu = _idaapi.PPC_evminhu -PPC_evminhs = _idaapi.PPC_evminhs -PPC_evminwu = _idaapi.PPC_evminwu -PPC_evminws = _idaapi.PPC_evminws -PPC_evmindu = _idaapi.PPC_evmindu -PPC_evminds = _idaapi.PPC_evminds -PPC_evavgwu = _idaapi.PPC_evavgwu -PPC_evavgws = _idaapi.PPC_evavgws -PPC_evavgbu = _idaapi.PPC_evavgbu -PPC_evavgbs = _idaapi.PPC_evavgbs -PPC_evavghu = _idaapi.PPC_evavghu -PPC_evavghs = _idaapi.PPC_evavghs -PPC_evavgdu = _idaapi.PPC_evavgdu -PPC_evavgds = _idaapi.PPC_evavgds -PPC_evavgwur = _idaapi.PPC_evavgwur -PPC_evavgwsr = _idaapi.PPC_evavgwsr -PPC_evavgbur = _idaapi.PPC_evavgbur -PPC_evavgbsr = _idaapi.PPC_evavgbsr -PPC_evavghur = _idaapi.PPC_evavghur -PPC_evavghsr = _idaapi.PPC_evavghsr -PPC_evavgdur = _idaapi.PPC_evavgdur -PPC_evavgdsr = _idaapi.PPC_evavgdsr -PPC_tdui = _idaapi.PPC_tdui -PPC_tdu = _idaapi.PPC_tdu -PPC_twui = _idaapi.PPC_twui -PPC_twu = _idaapi.PPC_twu -PPC_bctar = _idaapi.PPC_bctar -PPC_clrbhrb = _idaapi.PPC_clrbhrb -PPC_mfbhrbe = _idaapi.PPC_mfbhrbe -PPC_mtsle = _idaapi.PPC_mtsle -PPC_mfvsrd = _idaapi.PPC_mfvsrd -PPC_mfvsrwz = _idaapi.PPC_mfvsrwz -PPC_mtvsrd = _idaapi.PPC_mtvsrd -PPC_mtvsrwa = _idaapi.PPC_mtvsrwa -PPC_mtvsrwz = _idaapi.PPC_mtvsrwz -PPC_fmrgew = _idaapi.PPC_fmrgew -PPC_fmrgow = _idaapi.PPC_fmrgow -PPC_vpksdss = _idaapi.PPC_vpksdss -PPC_vpksdus = _idaapi.PPC_vpksdus -PPC_vpkudus = _idaapi.PPC_vpkudus -PPC_vpkudum = _idaapi.PPC_vpkudum -PPC_vupkhsw = _idaapi.PPC_vupkhsw -PPC_vupklsw = _idaapi.PPC_vupklsw -PPC_vmrgew = _idaapi.PPC_vmrgew -PPC_vmrgow = _idaapi.PPC_vmrgow -PPC_vaddudm = _idaapi.PPC_vaddudm -PPC_vadduqm = _idaapi.PPC_vadduqm -PPC_vaddeuqm = _idaapi.PPC_vaddeuqm -PPC_vaddcuq = _idaapi.PPC_vaddcuq -PPC_vaddecuq = _idaapi.PPC_vaddecuq -PPC_vsubudm = _idaapi.PPC_vsubudm -PPC_vsubuqm = _idaapi.PPC_vsubuqm -PPC_vsubeuqm = _idaapi.PPC_vsubeuqm -PPC_vsubcuq = _idaapi.PPC_vsubcuq -PPC_vsubecuq = _idaapi.PPC_vsubecuq -PPC_vmulesw = _idaapi.PPC_vmulesw -PPC_vmuleuw = _idaapi.PPC_vmuleuw -PPC_vmulosw = _idaapi.PPC_vmulosw -PPC_vmulouw = _idaapi.PPC_vmulouw -PPC_vmuluwm = _idaapi.PPC_vmuluwm -PPC_vmaxsd = _idaapi.PPC_vmaxsd -PPC_vmaxud = _idaapi.PPC_vmaxud -PPC_vminsd = _idaapi.PPC_vminsd -PPC_vminud = _idaapi.PPC_vminud -PPC_vcmpequd = _idaapi.PPC_vcmpequd -PPC_vcmpgtsd = _idaapi.PPC_vcmpgtsd -PPC_vcmpgtud = _idaapi.PPC_vcmpgtud -PPC_veqv = _idaapi.PPC_veqv -PPC_vnand = _idaapi.PPC_vnand -PPC_vorc = _idaapi.PPC_vorc -PPC_vrld = _idaapi.PPC_vrld -PPC_vsld = _idaapi.PPC_vsld -PPC_vsrd = _idaapi.PPC_vsrd -PPC_vsrad = _idaapi.PPC_vsrad -PPC_vcipher = _idaapi.PPC_vcipher -PPC_vcipherlast = _idaapi.PPC_vcipherlast -PPC_vncipher = _idaapi.PPC_vncipher -PPC_vncipherlast = _idaapi.PPC_vncipherlast -PPC_vsbox = _idaapi.PPC_vsbox -PPC_vshasigmad = _idaapi.PPC_vshasigmad -PPC_vshasigmaw = _idaapi.PPC_vshasigmaw -PPC_vpmsumb = _idaapi.PPC_vpmsumb -PPC_vpmsumd = _idaapi.PPC_vpmsumd -PPC_vpmsumh = _idaapi.PPC_vpmsumh -PPC_vpmsumw = _idaapi.PPC_vpmsumw -PPC_vpermxor = _idaapi.PPC_vpermxor -PPC_vgbbd = _idaapi.PPC_vgbbd -PPC_vclzb = _idaapi.PPC_vclzb -PPC_vclzh = _idaapi.PPC_vclzh -PPC_vclzw = _idaapi.PPC_vclzw -PPC_vclzd = _idaapi.PPC_vclzd -PPC_vpopcntb = _idaapi.PPC_vpopcntb -PPC_vpopcntd = _idaapi.PPC_vpopcntd -PPC_vpopcnth = _idaapi.PPC_vpopcnth -PPC_vpopcntw = _idaapi.PPC_vpopcntw -PPC_vbpermq = _idaapi.PPC_vbpermq -PPC_bcdadd = _idaapi.PPC_bcdadd -PPC_bcdsub = _idaapi.PPC_bcdsub -PPC_lxsiwax = _idaapi.PPC_lxsiwax -PPC_lxsspx = _idaapi.PPC_lxsspx -PPC_lxsiwzx = _idaapi.PPC_lxsiwzx -PPC_stxsiwx = _idaapi.PPC_stxsiwx -PPC_stxsspx = _idaapi.PPC_stxsspx -PPC_xsaddsp = _idaapi.PPC_xsaddsp -PPC_xscvdpspn = _idaapi.PPC_xscvdpspn -PPC_xscvspdpn = _idaapi.PPC_xscvspdpn -PPC_xscvsxdsp = _idaapi.PPC_xscvsxdsp -PPC_xscvuxdsp = _idaapi.PPC_xscvuxdsp -PPC_xsdivsp = _idaapi.PPC_xsdivsp -PPC_xsmaddasp = _idaapi.PPC_xsmaddasp -PPC_xsmaddmsp = _idaapi.PPC_xsmaddmsp -PPC_xsmsubasp = _idaapi.PPC_xsmsubasp -PPC_xsmsubmsp = _idaapi.PPC_xsmsubmsp -PPC_xsmulsp = _idaapi.PPC_xsmulsp -PPC_xsnmaddasp = _idaapi.PPC_xsnmaddasp -PPC_xsnmaddmsp = _idaapi.PPC_xsnmaddmsp -PPC_xsnmsubasp = _idaapi.PPC_xsnmsubasp -PPC_xsnmsubmsp = _idaapi.PPC_xsnmsubmsp -PPC_xsresp = _idaapi.PPC_xsresp -PPC_xsrsp = _idaapi.PPC_xsrsp -PPC_xsrsqrtesp = _idaapi.PPC_xsrsqrtesp -PPC_xssqrtsp = _idaapi.PPC_xssqrtsp -PPC_xssubsp = _idaapi.PPC_xssubsp -PPC_xxleqv = _idaapi.PPC_xxleqv -PPC_xxlnand = _idaapi.PPC_xxlnand -PPC_xxlorc = _idaapi.PPC_xxlorc -PPC_lqarx = _idaapi.PPC_lqarx -PPC_stqcx = _idaapi.PPC_stqcx -PPC_tbegin = _idaapi.PPC_tbegin -PPC_tend = _idaapi.PPC_tend -PPC_tabort = _idaapi.PPC_tabort -PPC_tabortwc = _idaapi.PPC_tabortwc -PPC_tabortwci = _idaapi.PPC_tabortwci -PPC_tabortdc = _idaapi.PPC_tabortdc -PPC_tabortdci = _idaapi.PPC_tabortdci -PPC_tsr = _idaapi.PPC_tsr -PPC_tcheck = _idaapi.PPC_tcheck -PPC_rfebb = _idaapi.PPC_rfebb -PPC_treclaim = _idaapi.PPC_treclaim -PPC_trechkpt = _idaapi.PPC_trechkpt -PPC_msgsndp = _idaapi.PPC_msgsndp -PPC_msgclrp = _idaapi.PPC_msgclrp -PPC_dcblq = _idaapi.PPC_dcblq -PPC_icblq = _idaapi.PPC_icblq -PPC_vmr = _idaapi.PPC_vmr -PPC_vnot = _idaapi.PPC_vnot -PPC_tendall = _idaapi.PPC_tendall -PPC_tsuspend = _idaapi.PPC_tsuspend -PPC_tresume = _idaapi.PPC_tresume -PPC_mtppr = _idaapi.PPC_mtppr -PPC_mfppr = _idaapi.PPC_mfppr -PPC_mtppr32 = _idaapi.PPC_mtppr32 -PPC_mfppr32 = _idaapi.PPC_mfppr32 -PPC_mtic = _idaapi.PPC_mtic -PPC_mfic = _idaapi.PPC_mfic -PPC_mtvtb = _idaapi.PPC_mtvtb -PPC_mfvtb = _idaapi.PPC_mfvtb -PPC_miso = _idaapi.PPC_miso -PPC_mdoio = _idaapi.PPC_mdoio -PPC_mdoom = _idaapi.PPC_mdoom PPC_last = _idaapi.PPC_last NEC850_NULL = _idaapi.NEC850_NULL NEC850_BREAKPOINT = _idaapi.NEC850_BREAKPOINT @@ -20311,349 +20719,15 @@ TMS28_zalr = _idaapi.TMS28_zalr TMS28_zap = _idaapi.TMS28_zap TMS28_zapa = _idaapi.TMS28_zapa TMS28_last = _idaapi.TMS28_last -UNSP_null = _idaapi.UNSP_null -UNSP_add = _idaapi.UNSP_add -UNSP_adc = _idaapi.UNSP_adc -UNSP_sub = _idaapi.UNSP_sub -UNSP_sbc = _idaapi.UNSP_sbc -UNSP_cmp = _idaapi.UNSP_cmp -UNSP_cmpc = _idaapi.UNSP_cmpc -UNSP_neg = _idaapi.UNSP_neg -UNSP_negc = _idaapi.UNSP_negc -UNSP_xor = _idaapi.UNSP_xor -UNSP_load = _idaapi.UNSP_load -UNSP_or = _idaapi.UNSP_or -UNSP_and = _idaapi.UNSP_and -UNSP_test = _idaapi.UNSP_test -UNSP_store = _idaapi.UNSP_store -UNSP_add_s = _idaapi.UNSP_add_s -UNSP_adc_s = _idaapi.UNSP_adc_s -UNSP_sub_s = _idaapi.UNSP_sub_s -UNSP_sbc_s = _idaapi.UNSP_sbc_s -UNSP_cmp_s = _idaapi.UNSP_cmp_s -UNSP_cmpc_s = _idaapi.UNSP_cmpc_s -UNSP_neg_s = _idaapi.UNSP_neg_s -UNSP_negc_s = _idaapi.UNSP_negc_s -UNSP_xor_s = _idaapi.UNSP_xor_s -UNSP_load_s = _idaapi.UNSP_load_s -UNSP_or_s = _idaapi.UNSP_or_s -UNSP_and_s = _idaapi.UNSP_and_s -UNSP_test_s = _idaapi.UNSP_test_s -UNSP_store_s = _idaapi.UNSP_store_s -UNSP_retf = _idaapi.UNSP_retf -UNSP_reti = _idaapi.UNSP_reti -UNSP_pop = _idaapi.UNSP_pop -UNSP_push = _idaapi.UNSP_push -UNSP_call = _idaapi.UNSP_call -UNSP_goto = _idaapi.UNSP_goto -UNSP_nop = _idaapi.UNSP_nop -UNSP_exp = _idaapi.UNSP_exp -UNSP_jb = _idaapi.UNSP_jb -UNSP_jae = _idaapi.UNSP_jae -UNSP_jge = _idaapi.UNSP_jge -UNSP_jl = _idaapi.UNSP_jl -UNSP_jne = _idaapi.UNSP_jne -UNSP_je = _idaapi.UNSP_je -UNSP_jpl = _idaapi.UNSP_jpl -UNSP_jmi = _idaapi.UNSP_jmi -UNSP_jbe = _idaapi.UNSP_jbe -UNSP_ja = _idaapi.UNSP_ja -UNSP_jle = _idaapi.UNSP_jle -UNSP_jg = _idaapi.UNSP_jg -UNSP_jvc = _idaapi.UNSP_jvc -UNSP_jvs = _idaapi.UNSP_jvs -UNSP_jmp = _idaapi.UNSP_jmp -UNSP_mulss = _idaapi.UNSP_mulss -UNSP_mulus = _idaapi.UNSP_mulus -UNSP_muluu = _idaapi.UNSP_muluu -UNSP_divs = _idaapi.UNSP_divs -UNSP_divq = _idaapi.UNSP_divq -UNSP_int1 = _idaapi.UNSP_int1 -UNSP_int2 = _idaapi.UNSP_int2 -UNSP_fir_mov = _idaapi.UNSP_fir_mov -UNSP_fraction = _idaapi.UNSP_fraction -UNSP_irq = _idaapi.UNSP_irq -UNSP_secbank = _idaapi.UNSP_secbank -UNSP_fiq = _idaapi.UNSP_fiq -UNSP_irqnest = _idaapi.UNSP_irqnest -UNSP_break = _idaapi.UNSP_break -UNSP_asr = _idaapi.UNSP_asr -UNSP_asror = _idaapi.UNSP_asror -UNSP_lsl = _idaapi.UNSP_lsl -UNSP_lslor = _idaapi.UNSP_lslor -UNSP_lsr = _idaapi.UNSP_lsr -UNSP_lsror = _idaapi.UNSP_lsror -UNSP_rol = _idaapi.UNSP_rol -UNSP_ror = _idaapi.UNSP_ror -UNSP_tstb = _idaapi.UNSP_tstb -UNSP_setb = _idaapi.UNSP_setb -UNSP_clrb = _idaapi.UNSP_clrb -UNSP_invb = _idaapi.UNSP_invb -UNSP_last = _idaapi.UNSP_last -DALVIK_NOP = _idaapi.DALVIK_NOP -DALVIK_MOVE = _idaapi.DALVIK_MOVE -DALVIK_MOVE_FROM16 = _idaapi.DALVIK_MOVE_FROM16 -DALVIK_MOVE_16 = _idaapi.DALVIK_MOVE_16 -DALVIK_MOVE_WIDE = _idaapi.DALVIK_MOVE_WIDE -DALVIK_MOVE_WIDE_FROM16 = _idaapi.DALVIK_MOVE_WIDE_FROM16 -DALVIK_MOVE_WIDE_16 = _idaapi.DALVIK_MOVE_WIDE_16 -DALVIK_MOVE_OBJECT = _idaapi.DALVIK_MOVE_OBJECT -DALVIK_MOVE_OBJECT_FROM16 = _idaapi.DALVIK_MOVE_OBJECT_FROM16 -DALVIK_MOVE_OBJECT_16 = _idaapi.DALVIK_MOVE_OBJECT_16 -DALVIK_MOVE_RESULT = _idaapi.DALVIK_MOVE_RESULT -DALVIK_MOVE_RESULT_WIDE = _idaapi.DALVIK_MOVE_RESULT_WIDE -DALVIK_MOVE_RESULT_OBJECT = _idaapi.DALVIK_MOVE_RESULT_OBJECT -DALVIK_MOVE_EXCEPTION = _idaapi.DALVIK_MOVE_EXCEPTION -DALVIK_RETURN_VOID = _idaapi.DALVIK_RETURN_VOID -DALVIK_RETURN = _idaapi.DALVIK_RETURN -DALVIK_RETURN_WIDE = _idaapi.DALVIK_RETURN_WIDE -DALVIK_RETURN_OBJECT = _idaapi.DALVIK_RETURN_OBJECT -DALVIK_CONST_4 = _idaapi.DALVIK_CONST_4 -DALVIK_CONST_16 = _idaapi.DALVIK_CONST_16 -DALVIK_CONST = _idaapi.DALVIK_CONST -DALVIK_CONST_HIGH16 = _idaapi.DALVIK_CONST_HIGH16 -DALVIK_CONST_WIDE_16 = _idaapi.DALVIK_CONST_WIDE_16 -DALVIK_CONST_WIDE_32 = _idaapi.DALVIK_CONST_WIDE_32 -DALVIK_CONST_WIDE = _idaapi.DALVIK_CONST_WIDE -DALVIK_CONST_WIDE_HIGH16 = _idaapi.DALVIK_CONST_WIDE_HIGH16 -DALVIK_CONST_STRING = _idaapi.DALVIK_CONST_STRING -DALVIK_CONST_STRING_JUMBO = _idaapi.DALVIK_CONST_STRING_JUMBO -DALVIK_CONST_CLASS = _idaapi.DALVIK_CONST_CLASS -DALVIK_MONITOR_ENTER = _idaapi.DALVIK_MONITOR_ENTER -DALVIK_MONITOR_EXIT = _idaapi.DALVIK_MONITOR_EXIT -DALVIK_CHECK_CAST = _idaapi.DALVIK_CHECK_CAST -DALVIK_INSTANCE_OF = _idaapi.DALVIK_INSTANCE_OF -DALVIK_ARRAY_LENGTH = _idaapi.DALVIK_ARRAY_LENGTH -DALVIK_NEW_INSTANCE = _idaapi.DALVIK_NEW_INSTANCE -DALVIK_NEW_ARRAY = _idaapi.DALVIK_NEW_ARRAY -DALVIK_FILLED_NEW_ARRAY = _idaapi.DALVIK_FILLED_NEW_ARRAY -DALVIK_FILLED_NEW_ARRAY_RANGE = _idaapi.DALVIK_FILLED_NEW_ARRAY_RANGE -DALVIK_FILL_ARRAY_DATA = _idaapi.DALVIK_FILL_ARRAY_DATA -DALVIK_THROW = _idaapi.DALVIK_THROW -DALVIK_GOTO = _idaapi.DALVIK_GOTO -DALVIK_GOTO_16 = _idaapi.DALVIK_GOTO_16 -DALVIK_GOTO_32 = _idaapi.DALVIK_GOTO_32 -DALVIK_PACKED_SWITCH = _idaapi.DALVIK_PACKED_SWITCH -DALVIK_SPARSE_SWITCH = _idaapi.DALVIK_SPARSE_SWITCH -DALVIK_CMPL_FLOAT = _idaapi.DALVIK_CMPL_FLOAT -DALVIK_CMPG_FLOAT = _idaapi.DALVIK_CMPG_FLOAT -DALVIK_CMPL_DOUBLE = _idaapi.DALVIK_CMPL_DOUBLE -DALVIK_CMPG_DOUBLE = _idaapi.DALVIK_CMPG_DOUBLE -DALVIK_CMP_LONG = _idaapi.DALVIK_CMP_LONG -DALVIK_IF_EQ = _idaapi.DALVIK_IF_EQ -DALVIK_IF_NE = _idaapi.DALVIK_IF_NE -DALVIK_IF_LT = _idaapi.DALVIK_IF_LT -DALVIK_IF_GE = _idaapi.DALVIK_IF_GE -DALVIK_IF_GT = _idaapi.DALVIK_IF_GT -DALVIK_IF_LE = _idaapi.DALVIK_IF_LE -DALVIK_IF_EQZ = _idaapi.DALVIK_IF_EQZ -DALVIK_IF_NEZ = _idaapi.DALVIK_IF_NEZ -DALVIK_IF_LTZ = _idaapi.DALVIK_IF_LTZ -DALVIK_IF_GEZ = _idaapi.DALVIK_IF_GEZ -DALVIK_IF_GTZ = _idaapi.DALVIK_IF_GTZ -DALVIK_IF_LEZ = _idaapi.DALVIK_IF_LEZ -DALVIK_UNUSED_3E = _idaapi.DALVIK_UNUSED_3E -DALVIK_UNUSED_3F = _idaapi.DALVIK_UNUSED_3F -DALVIK_UNUSED_40 = _idaapi.DALVIK_UNUSED_40 -DALVIK_UNUSED_41 = _idaapi.DALVIK_UNUSED_41 -DALVIK_UNUSED_42 = _idaapi.DALVIK_UNUSED_42 -DALVIK_UNUSED_43 = _idaapi.DALVIK_UNUSED_43 -DALVIK_AGET = _idaapi.DALVIK_AGET -DALVIK_AGET_WIDE = _idaapi.DALVIK_AGET_WIDE -DALVIK_AGET_OBJECT = _idaapi.DALVIK_AGET_OBJECT -DALVIK_AGET_BOOLEAN = _idaapi.DALVIK_AGET_BOOLEAN -DALVIK_AGET_BYTE = _idaapi.DALVIK_AGET_BYTE -DALVIK_AGET_CHAR = _idaapi.DALVIK_AGET_CHAR -DALVIK_AGET_SHORT = _idaapi.DALVIK_AGET_SHORT -DALVIK_APUT = _idaapi.DALVIK_APUT -DALVIK_APUT_WIDE = _idaapi.DALVIK_APUT_WIDE -DALVIK_APUT_OBJECT = _idaapi.DALVIK_APUT_OBJECT -DALVIK_APUT_BOOLEAN = _idaapi.DALVIK_APUT_BOOLEAN -DALVIK_APUT_BYTE = _idaapi.DALVIK_APUT_BYTE -DALVIK_APUT_CHAR = _idaapi.DALVIK_APUT_CHAR -DALVIK_APUT_SHORT = _idaapi.DALVIK_APUT_SHORT -DALVIK_IGET = _idaapi.DALVIK_IGET -DALVIK_IGET_WIDE = _idaapi.DALVIK_IGET_WIDE -DALVIK_IGET_OBJECT = _idaapi.DALVIK_IGET_OBJECT -DALVIK_IGET_BOOLEAN = _idaapi.DALVIK_IGET_BOOLEAN -DALVIK_IGET_BYTE = _idaapi.DALVIK_IGET_BYTE -DALVIK_IGET_CHAR = _idaapi.DALVIK_IGET_CHAR -DALVIK_IGET_SHORT = _idaapi.DALVIK_IGET_SHORT -DALVIK_IPUT = _idaapi.DALVIK_IPUT -DALVIK_IPUT_WIDE = _idaapi.DALVIK_IPUT_WIDE -DALVIK_IPUT_OBJECT = _idaapi.DALVIK_IPUT_OBJECT -DALVIK_IPUT_BOOLEAN = _idaapi.DALVIK_IPUT_BOOLEAN -DALVIK_IPUT_BYTE = _idaapi.DALVIK_IPUT_BYTE -DALVIK_IPUT_CHAR = _idaapi.DALVIK_IPUT_CHAR -DALVIK_IPUT_SHORT = _idaapi.DALVIK_IPUT_SHORT -DALVIK_SGET = _idaapi.DALVIK_SGET -DALVIK_SGET_WIDE = _idaapi.DALVIK_SGET_WIDE -DALVIK_SGET_OBJECT = _idaapi.DALVIK_SGET_OBJECT -DALVIK_SGET_BOOLEAN = _idaapi.DALVIK_SGET_BOOLEAN -DALVIK_SGET_BYTE = _idaapi.DALVIK_SGET_BYTE -DALVIK_SGET_CHAR = _idaapi.DALVIK_SGET_CHAR -DALVIK_SGET_SHORT = _idaapi.DALVIK_SGET_SHORT -DALVIK_SPUT = _idaapi.DALVIK_SPUT -DALVIK_SPUT_WIDE = _idaapi.DALVIK_SPUT_WIDE -DALVIK_SPUT_OBJECT = _idaapi.DALVIK_SPUT_OBJECT -DALVIK_SPUT_BOOLEAN = _idaapi.DALVIK_SPUT_BOOLEAN -DALVIK_SPUT_BYTE = _idaapi.DALVIK_SPUT_BYTE -DALVIK_SPUT_CHAR = _idaapi.DALVIK_SPUT_CHAR -DALVIK_SPUT_SHORT = _idaapi.DALVIK_SPUT_SHORT -DALVIK_INVOKE_VIRTUAL = _idaapi.DALVIK_INVOKE_VIRTUAL -DALVIK_INVOKE_SUPER = _idaapi.DALVIK_INVOKE_SUPER -DALVIK_INVOKE_DIRECT = _idaapi.DALVIK_INVOKE_DIRECT -DALVIK_INVOKE_STATIC = _idaapi.DALVIK_INVOKE_STATIC -DALVIK_INVOKE_INTERFACE = _idaapi.DALVIK_INVOKE_INTERFACE -DALVIK_UNUSED_73 = _idaapi.DALVIK_UNUSED_73 -DALVIK_INVOKE_VIRTUAL_RANGE = _idaapi.DALVIK_INVOKE_VIRTUAL_RANGE -DALVIK_INVOKE_SUPER_RANGE = _idaapi.DALVIK_INVOKE_SUPER_RANGE -DALVIK_INVOKE_DIRECT_RANGE = _idaapi.DALVIK_INVOKE_DIRECT_RANGE -DALVIK_INVOKE_STATIC_RANGE = _idaapi.DALVIK_INVOKE_STATIC_RANGE -DALVIK_INVOKE_INTERFACE_RANGE = _idaapi.DALVIK_INVOKE_INTERFACE_RANGE -DALVIK_UNUSED_79 = _idaapi.DALVIK_UNUSED_79 -DALVIK_UNUSED_7A = _idaapi.DALVIK_UNUSED_7A -DALVIK_NEG_INT = _idaapi.DALVIK_NEG_INT -DALVIK_NOT_INT = _idaapi.DALVIK_NOT_INT -DALVIK_NEG_LONG = _idaapi.DALVIK_NEG_LONG -DALVIK_NOT_LONG = _idaapi.DALVIK_NOT_LONG -DALVIK_NEG_FLOAT = _idaapi.DALVIK_NEG_FLOAT -DALVIK_NEG_DOUBLE = _idaapi.DALVIK_NEG_DOUBLE -DALVIK_INT_TO_LONG = _idaapi.DALVIK_INT_TO_LONG -DALVIK_INT_TO_FLOAT = _idaapi.DALVIK_INT_TO_FLOAT -DALVIK_INT_TO_DOUBLE = _idaapi.DALVIK_INT_TO_DOUBLE -DALVIK_LONG_TO_INT = _idaapi.DALVIK_LONG_TO_INT -DALVIK_LONG_TO_FLOAT = _idaapi.DALVIK_LONG_TO_FLOAT -DALVIK_LONG_TO_DOUBLE = _idaapi.DALVIK_LONG_TO_DOUBLE -DALVIK_FLOAT_TO_INT = _idaapi.DALVIK_FLOAT_TO_INT -DALVIK_FLOAT_TO_LONG = _idaapi.DALVIK_FLOAT_TO_LONG -DALVIK_FLOAT_TO_DOUBLE = _idaapi.DALVIK_FLOAT_TO_DOUBLE -DALVIK_DOUBLE_TO_INT = _idaapi.DALVIK_DOUBLE_TO_INT -DALVIK_DOUBLE_TO_LONG = _idaapi.DALVIK_DOUBLE_TO_LONG -DALVIK_DOUBLE_TO_FLOAT = _idaapi.DALVIK_DOUBLE_TO_FLOAT -DALVIK_INT_TO_BYTE = _idaapi.DALVIK_INT_TO_BYTE -DALVIK_INT_TO_CHAR = _idaapi.DALVIK_INT_TO_CHAR -DALVIK_INT_TO_SHORT = _idaapi.DALVIK_INT_TO_SHORT -DALVIK_ADD_INT = _idaapi.DALVIK_ADD_INT -DALVIK_SUB_INT = _idaapi.DALVIK_SUB_INT -DALVIK_MUL_INT = _idaapi.DALVIK_MUL_INT -DALVIK_DIV_INT = _idaapi.DALVIK_DIV_INT -DALVIK_REM_INT = _idaapi.DALVIK_REM_INT -DALVIK_AND_INT = _idaapi.DALVIK_AND_INT -DALVIK_OR_INT = _idaapi.DALVIK_OR_INT -DALVIK_XOR_INT = _idaapi.DALVIK_XOR_INT -DALVIK_SHL_INT = _idaapi.DALVIK_SHL_INT -DALVIK_SHR_INT = _idaapi.DALVIK_SHR_INT -DALVIK_USHR_INT = _idaapi.DALVIK_USHR_INT -DALVIK_ADD_LONG = _idaapi.DALVIK_ADD_LONG -DALVIK_SUB_LONG = _idaapi.DALVIK_SUB_LONG -DALVIK_MUL_LONG = _idaapi.DALVIK_MUL_LONG -DALVIK_DIV_LONG = _idaapi.DALVIK_DIV_LONG -DALVIK_REM_LONG = _idaapi.DALVIK_REM_LONG -DALVIK_AND_LONG = _idaapi.DALVIK_AND_LONG -DALVIK_OR_LONG = _idaapi.DALVIK_OR_LONG -DALVIK_XOR_LONG = _idaapi.DALVIK_XOR_LONG -DALVIK_SHL_LONG = _idaapi.DALVIK_SHL_LONG -DALVIK_SHR_LONG = _idaapi.DALVIK_SHR_LONG -DALVIK_USHR_LONG = _idaapi.DALVIK_USHR_LONG -DALVIK_ADD_FLOAT = _idaapi.DALVIK_ADD_FLOAT -DALVIK_SUB_FLOAT = _idaapi.DALVIK_SUB_FLOAT -DALVIK_MUL_FLOAT = _idaapi.DALVIK_MUL_FLOAT -DALVIK_DIV_FLOAT = _idaapi.DALVIK_DIV_FLOAT -DALVIK_REM_FLOAT = _idaapi.DALVIK_REM_FLOAT -DALVIK_ADD_DOUBLE = _idaapi.DALVIK_ADD_DOUBLE -DALVIK_SUB_DOUBLE = _idaapi.DALVIK_SUB_DOUBLE -DALVIK_MUL_DOUBLE = _idaapi.DALVIK_MUL_DOUBLE -DALVIK_DIV_DOUBLE = _idaapi.DALVIK_DIV_DOUBLE -DALVIK_REM_DOUBLE = _idaapi.DALVIK_REM_DOUBLE -DALVIK_ADD_INT_2ADDR = _idaapi.DALVIK_ADD_INT_2ADDR -DALVIK_SUB_INT_2ADDR = _idaapi.DALVIK_SUB_INT_2ADDR -DALVIK_MUL_INT_2ADDR = _idaapi.DALVIK_MUL_INT_2ADDR -DALVIK_DIV_INT_2ADDR = _idaapi.DALVIK_DIV_INT_2ADDR -DALVIK_REM_INT_2ADDR = _idaapi.DALVIK_REM_INT_2ADDR -DALVIK_AND_INT_2ADDR = _idaapi.DALVIK_AND_INT_2ADDR -DALVIK_OR_INT_2ADDR = _idaapi.DALVIK_OR_INT_2ADDR -DALVIK_XOR_INT_2ADDR = _idaapi.DALVIK_XOR_INT_2ADDR -DALVIK_SHL_INT_2ADDR = _idaapi.DALVIK_SHL_INT_2ADDR -DALVIK_SHR_INT_2ADDR = _idaapi.DALVIK_SHR_INT_2ADDR -DALVIK_USHR_INT_2ADDR = _idaapi.DALVIK_USHR_INT_2ADDR -DALVIK_ADD_LONG_2ADDR = _idaapi.DALVIK_ADD_LONG_2ADDR -DALVIK_SUB_LONG_2ADDR = _idaapi.DALVIK_SUB_LONG_2ADDR -DALVIK_MUL_LONG_2ADDR = _idaapi.DALVIK_MUL_LONG_2ADDR -DALVIK_DIV_LONG_2ADDR = _idaapi.DALVIK_DIV_LONG_2ADDR -DALVIK_REM_LONG_2ADDR = _idaapi.DALVIK_REM_LONG_2ADDR -DALVIK_AND_LONG_2ADDR = _idaapi.DALVIK_AND_LONG_2ADDR -DALVIK_OR_LONG_2ADDR = _idaapi.DALVIK_OR_LONG_2ADDR -DALVIK_XOR_LONG_2ADDR = _idaapi.DALVIK_XOR_LONG_2ADDR -DALVIK_SHL_LONG_2ADDR = _idaapi.DALVIK_SHL_LONG_2ADDR -DALVIK_SHR_LONG_2ADDR = _idaapi.DALVIK_SHR_LONG_2ADDR -DALVIK_USHR_LONG_2ADDR = _idaapi.DALVIK_USHR_LONG_2ADDR -DALVIK_ADD_FLOAT_2ADDR = _idaapi.DALVIK_ADD_FLOAT_2ADDR -DALVIK_SUB_FLOAT_2ADDR = _idaapi.DALVIK_SUB_FLOAT_2ADDR -DALVIK_MUL_FLOAT_2ADDR = _idaapi.DALVIK_MUL_FLOAT_2ADDR -DALVIK_DIV_FLOAT_2ADDR = _idaapi.DALVIK_DIV_FLOAT_2ADDR -DALVIK_REM_FLOAT_2ADDR = _idaapi.DALVIK_REM_FLOAT_2ADDR -DALVIK_ADD_DOUBLE_2ADDR = _idaapi.DALVIK_ADD_DOUBLE_2ADDR -DALVIK_SUB_DOUBLE_2ADDR = _idaapi.DALVIK_SUB_DOUBLE_2ADDR -DALVIK_MUL_DOUBLE_2ADDR = _idaapi.DALVIK_MUL_DOUBLE_2ADDR -DALVIK_DIV_DOUBLE_2ADDR = _idaapi.DALVIK_DIV_DOUBLE_2ADDR -DALVIK_REM_DOUBLE_2ADDR = _idaapi.DALVIK_REM_DOUBLE_2ADDR -DALVIK_ADD_INT_LIT16 = _idaapi.DALVIK_ADD_INT_LIT16 -DALVIK_RSUB_INT = _idaapi.DALVIK_RSUB_INT -DALVIK_MUL_INT_LIT16 = _idaapi.DALVIK_MUL_INT_LIT16 -DALVIK_DIV_INT_LIT16 = _idaapi.DALVIK_DIV_INT_LIT16 -DALVIK_REM_INT_LIT16 = _idaapi.DALVIK_REM_INT_LIT16 -DALVIK_AND_INT_LIT16 = _idaapi.DALVIK_AND_INT_LIT16 -DALVIK_OR_INT_LIT16 = _idaapi.DALVIK_OR_INT_LIT16 -DALVIK_XOR_INT_LIT16 = _idaapi.DALVIK_XOR_INT_LIT16 -DALVIK_ADD_INT_LIT8 = _idaapi.DALVIK_ADD_INT_LIT8 -DALVIK_RSUB_INT_LIT8 = _idaapi.DALVIK_RSUB_INT_LIT8 -DALVIK_MUL_INT_LIT8 = _idaapi.DALVIK_MUL_INT_LIT8 -DALVIK_DIV_INT_LIT8 = _idaapi.DALVIK_DIV_INT_LIT8 -DALVIK_REM_INT_LIT8 = _idaapi.DALVIK_REM_INT_LIT8 -DALVIK_AND_INT_LIT8 = _idaapi.DALVIK_AND_INT_LIT8 -DALVIK_OR_INT_LIT8 = _idaapi.DALVIK_OR_INT_LIT8 -DALVIK_XOR_INT_LIT8 = _idaapi.DALVIK_XOR_INT_LIT8 -DALVIK_SHL_INT_LIT8 = _idaapi.DALVIK_SHL_INT_LIT8 -DALVIK_SHR_INT_LIT8 = _idaapi.DALVIK_SHR_INT_LIT8 -DALVIK_USHR_INT_LIT8 = _idaapi.DALVIK_USHR_INT_LIT8 -DALVIK_IGET_VOLATILE = _idaapi.DALVIK_IGET_VOLATILE -DALVIK_IPUT_VOLATILE = _idaapi.DALVIK_IPUT_VOLATILE -DALVIK_SGET_VOLATILE = _idaapi.DALVIK_SGET_VOLATILE -DALVIK_SPUT_VOLATILE = _idaapi.DALVIK_SPUT_VOLATILE -DALVIK_IGET_OBJECT_VOLATILE = _idaapi.DALVIK_IGET_OBJECT_VOLATILE -DALVIK_IGET_WIDE_VOLATILE = _idaapi.DALVIK_IGET_WIDE_VOLATILE -DALVIK_IPUT_WIDE_VOLATILE = _idaapi.DALVIK_IPUT_WIDE_VOLATILE -DALVIK_SGET_WIDE_VOLATILE = _idaapi.DALVIK_SGET_WIDE_VOLATILE -DALVIK_SPUT_WIDE_VOLATILE = _idaapi.DALVIK_SPUT_WIDE_VOLATILE -DALVIK_BREAKPOINT = _idaapi.DALVIK_BREAKPOINT -DALVIK_THROW_VERIFICATION_ERROR = _idaapi.DALVIK_THROW_VERIFICATION_ERROR -DALVIK_EXECUTE_INLINE = _idaapi.DALVIK_EXECUTE_INLINE -DALVIK_EXECUTE_INLINE_RANGE = _idaapi.DALVIK_EXECUTE_INLINE_RANGE -DALVIK_INVOKE_DIRECT_EMPTY = _idaapi.DALVIK_INVOKE_DIRECT_EMPTY -DALVIK_RETURN_VOID_BARRIER = _idaapi.DALVIK_RETURN_VOID_BARRIER -DALVIK_IGET_QUICK = _idaapi.DALVIK_IGET_QUICK -DALVIK_IGET_WIDE_QUICK = _idaapi.DALVIK_IGET_WIDE_QUICK -DALVIK_IGET_OBJECT_QUICK = _idaapi.DALVIK_IGET_OBJECT_QUICK -DALVIK_IPUT_QUICK = _idaapi.DALVIK_IPUT_QUICK -DALVIK_IPUT_WIDE_QUICK = _idaapi.DALVIK_IPUT_WIDE_QUICK -DALVIK_IPUT_OBJECT_QUICK = _idaapi.DALVIK_IPUT_OBJECT_QUICK -DALVIK_INVOKE_VIRTUAL_QUICK = _idaapi.DALVIK_INVOKE_VIRTUAL_QUICK -DALVIK_INVOKE_VIRTUAL_QUICK_RANGE = _idaapi.DALVIK_INVOKE_VIRTUAL_QUICK_RANGE -DALVIK_INVOKE_SUPER_QUICK = _idaapi.DALVIK_INVOKE_SUPER_QUICK -DALVIK_INVOKE_SUPER_QUICK_RANGE = _idaapi.DALVIK_INVOKE_SUPER_QUICK_RANGE -DALVIK_IPUT_OBJECT_VOLATILE = _idaapi.DALVIK_IPUT_OBJECT_VOLATILE -DALVIK_SGET_OBJECT_VOLATILE = _idaapi.DALVIK_SGET_OBJECT_VOLATILE -DALVIK_SPUT_OBJECT_VOLATILE = _idaapi.DALVIK_SPUT_OBJECT_VOLATILE -DALVIK_UNUSED_FF = _idaapi.DALVIK_UNUSED_FF -DALVIK_LAST = _idaapi.DALVIK_LAST class area_t(object): - """Proxy of C++ area_t class""" + """ + Proxy of C++ area_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr startEA = _swig_property(_idaapi.area_t_startEA_get, _idaapi.area_t_startEA_set) endEA = _swig_property(_idaapi.area_t_endEA_get, _idaapi.area_t_endEA_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> area_t __init__(self, ea1, ea2) -> area_t @@ -20662,23 +20736,33 @@ class area_t(object): try: self.this.append(this) except: self.this = this def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.area_t_compare(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.area_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.area_t___ne__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.area_t___gt__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.area_t___lt__(self, *args) def contains(self, *args): @@ -20689,31 +20773,45 @@ class area_t(object): return _idaapi.area_t_contains(self, *args) def overlaps(self, *args): - """overlaps(self, r) -> bool""" + """ + overlaps(self, r) -> bool + """ return _idaapi.area_t_overlaps(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.area_t_clear(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.area_t_empty(self, *args) def size(self, *args): - """size(self) -> asize_t""" + """ + size(self) -> asize_t + """ return _idaapi.area_t_size(self, *args) def intersect(self, *args): - """intersect(self, r)""" + """ + intersect(self, r) + """ return _idaapi.area_t_intersect(self, *args) def extend(self, *args): - """extend(self, ea)""" + """ + extend(self, ea) + """ return _idaapi.area_t_extend(self, *args) def _print(self, *args): - """_print(self) -> size_t""" + """ + _print(self) -> size_t + """ return _idaapi.area_t__print(self, *args) __swig_destroy__ = _idaapi.delete_area_t @@ -20722,15 +20820,21 @@ area_t_swigregister = _idaapi.area_t_swigregister area_t_swigregister(area_t) def area_t_print(*args): - """area_t_print(cb) -> size_t""" + """ + area_t_print(cb) -> size_t + """ return _idaapi.area_t_print(*args) class areavec_t(object): - """Proxy of C++ areavec_t class""" + """ + Proxy of C++ areavec_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> areavec_t""" + def __init__(self, *args): + """ + __init__(self) -> areavec_t + """ this = _idaapi.new_areavec_t(*args) try: self.this.append(this) except: self.this = this @@ -20740,10 +20844,12 @@ areavec_t_swigregister = _idaapi.areavec_t_swigregister areavec_t_swigregister(areavec_t) class areaset_t(object): - """Proxy of C++ areaset_t class""" + """ + Proxy of C++ areaset_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> areaset_t __init__(self, area) -> areaset_t @@ -20753,7 +20859,9 @@ class areaset_t(object): try: self.this.append(this) except: self.this = this def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.areaset_t_swap(self, *args) def add(self, *args): @@ -20766,38 +20874,52 @@ class areaset_t(object): def sub(self, *args): """ - sub(self, area) -> bool sub(self, ea) -> bool + sub(self, area) -> bool sub(self, aset) -> bool """ return _idaapi.areaset_t_sub(self, *args) def includes(self, *args): - """includes(self, area) -> bool""" + """ + includes(self, area) -> bool + """ return _idaapi.areaset_t_includes(self, *args) def _print(self, *args): - """_print(self) -> size_t""" + """ + _print(self) -> size_t + """ return _idaapi.areaset_t__print(self, *args) def getarea(self, *args): - """getarea(self, idx) -> area_t""" + """ + getarea(self, idx) -> area_t + """ return _idaapi.areaset_t_getarea(self, *args) def lastarea(self, *args): - """lastarea(self) -> area_t""" + """ + lastarea(self) -> area_t + """ return _idaapi.areaset_t_lastarea(self, *args) def nareas(self, *args): - """nareas(self) -> size_t""" + """ + nareas(self) -> size_t + """ return _idaapi.areaset_t_nareas(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.areaset_t_empty(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.areaset_t_clear(self, *args) def has_common(self, *args): @@ -20815,23 +20937,33 @@ class areaset_t(object): return _idaapi.areaset_t_contains(self, *args) def intersect(self, *args): - """intersect(self, aset) -> bool""" + """ + intersect(self, aset) -> bool + """ return _idaapi.areaset_t_intersect(self, *args) def is_subset_of(self, *args): - """is_subset_of(self, aset) -> bool""" + """ + is_subset_of(self, aset) -> bool + """ return _idaapi.areaset_t_is_subset_of(self, *args) def is_equal(self, *args): - """is_equal(self, aset) -> bool""" + """ + is_equal(self, aset) -> bool + """ return _idaapi.areaset_t_is_equal(self, *args) def __eq__(self, *args): - """__eq__(self, aset) -> bool""" + """ + __eq__(self, aset) -> bool + """ return _idaapi.areaset_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, aset) -> bool""" + """ + __ne__(self, aset) -> bool + """ return _idaapi.areaset_t___ne__(self, *args) def begin(self, *args): @@ -20849,27 +20981,39 @@ class areaset_t(object): return _idaapi.areaset_t_end(self, *args) def find_area(self, *args): - """find_area(self, ea) -> area_t""" + """ + find_area(self, ea) -> area_t + """ return _idaapi.areaset_t_find_area(self, *args) def cached_area(self, *args): - """cached_area(self) -> area_t""" + """ + cached_area(self) -> area_t + """ return _idaapi.areaset_t_cached_area(self, *args) def next_addr(self, *args): - """next_addr(self, ea) -> ea_t""" + """ + next_addr(self, ea) -> ea_t + """ return _idaapi.areaset_t_next_addr(self, *args) def prev_addr(self, *args): - """prev_addr(self, ea) -> ea_t""" + """ + prev_addr(self, ea) -> ea_t + """ return _idaapi.areaset_t_prev_addr(self, *args) def next_area(self, *args): - """next_area(self, ea) -> ea_t""" + """ + next_area(self, ea) -> ea_t + """ return _idaapi.areaset_t_next_area(self, *args) def prev_area(self, *args): - """prev_area(self, ea) -> ea_t""" + """ + prev_area(self, ea) -> ea_t + """ return _idaapi.areaset_t_prev_area(self, *args) __swig_destroy__ = _idaapi.delete_areaset_t @@ -20878,12 +21022,16 @@ areaset_t_swigregister = _idaapi.areaset_t_swigregister areaset_t_swigregister(areaset_t) class area_visitor2_t(object): - """Proxy of C++ area_visitor2_t class""" + """ + Proxy of C++ area_visitor2_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr def visit_area(self, *args): - """visit_area(self, a) -> int""" + """ + visit_area(self, a) -> int + """ return _idaapi.area_visitor2_t_visit_area(self, *args) __swig_destroy__ = _idaapi.delete_area_visitor2_t @@ -20892,157 +21040,231 @@ area_visitor2_t_swigregister = _idaapi.area_visitor2_t_swigregister area_visitor2_t_swigregister(area_visitor2_t) class areacb_t(object): - """Proxy of C++ areacb_t class""" + """ + Proxy of C++ areacb_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def zero(self, *args): - """zero(self)""" + """ + zero(self) + """ return _idaapi.areacb_t_zero(self, *args) - def __init__(self, *args): - """__init__(self) -> areacb_t""" + def __init__(self, *args): + """ + __init__(self) -> areacb_t + """ this = _idaapi.new_areacb_t(*args) try: self.this.append(this) except: self.this = this def terminate(self, *args): - """terminate(self)""" + """ + terminate(self) + """ return _idaapi.areacb_t_terminate(self, *args) __swig_destroy__ = _idaapi.delete_areacb_t __del__ = lambda self : None; def get_netnode(self, *args): - """get_netnode(self) -> uval_t""" + """ + get_netnode(self) -> uval_t + """ return _idaapi.areacb_t_get_netnode(self, *args) def save(self, *args): - """save(self)""" + """ + save(self) + """ return _idaapi.areacb_t_save(self, *args) def link(self, *args): - """link(self, file, name, _infosize) -> bool""" + """ + link(self, file, name, _infosize) -> bool + """ return _idaapi.areacb_t_link(self, *args) def create(self, *args): - """create(self, file, name, _infosize) -> bool""" + """ + create(self, file, name, _infosize) -> bool + """ return _idaapi.areacb_t_create(self, *args) def kill(self, *args): - """kill(self)""" + """ + kill(self) + """ return _idaapi.areacb_t_kill(self, *args) def create_area(self, *args): - """create_area(self, info) -> bool""" + """ + create_area(self, info) -> bool + """ return _idaapi.areacb_t_create_area(self, *args) def update(self, *args): - """update(self, info) -> bool""" + """ + update(self, info) -> bool + """ return _idaapi.areacb_t_update(self, *args) def get_area(self, *args): - """get_area(self, ea) -> area_t""" + """ + get_area(self, ea) -> area_t + """ return _idaapi.areacb_t_get_area(self, *args) def getn_area(self, *args): - """getn_area(self, n) -> area_t""" + """ + getn_area(self, n) -> area_t + """ return _idaapi.areacb_t_getn_area(self, *args) def get_area_num(self, *args): - """get_area_num(self, ea) -> int""" + """ + get_area_num(self, ea) -> int + """ return _idaapi.areacb_t_get_area_num(self, *args) def prepare_to_create(self, *args): - """prepare_to_create(self, start, end) -> ea_t""" + """ + prepare_to_create(self, start, end) -> ea_t + """ return _idaapi.areacb_t_prepare_to_create(self, *args) def get_next_area(self, *args): - """get_next_area(self, ea) -> int""" + """ + get_next_area(self, ea) -> int + """ return _idaapi.areacb_t_get_next_area(self, *args) def get_prev_area(self, *args): - """get_prev_area(self, ea) -> int""" + """ + get_prev_area(self, ea) -> int + """ return _idaapi.areacb_t_get_prev_area(self, *args) def next_area_ptr(self, *args): - """next_area_ptr(self, ea) -> area_t""" + """ + next_area_ptr(self, ea) -> area_t + """ return _idaapi.areacb_t_next_area_ptr(self, *args) def prev_area_ptr(self, *args): - """prev_area_ptr(self, ea) -> area_t""" + """ + prev_area_ptr(self, ea) -> area_t + """ return _idaapi.areacb_t_prev_area_ptr(self, *args) def first_area_ptr(self, *args): - """first_area_ptr(self) -> area_t""" + """ + first_area_ptr(self) -> area_t + """ return _idaapi.areacb_t_first_area_ptr(self, *args) def last_area_ptr(self, *args): - """last_area_ptr(self) -> area_t""" + """ + last_area_ptr(self) -> area_t + """ return _idaapi.areacb_t_last_area_ptr(self, *args) def del_area(self, *args): - """del_area(self, ea, delcmt=True) -> bool""" + """ + del_area(self, ea, delcmt=True) -> bool + """ return _idaapi.areacb_t_del_area(self, *args) def may_start_at(self, *args): - """may_start_at(self, n, newstart) -> bool""" + """ + may_start_at(self, n, newstart) -> bool + """ return _idaapi.areacb_t_may_start_at(self, *args) def may_end_at(self, *args): - """may_end_at(self, n, newend) -> bool""" + """ + may_end_at(self, n, newend) -> bool + """ return _idaapi.areacb_t_may_end_at(self, *args) def set_start(self, *args): - """set_start(self, n, newstart) -> bool""" + """ + set_start(self, n, newstart) -> bool + """ return _idaapi.areacb_t_set_start(self, *args) def set_end(self, *args): - """set_end(self, n, newend) -> bool""" + """ + set_end(self, n, newend) -> bool + """ return _idaapi.areacb_t_set_end(self, *args) def make_hole(self, *args): - """make_hole(self, ea1, ea2, create_tail_area)""" + """ + make_hole(self, ea1, ea2, create_tail_area) + """ return _idaapi.areacb_t_make_hole(self, *args) def resize_areas(self, *args): - """resize_areas(self, n, newstart) -> bool""" + """ + resize_areas(self, n, newstart) -> bool + """ return _idaapi.areacb_t_resize_areas(self, *args) def get_area_qty(self, *args): - """get_area_qty(self) -> uint""" + """ + get_area_qty(self) -> uint + """ return _idaapi.areacb_t_get_area_qty(self, *args) def set_area_cmt(self, *args): - """set_area_cmt(self, a, cmt, repeatable) -> bool""" + """ + set_area_cmt(self, a, cmt, repeatable) -> bool + """ return _idaapi.areacb_t_set_area_cmt(self, *args) def del_area_cmt(self, *args): - """del_area_cmt(self, a, repeatable)""" + """ + del_area_cmt(self, a, repeatable) + """ return _idaapi.areacb_t_del_area_cmt(self, *args) def get_area_cmt(self, *args): - """get_area_cmt(self, a, repeatable) -> char *""" + """ + get_area_cmt(self, a, repeatable) -> char * + """ return _idaapi.areacb_t_get_area_cmt(self, *args) def for_all_areas2(self, *args): - """for_all_areas2(self, ea1, ea2, av) -> int""" + """ + for_all_areas2(self, ea1, ea2, av) -> int + """ return _idaapi.areacb_t_for_all_areas2(self, *args) def may_lock_area(self, *args): - """may_lock_area(self, a) -> bool""" + """ + may_lock_area(self, a) -> bool + """ return _idaapi.areacb_t_may_lock_area(self, *args) def get_type(self, *args): - """get_type(self) -> areacb_type_t""" + """ + get_type(self) -> areacb_type_t + """ return _idaapi.areacb_t_get_type(self, *args) areacb_t_swigregister = _idaapi.areacb_t_swigregister areacb_t_swigregister(areacb_t) class lock_area(object): - """Proxy of C++ lock_area class""" + """ + Proxy of C++ lock_area class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, _cb, _area) -> lock_area""" + def __init__(self, *args): + """ + __init__(self, _cb, _area) -> lock_area + """ this = _idaapi.new_lock_area(*args) try: self.this.append(this) except: self.this = this @@ -21052,14 +21274,18 @@ lock_area_swigregister = _idaapi.lock_area_swigregister lock_area_swigregister(lock_area) class auto_display_t(object): - """Proxy of C++ auto_display_t class""" + """ + Proxy of C++ auto_display_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr type = _swig_property(_idaapi.auto_display_t_type_get, _idaapi.auto_display_t_type_set) ea = _swig_property(_idaapi.auto_display_t_ea_get, _idaapi.auto_display_t_ea_set) state = _swig_property(_idaapi.auto_display_t_state_get, _idaapi.auto_display_t_state_set) - def __init__(self, *args): - """__init__(self) -> auto_display_t""" + def __init__(self, *args): + """ + __init__(self) -> auto_display_t + """ this = _idaapi.new_auto_display_t(*args) try: self.this.append(this) except: self.this = this @@ -21088,35 +21314,51 @@ st_Work = cvar.st_Work def showAuto(*args): - """showAuto(ea, type=AU_NONE)""" + """ + showAuto(ea, type=AU_NONE) + """ return _idaapi.showAuto(*args) def showAddr(*args): - """showAddr(ea)""" + """ + showAddr(ea) + """ return _idaapi.showAddr(*args) def setStat(*args): - """setStat(st) -> idastate_t""" + """ + setStat(st) -> idastate_t + """ return _idaapi.setStat(*args) def may_create_stkvars(*args): - """may_create_stkvars() -> bool""" + """ + may_create_stkvars() -> bool + """ return _idaapi.may_create_stkvars(*args) def may_trace_sp(*args): - """may_trace_sp() -> bool""" + """ + may_trace_sp() -> bool + """ return _idaapi.may_trace_sp(*args) def auto_mark_range(*args): - """auto_mark_range(start, end, type)""" + """ + auto_mark_range(start, end, type) + """ return _idaapi.auto_mark_range(*args) def autoMark(*args): - """autoMark(ea, type)""" + """ + autoMark(ea, type) + """ return _idaapi.autoMark(*args) def autoUnmark(*args): - """autoUnmark(start, end, type)""" + """ + autoUnmark(start, end, type) + """ return _idaapi.autoUnmark(*args) def noUsed(*args): @@ -21127,322 +21369,460 @@ def noUsed(*args): return _idaapi.noUsed(*args) def auto_make_code(*args): - """auto_make_code(ea)""" + """ + auto_make_code(ea) + """ return _idaapi.auto_make_code(*args) def auto_make_proc(*args): - """auto_make_proc(ea)""" + """ + auto_make_proc(ea) + """ return _idaapi.auto_make_proc(*args) def reanalyze_callers(*args): - """reanalyze_callers(ea, noret)""" + """ + reanalyze_callers(ea, noret) + """ return _idaapi.reanalyze_callers(*args) -def revert_ida_decisions(*args): - """revert_ida_decisions(ea1, ea2)""" - return _idaapi.revert_ida_decisions(*args) - def auto_apply_type(*args): - """auto_apply_type(caller, callee)""" + """ + auto_apply_type(caller, callee) + """ return _idaapi.auto_apply_type(*args) def analyze_area(*args): - """analyze_area(sEA, eEA) -> int""" + """ + analyze_area(sEA, eEA) -> int + """ return _idaapi.analyze_area(*args) def autoWait(*args): - """autoWait() -> bool""" + """ + autoWait() -> bool + """ return _idaapi.autoWait(*args) def autoCancel(*args): - """autoCancel(ea1, ea2)""" + """ + autoCancel(ea1, ea2) + """ return _idaapi.autoCancel(*args) def autoIsOk(*args): - """autoIsOk() -> bool""" + """ + autoIsOk() -> bool + """ return _idaapi.autoIsOk(*args) def autoStep(*args): - """autoStep() -> bool""" + """ + autoStep() -> bool + """ return _idaapi.autoStep(*args) def peek_auto_queue(*args): - """peek_auto_queue(low_ea, type) -> ea_t""" + """ + peek_auto_queue(low_ea, type) -> ea_t + """ return _idaapi.peek_auto_queue(*args) def auto_get(*args): - """auto_get(lowEA, highEA, type) -> ea_t""" + """ + auto_get(lowEA, highEA, type) -> ea_t + """ return _idaapi.auto_get(*args) def autoGetName(*args): - """autoGetName(type) -> char const *""" + """ + autoGetName(type) -> char const * + """ return _idaapi.autoGetName(*args) def enable_flags(*args): - """enable_flags(startEA, endEA, stt) -> error_t""" + """ + enable_flags(startEA, endEA, stt) -> error_t + """ return _idaapi.enable_flags(*args) def disable_flags(*args): - """disable_flags(startEA, endEA) -> error_t""" + """ + disable_flags(startEA, endEA) -> error_t + """ return _idaapi.disable_flags(*args) def change_storage_type(*args): - """change_storage_type(startEA, endEA, stt) -> error_t""" + """ + change_storage_type(startEA, endEA, stt) -> error_t + """ return _idaapi.change_storage_type(*args) def nextaddr(*args): - """nextaddr(ea) -> ea_t""" + """ + nextaddr(ea) -> ea_t + """ return _idaapi.nextaddr(*args) def prevaddr(*args): - """prevaddr(ea) -> ea_t""" + """ + prevaddr(ea) -> ea_t + """ return _idaapi.prevaddr(*args) def nextchunk(*args): - """nextchunk(ea) -> ea_t""" + """ + nextchunk(ea) -> ea_t + """ return _idaapi.nextchunk(*args) def prevchunk(*args): - """prevchunk(ea) -> ea_t""" + """ + prevchunk(ea) -> ea_t + """ return _idaapi.prevchunk(*args) def chunkstart(*args): - """chunkstart(ea) -> ea_t""" + """ + chunkstart(ea) -> ea_t + """ return _idaapi.chunkstart(*args) def chunksize(*args): - """chunksize(ea) -> asize_t""" + """ + chunksize(ea) -> asize_t + """ return _idaapi.chunksize(*args) def freechunk(*args): - """freechunk(bottom, size, step) -> ea_t""" + """ + freechunk(bottom, size, step) -> ea_t + """ return _idaapi.freechunk(*args) def next_unknown(*args): - """next_unknown(ea, maxea) -> ea_t""" + """ + next_unknown(ea, maxea) -> ea_t + """ return _idaapi.next_unknown(*args) def prev_unknown(*args): - """prev_unknown(ea, minea) -> ea_t""" + """ + prev_unknown(ea, minea) -> ea_t + """ return _idaapi.prev_unknown(*args) def prev_head(*args): - """prev_head(ea, minea) -> ea_t""" + """ + prev_head(ea, minea) -> ea_t + """ return _idaapi.prev_head(*args) def next_head(*args): - """next_head(ea, maxea) -> ea_t""" + """ + next_head(ea, maxea) -> ea_t + """ return _idaapi.next_head(*args) def prev_not_tail(*args): - """prev_not_tail(ea) -> ea_t""" + """ + prev_not_tail(ea) -> ea_t + """ return _idaapi.prev_not_tail(*args) def next_not_tail(*args): - """next_not_tail(ea) -> ea_t""" + """ + next_not_tail(ea) -> ea_t + """ return _idaapi.next_not_tail(*args) def get_item_head(*args): - """get_item_head(ea) -> ea_t""" + """ + get_item_head(ea) -> ea_t + """ return _idaapi.get_item_head(*args) def get_item_end(*args): - """get_item_end(ea) -> ea_t""" + """ + get_item_end(ea) -> ea_t + """ return _idaapi.get_item_end(*args) - -def calc_max_item_end(*args): - """calc_max_item_end(ea, how=15) -> ea_t""" - return _idaapi.calc_max_item_end(*args) ITEM_END_FIXUP = _idaapi.ITEM_END_FIXUP ITEM_END_INITED = _idaapi.ITEM_END_INITED ITEM_END_NAME = _idaapi.ITEM_END_NAME ITEM_END_XREF = _idaapi.ITEM_END_XREF +def calc_max_item_end(*args): + """ + calc_max_item_end(ea, how=15) -> ea_t + """ + return _idaapi.calc_max_item_end(*args) + def get_item_size(*args): - """get_item_size(ea) -> asize_t""" + """ + get_item_size(ea) -> asize_t + """ return _idaapi.get_item_size(*args) def isEnabled(*args): - """isEnabled(ea) -> bool""" + """ + isEnabled(ea) -> bool + """ return _idaapi.isEnabled(*args) def get_flags_ex(*args): - """get_flags_ex(ea, how) -> flags_t""" + """ + get_flags_ex(ea, how) -> flags_t + """ return _idaapi.get_flags_ex(*args) GFE_NOVALUE = _idaapi.GFE_NOVALUE def get_flags_novalue(*args): - """get_flags_novalue(ea) -> flags_t""" + """ + get_flags_novalue(ea) -> flags_t + """ return _idaapi.get_flags_novalue(*args) def getFlags(*args): - """getFlags(ea) -> flags_t""" + """ + getFlags(ea) -> flags_t + """ return _idaapi.getFlags(*args) def get_item_flag(*args): - """get_item_flag(frm, n, ea, appzero) -> flags_t""" + """ + get_item_flag(frm, n, ea, appzero) -> flags_t + """ return _idaapi.get_item_flag(*args) def setFlags(*args): - """setFlags(ea, flags)""" + """ + setFlags(ea, flags) + """ return _idaapi.setFlags(*args) MS_VAL = _idaapi.MS_VAL FF_IVL = _idaapi.FF_IVL def hasValue(*args): - """hasValue(F) -> bool""" + """ + hasValue(F) -> bool + """ return _idaapi.hasValue(*args) def f_hasValue(*args): - """f_hasValue(f, arg2) -> bool""" + """ + f_hasValue(f, arg2) -> bool + """ return _idaapi.f_hasValue(*args) def delValue(*args): - """delValue(ea)""" + """ + delValue(ea) + """ return _idaapi.delValue(*args) def isLoaded(*args): - """isLoaded(ea) -> bool""" + """ + isLoaded(ea) -> bool + """ return _idaapi.isLoaded(*args) def nbits(*args): - """nbits(ea) -> int""" + """ + nbits(ea) -> int + """ return _idaapi.nbits(*args) def bytesize(*args): - """bytesize(ea) -> int""" + """ + bytesize(ea) -> int + """ return _idaapi.bytesize(*args) def get_byte(*args): - """get_byte(ea) -> uchar""" + """ + get_byte(ea) -> uchar + """ return _idaapi.get_byte(*args) def get_db_byte(*args): - """get_db_byte(ea) -> uchar""" + """ + get_db_byte(ea) -> uchar + """ return _idaapi.get_db_byte(*args) def get_word(*args): - """get_word(ea) -> ushort""" + """ + get_word(ea) -> ushort + """ return _idaapi.get_word(*args) def get_3byte(*args): - """get_3byte(ea) -> uint32""" + """ + get_3byte(ea) -> uint32 + """ return _idaapi.get_3byte(*args) def get_long(*args): - """get_long(ea) -> uint32""" + """ + get_long(ea) -> uint32 + """ return _idaapi.get_long(*args) def get_qword(*args): - """get_qword(ea) -> uint64""" + """ + get_qword(ea) -> uint64 + """ return _idaapi.get_qword(*args) def get_full_byte(*args): - """get_full_byte(ea) -> uint32""" + """ + get_full_byte(ea) -> uint32 + """ return _idaapi.get_full_byte(*args) def get_full_word(*args): - """get_full_word(ea) -> uint64""" + """ + get_full_word(ea) -> uint64 + """ return _idaapi.get_full_word(*args) def get_full_long(*args): - """get_full_long(ea) -> uint64""" + """ + get_full_long(ea) -> uint64 + """ return _idaapi.get_full_long(*args) def get_16bit(*args): - """get_16bit(ea) -> uint32""" + """ + get_16bit(ea) -> uint32 + """ return _idaapi.get_16bit(*args) def get_32bit(*args): - """get_32bit(ea) -> uint32""" + """ + get_32bit(ea) -> uint32 + """ return _idaapi.get_32bit(*args) def get_64bit(*args): - """get_64bit(ea) -> uint64""" + """ + get_64bit(ea) -> uint64 + """ return _idaapi.get_64bit(*args) def get_data_value(*args): - """get_data_value(ea, v, size) -> bool""" + """ + get_data_value(ea, v, size) -> bool + """ return _idaapi.get_data_value(*args) def get_original_byte(*args): - """get_original_byte(ea) -> uint32""" + """ + get_original_byte(ea) -> uint32 + """ return _idaapi.get_original_byte(*args) def get_original_word(*args): - """get_original_word(ea) -> uint64""" + """ + get_original_word(ea) -> uint64 + """ return _idaapi.get_original_word(*args) def get_original_long(*args): - """get_original_long(ea) -> uint64""" + """ + get_original_long(ea) -> uint64 + """ return _idaapi.get_original_long(*args) -def get_original_qword(*args): - """get_original_qword(ea) -> uint64""" - return _idaapi.get_original_qword(*args) - def put_byte(*args): - """put_byte(ea, x) -> bool""" + """ + put_byte(ea, x) -> bool + """ return _idaapi.put_byte(*args) def put_word(*args): - """put_word(ea, x)""" + """ + put_word(ea, x) + """ return _idaapi.put_word(*args) def put_long(*args): - """put_long(ea, x)""" + """ + put_long(ea, x) + """ return _idaapi.put_long(*args) def put_qword(*args): - """put_qword(ea, x)""" + """ + put_qword(ea, x) + """ return _idaapi.put_qword(*args) def patch_byte(*args): - """patch_byte(ea, x) -> bool""" + """ + patch_byte(ea, x) -> bool + """ return _idaapi.patch_byte(*args) def patch_word(*args): - """patch_word(ea, x) -> bool""" + """ + patch_word(ea, x) -> bool + """ return _idaapi.patch_word(*args) def patch_long(*args): - """patch_long(ea, x) -> bool""" + """ + patch_long(ea, x) -> bool + """ return _idaapi.patch_long(*args) -def patch_qword(*args): - """patch_qword(ea, x) -> bool""" - return _idaapi.patch_qword(*args) - def add_byte(*args): - """add_byte(ea, value)""" + """ + add_byte(ea, value) + """ return _idaapi.add_byte(*args) def add_word(*args): - """add_word(ea, value)""" + """ + add_word(ea, value) + """ return _idaapi.add_word(*args) def add_long(*args): - """add_long(ea, value)""" + """ + add_long(ea, value) + """ return _idaapi.add_long(*args) def add_qword(*args): - """add_qword(ea, value)""" + """ + add_qword(ea, value) + """ return _idaapi.add_qword(*args) def get_zero_areas(*args): - """get_zero_areas(zareas, range) -> bool""" + """ + get_zero_areas(zareas, range) -> bool + """ return _idaapi.get_zero_areas(*args) def get_many_bytes_ex(*args): - """get_many_bytes_ex(ea, buf, size, mask) -> int""" + """ + get_many_bytes_ex(ea, buf, size, mask) -> int + """ return _idaapi.get_many_bytes_ex(*args) def put_many_bytes(*args): - """put_many_bytes(ea, buf)""" + """ + put_many_bytes(ea, buf) + """ return _idaapi.put_many_bytes(*args) def patch_many_bytes(*args): - """patch_many_bytes(ea, buf)""" + """ + patch_many_bytes(ea, buf) + """ return _idaapi.patch_many_bytes(*args) MS_CLS = _idaapi.MS_CLS FF_CODE = _idaapi.FF_CODE @@ -21451,51 +21831,75 @@ FF_TAIL = _idaapi.FF_TAIL FF_UNK = _idaapi.FF_UNK def isCode(*args): - """isCode(F) -> bool""" + """ + isCode(F) -> bool + """ return _idaapi.isCode(*args) def f_isCode(*args): - """f_isCode(F, arg2) -> bool""" + """ + f_isCode(F, arg2) -> bool + """ return _idaapi.f_isCode(*args) def isData(*args): - """isData(F) -> bool""" + """ + isData(F) -> bool + """ return _idaapi.isData(*args) def f_isData(*args): - """f_isData(F, arg2) -> bool""" + """ + f_isData(F, arg2) -> bool + """ return _idaapi.f_isData(*args) def isTail(*args): - """isTail(F) -> bool""" + """ + isTail(F) -> bool + """ return _idaapi.isTail(*args) def f_isTail(*args): - """f_isTail(F, arg2) -> bool""" + """ + f_isTail(F, arg2) -> bool + """ return _idaapi.f_isTail(*args) def isNotTail(*args): - """isNotTail(F) -> bool""" + """ + isNotTail(F) -> bool + """ return _idaapi.isNotTail(*args) def f_isNotTail(*args): - """f_isNotTail(F, arg2) -> bool""" + """ + f_isNotTail(F, arg2) -> bool + """ return _idaapi.f_isNotTail(*args) def isUnknown(*args): - """isUnknown(F) -> bool""" + """ + isUnknown(F) -> bool + """ return _idaapi.isUnknown(*args) def isHead(*args): - """isHead(F) -> bool""" + """ + isHead(F) -> bool + """ return _idaapi.isHead(*args) def f_isHead(*args): - """f_isHead(F, arg2) -> bool""" + """ + f_isHead(F, arg2) -> bool + """ return _idaapi.f_isHead(*args) def do_unknown(*args): - """do_unknown(ea, flags) -> bool""" + """ + do_unknown(ea, flags) + """ return _idaapi.do_unknown(*args) DOUNK_SIMPLE = _idaapi.DOUNK_SIMPLE DOUNK_EXPAND = _idaapi.DOUNK_EXPAND @@ -21503,19 +21907,27 @@ DOUNK_DELNAMES = _idaapi.DOUNK_DELNAMES DOUNK_NOTRUNC = _idaapi.DOUNK_NOTRUNC def do_unknown_range(*args): - """do_unknown_range(ea, size, flags)""" + """ + do_unknown_range(ea, size, flags) + """ return _idaapi.do_unknown_range(*args) def is_manual_insn(*args): - """is_manual_insn(ea) -> bool""" + """ + is_manual_insn(ea) -> bool + """ return _idaapi.is_manual_insn(*args) def get_manual_insn(*args): - """get_manual_insn(ea) -> char *""" + """ + get_manual_insn(ea) -> char * + """ return _idaapi.get_manual_insn(*args) def set_manual_insn(*args): - """set_manual_insn(ea, manual_insn)""" + """ + set_manual_insn(ea, manual_insn) + """ return _idaapi.set_manual_insn(*args) MS_COMM = _idaapi.MS_COMM FF_COMM = _idaapi.FF_COMM @@ -21529,100 +21941,172 @@ FF_BNOT = _idaapi.FF_BNOT FF_VAR = _idaapi.FF_VAR def isFlow(*args): - """isFlow(F) -> bool""" + """ + isFlow(F) -> bool + """ return _idaapi.isFlow(*args) def isVar(*args): - """isVar(F) -> bool""" + """ + isVar(F) -> bool + """ return _idaapi.isVar(*args) def hasExtra(*args): - """hasExtra(F) -> bool""" + """ + hasExtra(F) -> bool + """ return _idaapi.hasExtra(*args) def has_cmt(*args): - """has_cmt(F) -> bool""" + """ + has_cmt(F) -> bool + """ return _idaapi.has_cmt(*args) def hasRef(*args): - """hasRef(F) -> bool""" + """ + hasRef(F) -> bool + """ return _idaapi.hasRef(*args) def f_hasRef(*args): - """f_hasRef(f, arg2) -> bool""" + """ + f_hasRef(f, arg2) -> bool + """ return _idaapi.f_hasRef(*args) def has_name(*args): - """has_name(F) -> bool""" + """ + has_name(F) -> bool + """ return _idaapi.has_name(*args) def f_has_name(*args): - """f_has_name(f, arg2) -> bool""" + """ + f_has_name(f, arg2) -> bool + """ return _idaapi.f_has_name(*args) FF_ANYNAME = _idaapi.FF_ANYNAME def has_dummy_name(*args): - """has_dummy_name(F) -> bool""" + """ + has_dummy_name(F) -> bool + """ return _idaapi.has_dummy_name(*args) def f_has_dummy_name(*args): - """f_has_dummy_name(f, arg2) -> bool""" + """ + f_has_dummy_name(f, arg2) -> bool + """ return _idaapi.f_has_dummy_name(*args) def has_auto_name(*args): - """has_auto_name(F) -> bool""" + """ + has_auto_name(F) -> bool + """ return _idaapi.has_auto_name(*args) def has_any_name(*args): - """has_any_name(F) -> bool""" + """ + has_any_name(F) -> bool + """ return _idaapi.has_any_name(*args) def has_user_name(*args): - """has_user_name(F) -> bool""" + """ + has_user_name(F) -> bool + """ return _idaapi.has_user_name(*args) def f_has_user_name(*args): - """f_has_user_name(F, arg2) -> bool""" + """ + f_has_user_name(F, arg2) -> bool + """ return _idaapi.f_has_user_name(*args) def is_invsign(*args): - """is_invsign(ea, F, n) -> bool""" + """ + is_invsign(ea, F, n) -> bool + """ return _idaapi.is_invsign(*args) def toggle_sign(*args): - """toggle_sign(ea, n) -> bool""" + """ + toggle_sign(ea, n) -> bool + """ return _idaapi.toggle_sign(*args) +def signed_data_flag(*args): + """ + signed_data_flag() -> flags_t + """ + return _idaapi.signed_data_flag(*args) + +def is_signed_data(*args): + """ + is_signed_data(F) -> bool + """ + return _idaapi.is_signed_data(*args) + def is_bnot(*args): - """is_bnot(ea, F, n) -> bool""" + """ + is_bnot(ea, F, n) -> bool + """ return _idaapi.is_bnot(*args) def toggle_bnot(*args): - """toggle_bnot(ea, n) -> bool""" + """ + toggle_bnot(ea, n) -> bool + """ return _idaapi.toggle_bnot(*args) +def bnot_data_flag(*args): + """ + bnot_data_flag() -> flags_t + """ + return _idaapi.bnot_data_flag(*args) + +def is_bnot_data(*args): + """ + is_bnot_data(F) -> bool + """ + return _idaapi.is_bnot_data(*args) + def is_lzero(*args): - """is_lzero(ea, n) -> bool""" + """ + is_lzero(ea, n) -> bool + """ return _idaapi.is_lzero(*args) def set_lzero(*args): - """set_lzero(ea, n) -> bool""" + """ + set_lzero(ea, n) -> bool + """ return _idaapi.set_lzero(*args) def clr_lzero(*args): - """clr_lzero(ea, n) -> bool""" + """ + clr_lzero(ea, n) -> bool + """ return _idaapi.clr_lzero(*args) def toggle_lzero(*args): - """toggle_lzero(ea, n) -> bool""" + """ + toggle_lzero(ea, n) -> bool + """ return _idaapi.toggle_lzero(*args) def leading_zero_important(*args): - """leading_zero_important(ea, n) -> bool""" + """ + leading_zero_important(ea, n) -> bool + """ return _idaapi.leading_zero_important(*args) def doVar(*args): - """doVar(ea, isvar=True)""" + """ + doVar(ea, isvar=True) + """ return _idaapi.doVar(*args) MS_0TYPE = _idaapi.MS_0TYPE FF_0VOID = _idaapi.FF_0VOID @@ -21656,286 +22140,456 @@ FF_1FLT = _idaapi.FF_1FLT FF_1CUST = _idaapi.FF_1CUST def isDefArg0(*args): - """isDefArg0(F) -> bool""" + """ + isDefArg0(F) -> bool + """ return _idaapi.isDefArg0(*args) def isDefArg1(*args): - """isDefArg1(F) -> bool""" + """ + isDefArg1(F) -> bool + """ return _idaapi.isDefArg1(*args) def isOff0(*args): - """isOff0(F) -> bool""" + """ + isOff0(F) -> bool + """ return _idaapi.isOff0(*args) def isOff1(*args): - """isOff1(F) -> bool""" + """ + isOff1(F) -> bool + """ return _idaapi.isOff1(*args) def isChar0(*args): - """isChar0(F) -> bool""" + """ + isChar0(F) -> bool + """ return _idaapi.isChar0(*args) def isChar1(*args): - """isChar1(F) -> bool""" + """ + isChar1(F) -> bool + """ return _idaapi.isChar1(*args) def isSeg0(*args): - """isSeg0(F) -> bool""" + """ + isSeg0(F) -> bool + """ return _idaapi.isSeg0(*args) def isSeg1(*args): - """isSeg1(F) -> bool""" + """ + isSeg1(F) -> bool + """ return _idaapi.isSeg1(*args) def isEnum0(*args): - """isEnum0(F) -> bool""" + """ + isEnum0(F) -> bool + """ return _idaapi.isEnum0(*args) def isEnum1(*args): - """isEnum1(F) -> bool""" + """ + isEnum1(F) -> bool + """ return _idaapi.isEnum1(*args) +def isFop0(*args): + """ + isFop0(F) -> bool + """ + return _idaapi.isFop0(*args) + +def isFop1(*args): + """ + isFop1(F) -> bool + """ + return _idaapi.isFop1(*args) + def isStroff0(*args): - """isStroff0(F) -> bool""" + """ + isStroff0(F) -> bool + """ return _idaapi.isStroff0(*args) def isStroff1(*args): - """isStroff1(F) -> bool""" + """ + isStroff1(F) -> bool + """ return _idaapi.isStroff1(*args) def isStkvar0(*args): - """isStkvar0(F) -> bool""" + """ + isStkvar0(F) -> bool + """ return _idaapi.isStkvar0(*args) def isStkvar1(*args): - """isStkvar1(F) -> bool""" + """ + isStkvar1(F) -> bool + """ return _idaapi.isStkvar1(*args) def isFloat0(*args): - """isFloat0(F) -> bool""" + """ + isFloat0(F) -> bool + """ return _idaapi.isFloat0(*args) def isFloat1(*args): - """isFloat1(F) -> bool""" + """ + isFloat1(F) -> bool + """ return _idaapi.isFloat1(*args) def isCustFmt0(*args): - """isCustFmt0(F) -> bool""" + """ + isCustFmt0(F) -> bool + """ return _idaapi.isCustFmt0(*args) def isCustFmt1(*args): - """isCustFmt1(F) -> bool""" + """ + isCustFmt1(F) -> bool + """ return _idaapi.isCustFmt1(*args) def isNum0(*args): - """isNum0(F) -> bool""" + """ + isNum0(F) -> bool + """ return _idaapi.isNum0(*args) def isNum1(*args): - """isNum1(F) -> bool""" + """ + isNum1(F) -> bool + """ return _idaapi.isNum1(*args) def get_optype_flags0(*args): - """get_optype_flags0(F) -> flags_t""" + """ + get_optype_flags0(F) -> flags_t + """ return _idaapi.get_optype_flags0(*args) def get_optype_flags1(*args): - """get_optype_flags1(F) -> flags_t""" + """ + get_optype_flags1(F) -> flags_t + """ return _idaapi.get_optype_flags1(*args) OPND_OUTER = _idaapi.OPND_OUTER OPND_MASK = _idaapi.OPND_MASK OPND_ALL = _idaapi.OPND_ALL def isDefArg(*args): - """isDefArg(F, n) -> bool""" + """ + isDefArg(F, n) -> bool + """ return _idaapi.isDefArg(*args) def isOff(*args): - """isOff(F, n) -> bool""" + """ + isOff(F, n) -> bool + """ return _idaapi.isOff(*args) def isChar(*args): - """isChar(F, n) -> bool""" + """ + isChar(F, n) -> bool + """ return _idaapi.isChar(*args) def isSeg(*args): - """isSeg(F, n) -> bool""" + """ + isSeg(F, n) -> bool + """ return _idaapi.isSeg(*args) def isEnum(*args): - """isEnum(F, n) -> bool""" + """ + isEnum(F, n) -> bool + """ return _idaapi.isEnum(*args) def isFop(*args): - """isFop(F, n) -> bool""" + """ + isFop(F, n) -> bool + """ return _idaapi.isFop(*args) def isStroff(*args): - """isStroff(F, n) -> bool""" + """ + isStroff(F, n) -> bool + """ return _idaapi.isStroff(*args) def isStkvar(*args): - """isStkvar(F, n) -> bool""" + """ + isStkvar(F, n) -> bool + """ return _idaapi.isStkvar(*args) def isFltnum(*args): - """isFltnum(F, n) -> bool""" + """ + isFltnum(F, n) -> bool + """ return _idaapi.isFltnum(*args) def isCustFmt(*args): - """isCustFmt(F, n) -> bool""" + """ + isCustFmt(F, n) -> bool + """ return _idaapi.isCustFmt(*args) def isNum(*args): - """isNum(F, n) -> bool""" + """ + isNum(F, n) -> bool + """ return _idaapi.isNum(*args) def isVoid(*args): - """isVoid(ea, F, n) -> bool""" + """ + isVoid(ea, F, n) -> bool + """ return _idaapi.isVoid(*args) def op_adds_xrefs(*args): - """op_adds_xrefs(F, n) -> bool""" + """ + op_adds_xrefs(F, n) -> bool + """ return _idaapi.op_adds_xrefs(*args) def set_op_type(*args): - """set_op_type(ea, type, n) -> bool""" + """ + set_op_type(ea, type, n) -> bool + """ return _idaapi.set_op_type(*args) +def typeflag(*args): + """ + typeflag(ea, oldflag, type, n) -> flags_t + """ + return _idaapi.typeflag(*args) + def op_seg(*args): - """op_seg(ea, n) -> bool""" + """ + op_seg(ea, n) -> bool + """ return _idaapi.op_seg(*args) def op_enum(*args): - """op_enum(ea, n, id, serial) -> bool""" + """ + op_enum(ea, n, id, serial) -> bool + """ return _idaapi.op_enum(*args) def get_enum_id(*args): - """get_enum_id(ea, n) -> enum_t""" + """ + get_enum_id(ea, n) -> enum_t + """ return _idaapi.get_enum_id(*args) def op_stroff(*args): - """op_stroff(ea, n, path, path_len, delta) -> bool""" + """ + op_stroff(ea, n, path, path_len, delta) -> bool + """ return _idaapi.op_stroff(*args) +def set_stroff_path(*args): + """ + set_stroff_path(ea, n, path, plen, delta) -> bool + """ + return _idaapi.set_stroff_path(*args) + def get_stroff_path(*args): - """get_stroff_path(ea, n, path, delta) -> int""" + """ + get_stroff_path(ea, n, path, delta) -> int + """ return _idaapi.get_stroff_path(*args) +def del_stroff_path(*args): + """ + del_stroff_path(ea, n) -> bool + """ + return _idaapi.del_stroff_path(*args) + def op_stkvar(*args): - """op_stkvar(ea, n) -> bool""" + """ + op_stkvar(ea, n) -> bool + """ return _idaapi.op_stkvar(*args) def set_forced_operand(*args): - """set_forced_operand(ea, n, op) -> bool""" + """ + set_forced_operand(ea, n, op) -> bool + """ return _idaapi.set_forced_operand(*args) def get_forced_operand(*args): - """get_forced_operand(ea, n) -> ssize_t""" + """ + get_forced_operand(ea, n) -> ssize_t + """ return _idaapi.get_forced_operand(*args) def is_forced_operand(*args): - """is_forced_operand(ea, n) -> bool""" + """ + is_forced_operand(ea, n) -> bool + """ return _idaapi.is_forced_operand(*args) def charflag(*args): - """charflag() -> flags_t""" + """ + charflag() -> flags_t + """ return _idaapi.charflag(*args) def offflag(*args): - """offflag() -> flags_t""" + """ + offflag() -> flags_t + """ return _idaapi.offflag(*args) def enumflag(*args): - """enumflag() -> flags_t""" + """ + enumflag() -> flags_t + """ return _idaapi.enumflag(*args) def stroffflag(*args): - """stroffflag() -> flags_t""" + """ + stroffflag() -> flags_t + """ return _idaapi.stroffflag(*args) def stkvarflag(*args): - """stkvarflag() -> flags_t""" + """ + stkvarflag() -> flags_t + """ return _idaapi.stkvarflag(*args) def fltflag(*args): - """fltflag() -> flags_t""" + """ + fltflag() -> flags_t + """ return _idaapi.fltflag(*args) def custfmtflag(*args): - """custfmtflag() -> flags_t""" + """ + custfmtflag() -> flags_t + """ return _idaapi.custfmtflag(*args) def segflag(*args): - """segflag() -> flags_t""" + """ + segflag() -> flags_t + """ return _idaapi.segflag(*args) def numflag(*args): - """numflag() -> flags_t""" + """ + numflag() -> flags_t + """ return _idaapi.numflag(*args) def hexflag(*args): - """hexflag() -> flags_t""" + """ + hexflag() -> flags_t + """ return _idaapi.hexflag(*args) def decflag(*args): - """decflag() -> flags_t""" + """ + decflag() -> flags_t + """ return _idaapi.decflag(*args) def octflag(*args): - """octflag() -> flags_t""" + """ + octflag() -> flags_t + """ return _idaapi.octflag(*args) def binflag(*args): - """binflag() -> flags_t""" + """ + binflag() -> flags_t + """ return _idaapi.binflag(*args) def op_chr(*args): - """op_chr(ea, n) -> bool""" + """ + op_chr(ea, n) -> bool + """ return _idaapi.op_chr(*args) def op_num(*args): - """op_num(ea, n) -> bool""" + """ + op_num(ea, n) -> bool + """ return _idaapi.op_num(*args) def op_hex(*args): - """op_hex(ea, n) -> bool""" + """ + op_hex(ea, n) -> bool + """ return _idaapi.op_hex(*args) def op_dec(*args): - """op_dec(ea, n) -> bool""" + """ + op_dec(ea, n) -> bool + """ return _idaapi.op_dec(*args) def op_oct(*args): - """op_oct(ea, n) -> bool""" + """ + op_oct(ea, n) -> bool + """ return _idaapi.op_oct(*args) def op_bin(*args): - """op_bin(ea, n) -> bool""" + """ + op_bin(ea, n) -> bool + """ return _idaapi.op_bin(*args) def op_flt(*args): - """op_flt(ea, n) -> bool""" + """ + op_flt(ea, n) -> bool + """ return _idaapi.op_flt(*args) def op_custfmt(*args): - """op_custfmt(ea, n, fid) -> bool""" + """ + op_custfmt(ea, n, fid) -> bool + """ return _idaapi.op_custfmt(*args) def noType(*args): - """noType(ea, n) -> bool""" + """ + noType(ea, n) -> bool + """ return _idaapi.noType(*args) def getDefaultRadix(*args): - """getDefaultRadix() -> int""" + """ + getDefaultRadix() -> int + """ return _idaapi.getDefaultRadix(*args) def getRadix(*args): - """getRadix(F, n) -> int""" + """ + getRadix(F, n) -> int + """ return _idaapi.getRadix(*args) def getRadixEA(*args): - """getRadixEA(ea, n) -> int""" + """ + getRadixEA(ea, n) -> int + """ return _idaapi.getRadixEA(*args) DT_TYPE = _idaapi.DT_TYPE FF_BYTE = _idaapi.FF_BYTE @@ -21955,285 +22609,425 @@ FF_CUSTOM = _idaapi.FF_CUSTOM FF_YWRD = _idaapi.FF_YWRD def codeflag(*args): - """codeflag() -> flags_t""" + """ + codeflag() -> flags_t + """ return _idaapi.codeflag(*args) def byteflag(*args): - """byteflag() -> flags_t""" + """ + byteflag() -> flags_t + """ return _idaapi.byteflag(*args) def wordflag(*args): - """wordflag() -> flags_t""" + """ + wordflag() -> flags_t + """ return _idaapi.wordflag(*args) def dwrdflag(*args): - """dwrdflag() -> flags_t""" + """ + dwrdflag() -> flags_t + """ return _idaapi.dwrdflag(*args) def qwrdflag(*args): - """qwrdflag() -> flags_t""" + """ + qwrdflag() -> flags_t + """ return _idaapi.qwrdflag(*args) def owrdflag(*args): - """owrdflag() -> flags_t""" + """ + owrdflag() -> flags_t + """ return _idaapi.owrdflag(*args) def ywrdflag(*args): - """ywrdflag() -> flags_t""" + """ + ywrdflag() -> flags_t + """ return _idaapi.ywrdflag(*args) def tbytflag(*args): - """tbytflag() -> flags_t""" + """ + tbytflag() -> flags_t + """ return _idaapi.tbytflag(*args) def asciflag(*args): - """asciflag() -> flags_t""" + """ + asciflag() -> flags_t + """ return _idaapi.asciflag(*args) def struflag(*args): - """struflag() -> flags_t""" + """ + struflag() -> flags_t + """ return _idaapi.struflag(*args) def custflag(*args): - """custflag() -> flags_t""" + """ + custflag() -> flags_t + """ return _idaapi.custflag(*args) def alignflag(*args): - """alignflag() -> flags_t""" + """ + alignflag() -> flags_t + """ return _idaapi.alignflag(*args) def floatflag(*args): - """floatflag() -> flags_t""" + """ + floatflag() -> flags_t + """ return _idaapi.floatflag(*args) def doubleflag(*args): - """doubleflag() -> flags_t""" + """ + doubleflag() -> flags_t + """ return _idaapi.doubleflag(*args) def tribyteflag(*args): - """tribyteflag() -> flags_t""" + """ + tribyteflag() -> flags_t + """ return _idaapi.tribyteflag(*args) def packrealflag(*args): - """packrealflag() -> flags_t""" + """ + packrealflag() -> flags_t + """ return _idaapi.packrealflag(*args) -def isByte(*args): - """isByte(F) -> bool""" - return _idaapi.isByte(*args) - -def isWord(*args): - """isWord(F) -> bool""" - return _idaapi.isWord(*args) - -def isDwrd(*args): - """isDwrd(F) -> bool""" - return _idaapi.isDwrd(*args) - -def isQwrd(*args): - """isQwrd(F) -> bool""" - return _idaapi.isQwrd(*args) - -def isOwrd(*args): - """isOwrd(F) -> bool""" - return _idaapi.isOwrd(*args) - -def isYwrd(*args): - """isYwrd(F) -> bool""" - return _idaapi.isYwrd(*args) - -def isTbyt(*args): - """isTbyt(F) -> bool""" - return _idaapi.isTbyt(*args) - -def isFloat(*args): - """isFloat(F) -> bool""" - return _idaapi.isFloat(*args) - -def isDouble(*args): - """isDouble(F) -> bool""" - return _idaapi.isDouble(*args) - -def isPackReal(*args): - """isPackReal(F) -> bool""" - return _idaapi.isPackReal(*args) - -def isASCII(*args): - """isASCII(F) -> bool""" - return _idaapi.isASCII(*args) - -def isStruct(*args): - """isStruct(F) -> bool""" - return _idaapi.isStruct(*args) - -def isAlign(*args): - """isAlign(F) -> bool""" - return _idaapi.isAlign(*args) - -def is3byte(*args): - """is3byte(F) -> bool""" - return _idaapi.is3byte(*args) - -def isCustom(*args): - """isCustom(F) -> bool""" - return _idaapi.isCustom(*args) - -def f_isByte(*args): - """f_isByte(F, arg2) -> bool""" - return _idaapi.f_isByte(*args) - -def f_isWord(*args): - """f_isWord(F, arg2) -> bool""" - return _idaapi.f_isWord(*args) - -def f_isDwrd(*args): - """f_isDwrd(F, arg2) -> bool""" - return _idaapi.f_isDwrd(*args) - -def f_isQwrd(*args): - """f_isQwrd(F, arg2) -> bool""" - return _idaapi.f_isQwrd(*args) - -def f_isOwrd(*args): - """f_isOwrd(F, arg2) -> bool""" - return _idaapi.f_isOwrd(*args) - -def f_isYwrd(*args): - """f_isYwrd(F, arg2) -> bool""" - return _idaapi.f_isYwrd(*args) - -def f_isTbyt(*args): - """f_isTbyt(F, arg2) -> bool""" - return _idaapi.f_isTbyt(*args) - -def f_isFloat(*args): - """f_isFloat(F, arg2) -> bool""" - return _idaapi.f_isFloat(*args) - -def f_isDouble(*args): - """f_isDouble(F, arg2) -> bool""" - return _idaapi.f_isDouble(*args) - -def f_isPackReal(*args): - """f_isPackReal(F, arg2) -> bool""" - return _idaapi.f_isPackReal(*args) - -def f_isASCII(*args): - """f_isASCII(F, arg2) -> bool""" - return _idaapi.f_isASCII(*args) - -def f_isStruct(*args): - """f_isStruct(F, arg2) -> bool""" - return _idaapi.f_isStruct(*args) - -def f_isAlign(*args): - """f_isAlign(F, arg2) -> bool""" - return _idaapi.f_isAlign(*args) - -def f_is3byte(*args): - """f_is3byte(F, arg2) -> bool""" - return _idaapi.f_is3byte(*args) - -def f_isCustom(*args): - """f_isCustom(F, arg2) -> bool""" - return _idaapi.f_isCustom(*args) - -def is_same_data_type(*args): - """is_same_data_type(F1, F2) -> bool""" - return _idaapi.is_same_data_type(*args) - def get_flags_by_size(*args): - """get_flags_by_size(size) -> flags_t""" + """ + get_flags_by_size(size) -> flags_t + """ return _idaapi.get_flags_by_size(*args) def do_data_ex(*args): - """do_data_ex(ea, dataflag, size, tid) -> bool""" + """ + do_data_ex(ea, dataflag, size, tid) -> bool + """ return _idaapi.do_data_ex(*args) def doByte(*args): - """doByte(ea, length) -> bool""" + """ + doByte(ea, length) -> bool + """ return _idaapi.doByte(*args) def doWord(*args): - """doWord(ea, length) -> bool""" + """ + doWord(ea, length) -> bool + """ return _idaapi.doWord(*args) def doDwrd(*args): - """doDwrd(ea, length) -> bool""" + """ + doDwrd(ea, length) -> bool + """ return _idaapi.doDwrd(*args) def doQwrd(*args): - """doQwrd(ea, length) -> bool""" + """ + doQwrd(ea, length) -> bool + """ return _idaapi.doQwrd(*args) def doOwrd(*args): - """doOwrd(ea, length) -> bool""" + """ + doOwrd(ea, length) -> bool + """ return _idaapi.doOwrd(*args) def doYwrd(*args): - """doYwrd(ea, length) -> bool""" + """ + doYwrd(ea, length) -> bool + """ return _idaapi.doYwrd(*args) def doTbyt(*args): - """doTbyt(ea, length) -> bool""" + """ + doTbyt(ea, length) -> bool + """ return _idaapi.doTbyt(*args) def doFloat(*args): - """doFloat(ea, length) -> bool""" + """ + doFloat(ea, length) -> bool + """ return _idaapi.doFloat(*args) def doDouble(*args): - """doDouble(ea, length) -> bool""" + """ + doDouble(ea, length) -> bool + """ return _idaapi.doDouble(*args) def doPackReal(*args): - """doPackReal(ea, length) -> bool""" + """ + doPackReal(ea, length) -> bool + """ return _idaapi.doPackReal(*args) def doASCI(*args): - """doASCI(ea, length) -> bool""" + """ + doASCI(ea, length) -> bool + """ return _idaapi.doASCI(*args) def do3byte(*args): - """do3byte(ea, length) -> bool""" + """ + do3byte(ea, length) -> bool + """ return _idaapi.do3byte(*args) def doStruct(*args): - """doStruct(ea, length, tid) -> bool""" + """ + doStruct(ea, length, tid) -> bool + """ return _idaapi.doStruct(*args) def doCustomData(*args): - """doCustomData(ea, length, dtid, fid) -> bool""" + """ + doCustomData(ea, length, dtid, fid) -> bool + """ return _idaapi.doCustomData(*args) def doAlign(*args): - """doAlign(ea, length, alignment) -> bool""" + """ + doAlign(ea, length, alignment) -> bool + """ return _idaapi.doAlign(*args) def calc_min_align(*args): - """calc_min_align(length) -> int""" + """ + calc_min_align(length) -> int + """ return _idaapi.calc_min_align(*args) def calc_max_align(*args): - """calc_max_align(endea) -> int""" + """ + calc_max_align(endea) -> int + """ return _idaapi.calc_max_align(*args) def calc_def_align(*args): - """calc_def_align(ea, mina, maxa) -> int""" + """ + calc_def_align(ea, mina, maxa) -> int + """ return _idaapi.calc_def_align(*args) def do16bit(*args): - """do16bit(ea, length) -> bool""" + """ + do16bit(ea, length) -> bool + """ return _idaapi.do16bit(*args) def do32bit(*args): - """do32bit(ea, length) -> bool""" + """ + do32bit(ea, length) -> bool + """ return _idaapi.do32bit(*args) + +def isByte(*args): + """ + isByte(F) -> bool + """ + return _idaapi.isByte(*args) + +def isWord(*args): + """ + isWord(F) -> bool + """ + return _idaapi.isWord(*args) + +def isDwrd(*args): + """ + isDwrd(F) -> bool + """ + return _idaapi.isDwrd(*args) + +def isQwrd(*args): + """ + isQwrd(F) -> bool + """ + return _idaapi.isQwrd(*args) + +def isOwrd(*args): + """ + isOwrd(F) -> bool + """ + return _idaapi.isOwrd(*args) + +def isYwrd(*args): + """ + isYwrd(F) -> bool + """ + return _idaapi.isYwrd(*args) + +def isTbyt(*args): + """ + isTbyt(F) -> bool + """ + return _idaapi.isTbyt(*args) + +def isFloat(*args): + """ + isFloat(F) -> bool + """ + return _idaapi.isFloat(*args) + +def isDouble(*args): + """ + isDouble(F) -> bool + """ + return _idaapi.isDouble(*args) + +def isPackReal(*args): + """ + isPackReal(F) -> bool + """ + return _idaapi.isPackReal(*args) + +def isASCII(*args): + """ + isASCII(F) -> bool + """ + return _idaapi.isASCII(*args) + +def isStruct(*args): + """ + isStruct(F) -> bool + """ + return _idaapi.isStruct(*args) + +def isAlign(*args): + """ + isAlign(F) -> bool + """ + return _idaapi.isAlign(*args) + +def is3byte(*args): + """ + is3byte(F) -> bool + """ + return _idaapi.is3byte(*args) + +def isCustom(*args): + """ + isCustom(F) -> bool + """ + return _idaapi.isCustom(*args) + +def f_isByte(*args): + """ + f_isByte(F, arg2) -> bool + """ + return _idaapi.f_isByte(*args) + +def f_isWord(*args): + """ + f_isWord(F, arg2) -> bool + """ + return _idaapi.f_isWord(*args) + +def f_isDwrd(*args): + """ + f_isDwrd(F, arg2) -> bool + """ + return _idaapi.f_isDwrd(*args) + +def f_isQwrd(*args): + """ + f_isQwrd(F, arg2) -> bool + """ + return _idaapi.f_isQwrd(*args) + +def f_isOwrd(*args): + """ + f_isOwrd(F, arg2) -> bool + """ + return _idaapi.f_isOwrd(*args) + +def f_isYwrd(*args): + """ + f_isYwrd(F, arg2) -> bool + """ + return _idaapi.f_isYwrd(*args) + +def f_isTbyt(*args): + """ + f_isTbyt(F, arg2) -> bool + """ + return _idaapi.f_isTbyt(*args) + +def f_isFloat(*args): + """ + f_isFloat(F, arg2) -> bool + """ + return _idaapi.f_isFloat(*args) + +def f_isDouble(*args): + """ + f_isDouble(F, arg2) -> bool + """ + return _idaapi.f_isDouble(*args) + +def f_isPackReal(*args): + """ + f_isPackReal(F, arg2) -> bool + """ + return _idaapi.f_isPackReal(*args) + +def f_isASCII(*args): + """ + f_isASCII(F, arg2) -> bool + """ + return _idaapi.f_isASCII(*args) + +def f_isStruct(*args): + """ + f_isStruct(F, arg2) -> bool + """ + return _idaapi.f_isStruct(*args) + +def f_isAlign(*args): + """ + f_isAlign(F, arg2) -> bool + """ + return _idaapi.f_isAlign(*args) + +def f_is3byte(*args): + """ + f_is3byte(F, arg2) -> bool + """ + return _idaapi.f_is3byte(*args) + +def f_isCustom(*args): + """ + f_isCustom(F, arg2) -> bool + """ + return _idaapi.f_isCustom(*args) + +def is_same_data_type(*args): + """ + is_same_data_type(F1, F2) -> bool + """ + return _idaapi.is_same_data_type(*args) ALOPT_IGNHEADS = _idaapi.ALOPT_IGNHEADS ALOPT_IGNPRINT = _idaapi.ALOPT_IGNPRINT def get_max_ascii_length(*args): - """get_max_ascii_length(ea, strtype, options=0) -> size_t""" + """ + get_max_ascii_length(ea, strtype, options=0) -> size_t + """ return _idaapi.get_max_ascii_length(*args) ACFOPT_ASCII = _idaapi.ACFOPT_ASCII ACFOPT_UTF16 = _idaapi.ACFOPT_UTF16 @@ -22242,35 +23036,51 @@ ACFOPT_CONVMASK = _idaapi.ACFOPT_CONVMASK ACFOPT_ESCAPE = _idaapi.ACFOPT_ESCAPE def make_ascii_string(*args): - """make_ascii_string(start, len, strtype) -> bool""" + """ + make_ascii_string(start, len, strtype) -> bool + """ return _idaapi.make_ascii_string(*args) def print_ascii_string_type(*args): - """print_ascii_string_type(strtype) -> char *""" + """ + print_ascii_string_type(strtype) -> char * + """ return _idaapi.print_ascii_string_type(*args) def get_opinfo(*args): - """get_opinfo(ea, n, flags, buf) -> opinfo_t""" + """ + get_opinfo(ea, n, flags, buf) -> opinfo_t + """ return _idaapi.get_opinfo(*args) def set_opinfo(*args): - """set_opinfo(ea, n, flag, ti) -> bool""" + """ + set_opinfo(ea, n, flag, ti) -> bool + """ return _idaapi.set_opinfo(*args) def get_data_elsize(*args): - """get_data_elsize(ea, F, ti=None) -> asize_t""" + """ + get_data_elsize(ea, F, ti=None) -> asize_t + """ return _idaapi.get_data_elsize(*args) def get_full_data_elsize(*args): - """get_full_data_elsize(ea, F, ti=None) -> asize_t""" + """ + get_full_data_elsize(ea, F, ti=None) -> asize_t + """ return _idaapi.get_full_data_elsize(*args) def is_varsize_item(*args): - """is_varsize_item(ea, F, ti=None, itemsize=None) -> int""" + """ + is_varsize_item(ea, F, ti=None, itemsize=None) -> int + """ return _idaapi.is_varsize_item(*args) def can_define_item(*args): - """can_define_item(ea, length, flags) -> bool""" + """ + can_define_item(ea, length, flags) -> bool + """ return _idaapi.can_define_item(*args) MS_CODE = _idaapi.MS_CODE FF_FUNC = _idaapi.FF_FUNC @@ -22278,59 +23088,97 @@ FF_IMMD = _idaapi.FF_IMMD FF_JUMP = _idaapi.FF_JUMP def isImmd(*args): - """isImmd(F) -> bool""" + """ + isImmd(F) -> bool + """ return _idaapi.isImmd(*args) def isFunc(*args): - """isFunc(F) -> bool""" + """ + isFunc(F) -> bool + """ return _idaapi.isFunc(*args) def doImmd(*args): - """doImmd(ea) -> bool""" + """ + doImmd(ea) -> bool + """ return _idaapi.doImmd(*args) def noImmd(*args): - """noImmd(ea) -> bool""" + """ + noImmd(ea) -> bool + """ return _idaapi.noImmd(*args) +MS_TAIL = _idaapi.MS_TAIL +TL_TSFT = _idaapi.TL_TSFT +TL_TOFF = _idaapi.TL_TOFF +MAX_TOFF = _idaapi.MAX_TOFF + +def gettof(*args): + """ + gettof(F) -> ushort + """ + return _idaapi.gettof(*args) def get_custom_data_types(*args): - """get_custom_data_types(out, min_size=0, max_size=BADADDR) -> int""" + """ + get_custom_data_types(out, min_size=0, max_size=BADADDR) -> int + """ return _idaapi.get_custom_data_types(*args) def get_custom_data_formats(*args): - """get_custom_data_formats(out, dtid) -> int""" + """ + get_custom_data_formats(out, dtid) -> int + """ return _idaapi.get_custom_data_formats(*args) def find_custom_data_type(*args): - """find_custom_data_type(name) -> int""" + """ + find_custom_data_type(name) -> int + """ return _idaapi.find_custom_data_type(*args) def find_custom_data_format(*args): - """find_custom_data_format(name) -> int""" + """ + find_custom_data_format(name) -> int + """ return _idaapi.find_custom_data_format(*args) def set_cmt(*args): - """set_cmt(ea, comm, rptble) -> bool""" + """ + set_cmt(ea, comm, rptble) -> bool + """ return _idaapi.set_cmt(*args) def get_cmt(*args): - """get_cmt(ea, rptble) -> ssize_t""" + """ + get_cmt(ea, rptble) -> ssize_t + """ return _idaapi.get_cmt(*args) def append_cmt(*args): - """append_cmt(ea, str, rptble) -> bool""" + """ + append_cmt(ea, str, rptble) -> bool + """ return _idaapi.append_cmt(*args) def find_byte(*args): - """find_byte(sEA, size, value, bin_search_flags) -> ea_t""" + """ + find_byte(sEA, size, value, bin_search_flags) -> ea_t + """ return _idaapi.find_byte(*args) def find_byter(*args): - """find_byter(sEA, size, value, bin_search_flags) -> ea_t""" + """ + find_byter(sEA, size, value, bin_search_flags) -> ea_t + """ return _idaapi.find_byter(*args) def bin_search(*args): - """bin_search(startEA, endEA, image, mask, len, step, flags) -> ea_t""" + """ + bin_search(startEA, endEA, image, mask, len, step, flags) -> ea_t + """ return _idaapi.bin_search(*args) BIN_SEARCH_FORWARD = _idaapi.BIN_SEARCH_FORWARD BIN_SEARCH_BACKWARD = _idaapi.BIN_SEARCH_BACKWARD @@ -22339,10 +23187,14 @@ BIN_SEARCH_NOCASE = _idaapi.BIN_SEARCH_NOCASE BIN_SEARCH_NOBREAK = _idaapi.BIN_SEARCH_NOBREAK def equal_bytes(*args): - """equal_bytes(ea, image, mask, len, sense_case) -> bool""" + """ + equal_bytes(ea, image, mask, len, sense_case) -> bool + """ return _idaapi.equal_bytes(*args) class hidden_area_t(area_t): - """Proxy of C++ hidden_area_t class""" + """ + Proxy of C++ hidden_area_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr description = _swig_property(_idaapi.hidden_area_t_description_get, _idaapi.hidden_area_t_description_set) @@ -22350,8 +23202,10 @@ class hidden_area_t(area_t): footer = _swig_property(_idaapi.hidden_area_t_footer_get, _idaapi.hidden_area_t_footer_set) visible = _swig_property(_idaapi.hidden_area_t_visible_get, _idaapi.hidden_area_t_visible_set) color = _swig_property(_idaapi.hidden_area_t_color_get, _idaapi.hidden_area_t_color_set) - def __init__(self, *args): - """__init__(self) -> hidden_area_t""" + def __init__(self, *args): + """ + __init__(self) -> hidden_area_t + """ this = _idaapi.new_hidden_area_t(*args) try: self.this.append(this) except: self.this = this @@ -22361,100 +23215,249 @@ hidden_area_t_swigregister = _idaapi.hidden_area_t_swigregister hidden_area_t_swigregister(hidden_area_t) +def update_hidden_area(*args): + """ + update_hidden_area(ha) -> bool + """ + return _idaapi.update_hidden_area(*args) + def add_hidden_area(*args): - """add_hidden_area(ea1, ea2, description, header, footer, color) -> bool""" + """ + add_hidden_area(ea1, ea2, description, header, footer, color) -> bool + """ return _idaapi.add_hidden_area(*args) def get_hidden_area(*args): - """get_hidden_area(ea) -> hidden_area_t""" + """ + get_hidden_area(ea) -> hidden_area_t + """ return _idaapi.get_hidden_area(*args) def getn_hidden_area(*args): - """getn_hidden_area(n) -> hidden_area_t""" + """ + getn_hidden_area(n) -> hidden_area_t + """ return _idaapi.getn_hidden_area(*args) def get_hidden_area_qty(*args): - """get_hidden_area_qty() -> int""" + """ + get_hidden_area_qty() -> int + """ return _idaapi.get_hidden_area_qty(*args) def get_hidden_area_num(*args): - """get_hidden_area_num(ea) -> int""" + """ + get_hidden_area_num(ea) -> int + """ return _idaapi.get_hidden_area_num(*args) def get_prev_hidden_area(*args): - """get_prev_hidden_area(ea) -> hidden_area_t""" + """ + get_prev_hidden_area(ea) -> hidden_area_t + """ return _idaapi.get_prev_hidden_area(*args) def get_next_hidden_area(*args): - """get_next_hidden_area(ea) -> hidden_area_t""" + """ + get_next_hidden_area(ea) -> hidden_area_t + """ return _idaapi.get_next_hidden_area(*args) def del_hidden_area(*args): - """del_hidden_area(ea) -> bool""" + """ + del_hidden_area(ea) -> bool + """ return _idaapi.del_hidden_area(*args) +def doExtra(*args): + """ + doExtra(ea) -> bool + """ + return _idaapi.doExtra(*args) + +def noExtra(*args): + """ + noExtra(ea) -> bool + """ + return _idaapi.noExtra(*args) + def get_data_type_size(*args): - """get_data_type_size(F, ti) -> asize_t""" + """ + get_data_type_size(F, ti) -> asize_t + """ return _idaapi.get_data_type_size(*args) def f_isUnknown(*args): - """f_isUnknown(F, arg2) -> bool""" + """ + f_isUnknown(F, arg2) -> bool + """ return _idaapi.f_isUnknown(*args) def get_typeinfo(*args): - """get_typeinfo(ea, n, flags, buf) -> opinfo_t""" + """ + get_typeinfo(ea, n, flags, buf) -> opinfo_t + """ return _idaapi.get_typeinfo(*args) def set_typeinfo(*args): - """set_typeinfo(ea, n, flag, ti) -> bool""" + """ + set_typeinfo(ea, n, flag, ti) -> bool + """ return _idaapi.set_typeinfo(*args) def visit_patched_bytes(*args): - """visit_patched_bytes(ea1, ea2, py_callable) -> int""" + """ + visit_patched_bytes(ea1, ea2, py_callable) -> int + + + Enumerates patched bytes in the given range and invokes a callable + @param ea1: start address + @param ea2: end address + @param callable: a Python callable with the following prototype: + callable(ea, fpos, org_val, patch_val). + If the callable returns non-zero then that value will be + returned to the caller and the enumeration will be + interrupted. + @return: Zero if the enumeration was successful or the return + value of the callback if enumeration was interrupted. + """ return _idaapi.visit_patched_bytes(*args) def nextthat(*args): - """nextthat(ea, maxea, callable) -> ea_t""" + """ + nextthat(ea, maxea, callable) -> ea_t + + + Find next address with a flag satisfying the function 'testf'. + Start searching from address 'ea'+1 and inspect bytes up to 'maxea'. + maxea is not included in the search range. + + @param callable: a Python callable with the following prototype: + callable(flags). Return True to stop enumeration. + @return: the found address or BADADDR. + """ return _idaapi.nextthat(*args) def prevthat(*args): - """prevthat(ea, minea, callable) -> ea_t""" + """ + prevthat(ea, minea, callable) -> ea_t + """ return _idaapi.prevthat(*args) def get_many_bytes(*args): - """get_many_bytes(ea, size) -> PyObject *""" + """ + get_many_bytes(ea, size) -> PyObject * + + + Get the specified number of bytes of the program into the buffer. + @param ea: program address + @param size: number of bytes to return + @return: None or the string buffer + """ return _idaapi.get_many_bytes(*args) def get_ascii_contents2(*args): - """get_ascii_contents2(ea, len, type, flags=0x00000000) -> PyObject *""" + """ + get_ascii_contents2(ea, len, type, flags=0x00000000) -> PyObject * + + + Get contents of ascii string + This function returns the displayed part of the string + It works even if the string has not been created in the database yet. + + @param ea: linear address of the string + @param len: length of the string in bytes (including terminating 0) + @param type: type of the string + @param flags: combination of ACFOPT_... + @return: string contents (not including terminating 0) or None + """ return _idaapi.get_ascii_contents2(*args) def get_ascii_contents(*args): - """get_ascii_contents(ea, len, type) -> PyObject *""" + """ + get_ascii_contents(ea, len, type) -> PyObject * + + + Get contents of ascii string + This function returns the displayed part of the string + It works even if the string has not been created in the database yet. + + @param ea: linear address of the string + @param len: length of the string in bytes (including terminating 0) + @param type: type of the string + @return: string contents (not including terminating 0) or None + """ return _idaapi.get_ascii_contents(*args) def register_custom_data_type(*args): - """register_custom_data_type(py_dt) -> int""" + """ + register_custom_data_type(py_dt) -> int + + + Registers a custom data type. + @param dt: an instance of the data_type_t class + @return: + < 0 if failed to register + > 0 data type id + """ return _idaapi.register_custom_data_type(*args) def unregister_custom_data_type(*args): - """unregister_custom_data_type(dtid) -> bool""" + """ + unregister_custom_data_type(dtid) -> bool + + + Unregisters a custom data type. + @param dtid: the data type id + @return: Boolean + """ return _idaapi.unregister_custom_data_type(*args) def register_custom_data_format(*args): - """register_custom_data_format(dtid, py_df) -> int""" + """ + register_custom_data_format(dtid, py_df) -> int + + + Registers a custom data format with a given data type. + @param dtid: data type id + @param df: an instance of data_format_t + @return: + < 0 if failed to register + > 0 data format id + """ return _idaapi.register_custom_data_format(*args) def unregister_custom_data_format(*args): - """unregister_custom_data_format(dtid, dfid) -> bool""" + """ + unregister_custom_data_format(dtid, dfid) -> bool + + + Unregisters a custom data format + @param dtid: data type id + @param dfid: data format id + @return: Boolean + """ return _idaapi.unregister_custom_data_format(*args) def get_custom_data_format(*args): - """get_custom_data_format(dtid, fid) -> PyObject *""" + """ + get_custom_data_format(dtid, fid) -> PyObject * + + + Returns a dictionary populated with the data format values or None on failure. + @param dtid: data type id + @param dfid: data format id + """ return _idaapi.get_custom_data_format(*args) def get_custom_data_type(*args): - """get_custom_data_type(dtid) -> PyObject *""" + """ + get_custom_data_type(dtid) -> PyObject * + + + Returns a dictionary populated with the data type values or None on failure. + @param dtid: data type id + """ return _idaapi.get_custom_data_type(*args) # DTP_NODUP = 0x0001 @@ -22465,7 +23468,9 @@ class data_type_t(object): """ def __init__(self, name, value_size = 0, menu_name = None, hotkey = None, asm_keyword = None, props = 0): - """Please refer to bytes.hpp / data_type_t in the SDK""" + """ + Please refer to bytes.hpp / data_type_t in the SDK + """ self.name = name self.props = props self.menu_name = menu_name @@ -22474,14 +23479,20 @@ class data_type_t(object): self.value_size = value_size self.id = -1 # Will be initialized after registration - """Contains the data type id after the data type is registered""" + """ + Contains the data type id after the data type is registered + """ def register(self): - """Registers the data type and returns the type id or < 0 on failure""" + """ + Registers the data type and returns the type id or < 0 on failure + """ return _idaapi.register_custom_data_type(self) def unregister(self): - """Unregisters the data type and returns True on success""" + """ + Unregisters the data type and returns True on success + """ # Not registered? if self.id < 0: return True @@ -22519,9 +23530,12 @@ class data_type_t(object): # ----------------------------------------------------------------------- # Uncomment the corresponding callbacks in the inherited class class data_format_t(object): - """Information about a data format""" + """ + Information about a data format + """ def __init__(self, name, value_size = 0, menu_name = None, props = 0, hotkey = None, text_width = 0): - """Custom data format definition. + """ + Custom data format definition. @param name: Format name, must be unique @param menu_name: Visible format name to use in menus @param props: properties (currently 0) @@ -22537,14 +23551,20 @@ class data_format_t(object): self.text_width = text_width self.id = -1 # Will be initialized after registration - """contains the format id after the format gets registered""" + """ + contains the format id after the format gets registered + """ def register(self, dtid): - """Registers the data format with the given data type id and returns the type id or < 0 on failure""" + """ + Registers the data format with the given data type id and returns the type id or < 0 on failure + """ return _idaapi.register_custom_data_format(dtid, self) def unregister(self, dtid): - """Unregisters the data format with the given data type id""" + """ + Unregisters the data format with the given data type id + """ # Not registered? if self.id < 0: @@ -22658,7 +23678,8 @@ def register_data_types_and_formats(formats): # ----------------------------------------------------------------------- def unregister_data_types_and_formats(formats): - """As opposed to register_data_types_and_formats(), this function + """ + As opposed to register_data_types_and_formats(), this function unregisters multiple data types and formats at once. """ def __unreg_format(df, dtid): @@ -22675,247 +23696,157 @@ def unregister_data_types_and_formats(formats): # -class bpt_vec_t(object): - """Proxy of C++ qvector<(bpt_t)> class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args): - """ - __init__(self) -> bpt_vec_t - __init__(self, x) -> bpt_vec_t - """ - this = _idaapi.new_bpt_vec_t(*args) - try: self.this.append(this) - except: self.this = this - __swig_destroy__ = _idaapi.delete_bpt_vec_t - __del__ = lambda self : None; - def push_back(self, *args): - """ - push_back(self, x) - push_back(self) -> bpt_t - """ - return _idaapi.bpt_vec_t_push_back(self, *args) - - def pop_back(self, *args): - """pop_back(self)""" - return _idaapi.bpt_vec_t_pop_back(self, *args) - - def size(self, *args): - """size(self) -> size_t""" - return _idaapi.bpt_vec_t_size(self, *args) - - def empty(self, *args): - """empty(self) -> bool""" - return _idaapi.bpt_vec_t_empty(self, *args) - - def at(self, *args): - """at(self, _idx) -> bpt_t""" - return _idaapi.bpt_vec_t_at(self, *args) - - def front(self, *args): - """ - front(self) -> bpt_t - front(self) -> bpt_t - """ - return _idaapi.bpt_vec_t_front(self, *args) - - def back(self, *args): - """ - back(self) -> bpt_t - back(self) -> bpt_t - """ - return _idaapi.bpt_vec_t_back(self, *args) - - def qclear(self, *args): - """qclear(self)""" - return _idaapi.bpt_vec_t_qclear(self, *args) - - def clear(self, *args): - """clear(self)""" - return _idaapi.bpt_vec_t_clear(self, *args) - - def resize(self, *args): - """ - resize(self, _newsize, x) - resize(self, _newsize) - """ - return _idaapi.bpt_vec_t_resize(self, *args) - - def grow(self, *args): - """grow(self, x=bpt_t())""" - return _idaapi.bpt_vec_t_grow(self, *args) - - def capacity(self, *args): - """capacity(self) -> size_t""" - return _idaapi.bpt_vec_t_capacity(self, *args) - - def reserve(self, *args): - """reserve(self, cnt)""" - return _idaapi.bpt_vec_t_reserve(self, *args) - - def truncate(self, *args): - """truncate(self)""" - return _idaapi.bpt_vec_t_truncate(self, *args) - - def swap(self, *args): - """swap(self, r)""" - return _idaapi.bpt_vec_t_swap(self, *args) - - def extract(self, *args): - """extract(self) -> bpt_t""" - return _idaapi.bpt_vec_t_extract(self, *args) - - def inject(self, *args): - """inject(self, s, len)""" - return _idaapi.bpt_vec_t_inject(self, *args) - - def begin(self, *args): - """ - begin(self) -> bpt_t - begin(self) -> bpt_t - """ - return _idaapi.bpt_vec_t_begin(self, *args) - - def end(self, *args): - """ - end(self) -> bpt_t - end(self) -> bpt_t - """ - return _idaapi.bpt_vec_t_end(self, *args) - - def insert(self, *args): - """insert(self, it, x) -> bpt_t""" - return _idaapi.bpt_vec_t_insert(self, *args) - - def erase(self, *args): - """ - erase(self, it) -> bpt_t - erase(self, first, last) -> bpt_t - """ - return _idaapi.bpt_vec_t_erase(self, *args) - - def __len__(self, *args): - """__len__(self) -> size_t""" - return _idaapi.bpt_vec_t___len__(self, *args) - - def __getitem__(self, *args): - """__getitem__(self, i) -> bpt_t""" - return _idaapi.bpt_vec_t___getitem__(self, *args) - - def __setitem__(self, *args): - """__setitem__(self, i, v)""" - return _idaapi.bpt_vec_t___setitem__(self, *args) - - __iter__ = _bounded_getitem_iterator - -bpt_vec_t_swigregister = _idaapi.bpt_vec_t_swigregister -bpt_vec_t_swigregister(bpt_vec_t) -power2 = cvar.power2 -lowbits = cvar.lowbits - def set_bptloc_string(*args): - """set_bptloc_string(s) -> int""" + """ + set_bptloc_string(s) -> int + """ return _idaapi.set_bptloc_string(*args) def get_bptloc_string(*args): - """get_bptloc_string(i) -> char const *""" + """ + get_bptloc_string(i) -> char const * + """ return _idaapi.get_bptloc_string(*args) BPLT_ABS = _idaapi.BPLT_ABS BPLT_REL = _idaapi.BPLT_REL BPLT_SYM = _idaapi.BPLT_SYM BPLT_SRC = _idaapi.BPLT_SRC class bpt_location_t(object): - """Proxy of C++ bpt_location_t class""" + """ + Proxy of C++ bpt_location_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr info = _swig_property(_idaapi.bpt_location_t_info_get, _idaapi.bpt_location_t_info_set) index = _swig_property(_idaapi.bpt_location_t_index_get, _idaapi.bpt_location_t_index_set) loctype = _swig_property(_idaapi.bpt_location_t_loctype_get, _idaapi.bpt_location_t_loctype_set) def type(self, *args): - """type(self) -> bpt_loctype_t""" + """ + type(self) -> bpt_loctype_t + """ return _idaapi.bpt_location_t_type(self, *args) def is_empty_path(self, *args): - """is_empty_path(self) -> bool""" + """ + is_empty_path(self) -> bool + """ return _idaapi.bpt_location_t_is_empty_path(self, *args) def path(self, *args): - """path(self) -> char const *""" + """ + path(self) -> char const * + """ return _idaapi.bpt_location_t_path(self, *args) def symbol(self, *args): - """symbol(self) -> char const *""" + """ + symbol(self) -> char const * + """ return _idaapi.bpt_location_t_symbol(self, *args) def lineno(self, *args): - """lineno(self) -> int""" + """ + lineno(self) -> int + """ return _idaapi.bpt_location_t_lineno(self, *args) def offset(self, *args): - """offset(self) -> uval_t""" + """ + offset(self) -> uval_t + """ return _idaapi.bpt_location_t_offset(self, *args) def ea(self, *args): - """ea(self) -> ea_t""" + """ + ea(self) -> ea_t + """ return _idaapi.bpt_location_t_ea(self, *args) - def __init__(self, *args): - """__init__(self) -> bpt_location_t""" + def __init__(self, *args): + """ + __init__(self) -> bpt_location_t + """ this = _idaapi.new_bpt_location_t(*args) try: self.this.append(this) except: self.this = this def set_abs_bpt(self, *args): - """set_abs_bpt(self, a)""" + """ + set_abs_bpt(self, a) + """ return _idaapi.bpt_location_t_set_abs_bpt(self, *args) def set_src_bpt(self, *args): - """set_src_bpt(self, fn, _lineno)""" + """ + set_src_bpt(self, fn, _lineno) + """ return _idaapi.bpt_location_t_set_src_bpt(self, *args) def set_sym_bpt(self, *args): - """set_sym_bpt(self, _symbol, _offset=0)""" + """ + set_sym_bpt(self, _symbol, _offset=0) + """ return _idaapi.bpt_location_t_set_sym_bpt(self, *args) def set_rel_bpt(self, *args): - """set_rel_bpt(self, mod, _offset)""" + """ + set_rel_bpt(self, mod, _offset) + """ return _idaapi.bpt_location_t_set_rel_bpt(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.bpt_location_t_compare(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.bpt_location_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.bpt_location_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.bpt_location_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.bpt_location_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.bpt_location_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.bpt_location_t___ge__(self, *args) __swig_destroy__ = _idaapi.delete_bpt_location_t __del__ = lambda self : None; bpt_location_t_swigregister = _idaapi.bpt_location_t_swigregister bpt_location_t_swigregister(bpt_location_t) +power2 = cvar.power2 +lowbits = cvar.lowbits class bpt_t(object): - """Proxy of C++ bpt_t class""" + """ + Proxy of C++ bpt_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr cb = _swig_property(_idaapi.bpt_t_cb_get, _idaapi.bpt_t_cb_set) @@ -22927,101 +23858,149 @@ class bpt_t(object): props = _swig_property(_idaapi.bpt_t_props_get, _idaapi.bpt_t_props_set) size = _swig_property(_idaapi.bpt_t_size_get, _idaapi.bpt_t_size_set) cndidx = _swig_property(_idaapi.bpt_t_cndidx_get, _idaapi.bpt_t_cndidx_set) - def __init__(self, *args): - """__init__(self) -> bpt_t""" + def __init__(self, *args): + """ + __init__(self) -> bpt_t + """ this = _idaapi.new_bpt_t(*args) try: self.this.append(this) except: self.this = this def is_hwbpt(self, *args): - """is_hwbpt(self) -> bool""" + """ + is_hwbpt(self) -> bool + """ return _idaapi.bpt_t_is_hwbpt(self, *args) def enabled(self, *args): - """enabled(self) -> bool""" + """ + enabled(self) -> bool + """ return _idaapi.bpt_t_enabled(self, *args) def is_low_level(self, *args): - """is_low_level(self) -> bool""" + """ + is_low_level(self) -> bool + """ return _idaapi.bpt_t_is_low_level(self, *args) def badbpt(self, *args): - """badbpt(self) -> bool""" + """ + badbpt(self) -> bool + """ return _idaapi.bpt_t_badbpt(self, *args) def listbpt(self, *args): - """listbpt(self) -> bool""" + """ + listbpt(self) -> bool + """ return _idaapi.bpt_t_listbpt(self, *args) def is_compiled(self, *args): - """is_compiled(self) -> bool""" + """ + is_compiled(self) -> bool + """ return _idaapi.bpt_t_is_compiled(self, *args) def is_active(self, *args): - """is_active(self) -> bool""" + """ + is_active(self) -> bool + """ return _idaapi.bpt_t_is_active(self, *args) def is_partially_active(self, *args): - """is_partially_active(self) -> bool""" + """ + is_partially_active(self) -> bool + """ return _idaapi.bpt_t_is_partially_active(self, *args) def is_inactive(self, *args): - """is_inactive(self) -> bool""" + """ + is_inactive(self) -> bool + """ return _idaapi.bpt_t_is_inactive(self, *args) def is_page_bpt(self, *args): - """is_page_bpt(self) -> bool""" + """ + is_page_bpt(self) -> bool + """ return _idaapi.bpt_t_is_page_bpt(self, *args) def get_size(self, *args): - """get_size(self) -> int""" + """ + get_size(self) -> int + """ return _idaapi.bpt_t_get_size(self, *args) def set_abs_bpt(self, *args): - """set_abs_bpt(self, a)""" + """ + set_abs_bpt(self, a) + """ return _idaapi.bpt_t_set_abs_bpt(self, *args) def set_src_bpt(self, *args): - """set_src_bpt(self, fn, lineno)""" + """ + set_src_bpt(self, fn, lineno) + """ return _idaapi.bpt_t_set_src_bpt(self, *args) def set_sym_bpt(self, *args): - """set_sym_bpt(self, sym, o)""" + """ + set_sym_bpt(self, sym, o) + """ return _idaapi.bpt_t_set_sym_bpt(self, *args) def set_rel_bpt(self, *args): - """set_rel_bpt(self, mod, o)""" + """ + set_rel_bpt(self, mod, o) + """ return _idaapi.bpt_t_set_rel_bpt(self, *args) def is_absbpt(self, *args): - """is_absbpt(self) -> bool""" + """ + is_absbpt(self) -> bool + """ return _idaapi.bpt_t_is_absbpt(self, *args) def is_relbpt(self, *args): - """is_relbpt(self) -> bool""" + """ + is_relbpt(self) -> bool + """ return _idaapi.bpt_t_is_relbpt(self, *args) def is_symbpt(self, *args): - """is_symbpt(self) -> bool""" + """ + is_symbpt(self) -> bool + """ return _idaapi.bpt_t_is_symbpt(self, *args) def is_srcbpt(self, *args): - """is_srcbpt(self) -> bool""" + """ + is_srcbpt(self) -> bool + """ return _idaapi.bpt_t_is_srcbpt(self, *args) def is_tracemodebpt(self, *args): - """is_tracemodebpt(self) -> bool""" + """ + is_tracemodebpt(self) -> bool + """ return _idaapi.bpt_t_is_tracemodebpt(self, *args) def is_traceonbpt(self, *args): - """is_traceonbpt(self) -> bool""" + """ + is_traceonbpt(self) -> bool + """ return _idaapi.bpt_t_is_traceonbpt(self, *args) def is_traceoffbpt(self, *args): - """is_traceoffbpt(self) -> bool""" + """ + is_traceoffbpt(self) -> bool + """ return _idaapi.bpt_t_is_traceoffbpt(self, *args) def set_trace_action(self, *args): - """set_trace_action(self, enable, trace_types) -> bool""" + """ + set_trace_action(self, enable, trace_types) -> bool + """ return _idaapi.bpt_t_set_trace_action(self, *args) condition = _swig_property(_idaapi.bpt_t_condition_get, _idaapi.bpt_t_condition_set) @@ -23051,10 +24030,6 @@ BKPT_PAGE = _idaapi.BKPT_PAGE BKPT_ELANG_MASK = _idaapi.BKPT_ELANG_MASK BKPT_ELANG_SHIFT = _idaapi.BKPT_ELANG_SHIFT -MOVBPT_OK = _idaapi.MOVBPT_OK -MOVBPT_NOT_FOUND = _idaapi.MOVBPT_NOT_FOUND -MOVBPT_DEST_BUSY = _idaapi.MOVBPT_DEST_BUSY -MOVBPT_BAD_TYPE = _idaapi.MOVBPT_BAD_TYPE tev_none = _idaapi.tev_none tev_insn = _idaapi.tev_insn tev_call = _idaapi.tev_call @@ -23064,14 +24039,18 @@ tev_mem = _idaapi.tev_mem tev_event = _idaapi.tev_event tev_max = _idaapi.tev_max class tev_info_t(object): - """Proxy of C++ tev_info_t class""" + """ + Proxy of C++ tev_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr type = _swig_property(_idaapi.tev_info_t_type_get, _idaapi.tev_info_t_type_set) tid = _swig_property(_idaapi.tev_info_t_tid_get, _idaapi.tev_info_t_tid_set) ea = _swig_property(_idaapi.tev_info_t_ea_get, _idaapi.tev_info_t_ea_set) - def __init__(self, *args): - """__init__(self) -> tev_info_t""" + def __init__(self, *args): + """ + __init__(self) -> tev_info_t + """ this = _idaapi.new_tev_info_t(*args) try: self.this.append(this) except: self.this = this @@ -23085,7 +24064,9 @@ DEC_ERROR = _idaapi.DEC_ERROR DEC_TIMEOUT = _idaapi.DEC_TIMEOUT def wait_for_next_event(*args): - """wait_for_next_event(wfne, timeout_in_secs) -> dbg_event_code_t""" + """ + wait_for_next_event(wfne, timeout_in_secs) -> dbg_event_code_t + """ return _idaapi.wait_for_next_event(*args) WFNE_ANY = _idaapi.WFNE_ANY WFNE_SUSP = _idaapi.WFNE_SUSP @@ -23095,11 +24076,15 @@ WFNE_NOWAIT = _idaapi.WFNE_NOWAIT WFNE_USEC = _idaapi.WFNE_USEC def get_debug_event(*args): - """get_debug_event() -> debug_event_t""" + """ + get_debug_event() -> debug_event_t + """ return _idaapi.get_debug_event(*args) def set_debugger_options(*args): - """set_debugger_options(options) -> uint""" + """ + set_debugger_options(options) -> uint + """ return _idaapi.set_debugger_options(*args) DOPT_SEGM_MSGS = _idaapi.DOPT_SEGM_MSGS DOPT_START_BPT = _idaapi.DOPT_START_BPT @@ -23122,31 +24107,45 @@ DOPT_END_BPT = _idaapi.DOPT_END_BPT DOPT_TEMP_HWBPT = _idaapi.DOPT_TEMP_HWBPT def set_remote_debugger(*args): - """set_remote_debugger(host, _pass, port=-1)""" + """ + set_remote_debugger(host, _pass, port=-1) + """ return _idaapi.set_remote_debugger(*args) def get_process_options(*args): - """get_process_options(path, args, sdir, host, _pass, port)""" + """ + get_process_options(path, args, sdir, host, _pass, port) + """ return _idaapi.get_process_options(*args) def set_process_options(*args): - """set_process_options(path, args, sdir, host, _pass, port)""" + """ + set_process_options(path, args, sdir, host, _pass, port) + """ return _idaapi.set_process_options(*args) def retrieve_exceptions(*args): - """retrieve_exceptions() -> excvec_t *""" + """ + retrieve_exceptions() -> excvec_t * + """ return _idaapi.retrieve_exceptions(*args) def store_exceptions(*args): - """store_exceptions() -> bool""" + """ + store_exceptions() -> bool + """ return _idaapi.store_exceptions(*args) def define_exception(*args): - """define_exception(code, name, desc, flags) -> char const *""" + """ + define_exception(code, name, desc, flags) -> char const * + """ return _idaapi.define_exception(*args) def have_set_options(*args): - """have_set_options(_dbg) -> bool""" + """ + have_set_options(_dbg) -> bool + """ return _idaapi.have_set_options(*args) def set_dbg_options(*args): @@ -23157,18 +24156,26 @@ def set_dbg_options(*args): return _idaapi.set_dbg_options(*args) def set_dbg_default_options(*args): - """set_dbg_default_options(keyword, value_type, value) -> char const *""" + """ + set_dbg_default_options(keyword, value_type, value) -> char const * + """ return _idaapi.set_dbg_default_options(*args) def set_int_dbg_options(*args): - """set_int_dbg_options(keyword, value) -> char const *""" + """ + set_int_dbg_options(keyword, value) -> char const * + """ return _idaapi.set_int_dbg_options(*args) class eval_ctx_t(object): - """Proxy of C++ eval_ctx_t class""" + """ + Proxy of C++ eval_ctx_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, _ea) -> eval_ctx_t""" + def __init__(self, *args): + """ + __init__(self, _ea) -> eval_ctx_t + """ this = _idaapi.new_eval_ctx_t(*args) try: self.this.append(this) except: self.this = this @@ -23191,187 +24198,267 @@ SRCIT_LOCVAR = _idaapi.SRCIT_LOCVAR SRCDBG_PROV_VERSION = _idaapi.SRCDBG_PROV_VERSION def create_source_viewer(*args): - """create_source_viewer(parent, custview, sf, lines, lnnum, colnum, flags) -> source_view_t *""" + """ + create_source_viewer(parent, custview, sf, lines, lnnum, colnum, flags) -> source_view_t * + """ return _idaapi.create_source_viewer(*args) def get_dbg_byte(*args): - """get_dbg_byte(ea, x) -> bool""" + """ + get_dbg_byte(ea, x) -> bool + """ return _idaapi.get_dbg_byte(*args) def put_dbg_byte(*args): - """put_dbg_byte(ea, x) -> bool""" + """ + put_dbg_byte(ea, x) -> bool + """ return _idaapi.put_dbg_byte(*args) def invalidate_dbgmem_config(*args): - """invalidate_dbgmem_config()""" + """ + invalidate_dbgmem_config() + """ return _idaapi.invalidate_dbgmem_config(*args) def invalidate_dbgmem_contents(*args): - """invalidate_dbgmem_contents(ea, size)""" + """ + invalidate_dbgmem_contents(ea, size) + """ return _idaapi.invalidate_dbgmem_contents(*args) def is_debugger_on(*args): - """is_debugger_on() -> bool""" + """ + is_debugger_on() -> bool + """ return _idaapi.is_debugger_on(*args) def is_debugger_memory(*args): - """is_debugger_memory(ea) -> bool""" + """ + is_debugger_memory(ea) -> bool + """ return _idaapi.is_debugger_memory(*args) def run_requests(*args): - """run_requests() -> bool""" + """ + run_requests() -> bool + """ return _idaapi.run_requests(*args) def get_running_request(*args): - """get_running_request() -> ui_notification_t""" + """ + get_running_request() -> ui_notification_t + """ return _idaapi.get_running_request(*args) def get_running_notification(*args): - """get_running_notification() -> dbg_notification_t""" + """ + get_running_notification() -> dbg_notification_t + """ return _idaapi.get_running_notification(*args) def clear_requests_queue(*args): - """clear_requests_queue()""" + """ + clear_requests_queue() + """ return _idaapi.clear_requests_queue(*args) def get_process_state(*args): - """get_process_state() -> int""" + """ + get_process_state() -> int + """ return _idaapi.get_process_state(*args) def start_process(*args): - """start_process(path, args, sdir) -> int""" + """ + start_process(path, args, sdir) -> int + """ return _idaapi.start_process(*args) def request_start_process(*args): - """request_start_process(path, args, sdir) -> int""" + """ + request_start_process(path, args, sdir) -> int + """ return _idaapi.request_start_process(*args) def suspend_process(*args): - """suspend_process() -> bool""" + """ + suspend_process() -> bool + """ return _idaapi.suspend_process(*args) def request_suspend_process(*args): - """request_suspend_process() -> bool""" + """ + request_suspend_process() -> bool + """ return _idaapi.request_suspend_process(*args) def continue_process(*args): - """continue_process() -> bool""" + """ + continue_process() -> bool + """ return _idaapi.continue_process(*args) def request_continue_process(*args): - """request_continue_process() -> bool""" + """ + request_continue_process() -> bool + """ return _idaapi.request_continue_process(*args) def exit_process(*args): - """exit_process() -> bool""" + """ + exit_process() -> bool + """ return _idaapi.exit_process(*args) def request_exit_process(*args): - """request_exit_process() -> bool""" + """ + request_exit_process() -> bool + """ return _idaapi.request_exit_process(*args) def get_process_qty(*args): - """get_process_qty() -> int""" + """ + get_process_qty() -> int + """ return _idaapi.get_process_qty(*args) def get_process_info(*args): - """get_process_info(n, process_info) -> pid_t""" + """ + get_process_info(n, process_info) -> pid_t + """ return _idaapi.get_process_info(*args) def attach_process(*args): - """attach_process(pid, event_id) -> int""" + """ + attach_process(pid, event_id) -> int + """ return _idaapi.attach_process(*args) def request_attach_process(*args): - """request_attach_process(pid, event_id) -> int""" + """ + request_attach_process(pid, event_id) -> int + """ return _idaapi.request_attach_process(*args) def detach_process(*args): - """detach_process() -> bool""" + """ + detach_process() -> bool + """ return _idaapi.detach_process(*args) def request_detach_process(*args): - """request_detach_process() -> bool""" + """ + request_detach_process() -> bool + """ return _idaapi.request_detach_process(*args) def get_thread_qty(*args): - """get_thread_qty() -> int""" + """ + get_thread_qty() -> int + """ return _idaapi.get_thread_qty(*args) def getn_thread(*args): - """getn_thread(n) -> thid_t""" + """ + getn_thread(n) -> thid_t + """ return _idaapi.getn_thread(*args) def select_thread(*args): - """select_thread(tid) -> bool""" + """ + select_thread(tid) -> bool + """ return _idaapi.select_thread(*args) def request_select_thread(*args): - """request_select_thread(tid) -> bool""" + """ + request_select_thread(tid) -> bool + """ return _idaapi.request_select_thread(*args) -def set_resume_mode(*args): - """set_resume_mode(tid, mode) -> bool""" - return _idaapi.set_resume_mode(*args) - -def request_set_resume_mode(*args): - """request_set_resume_mode(tid, mode) -> bool""" - return _idaapi.request_set_resume_mode(*args) - def step_into(*args): - """step_into() -> bool""" + """ + step_into() -> bool + """ return _idaapi.step_into(*args) def request_step_into(*args): - """request_step_into() -> bool""" + """ + request_step_into() -> bool + """ return _idaapi.request_step_into(*args) def step_over(*args): - """step_over() -> bool""" + """ + step_over() -> bool + """ return _idaapi.step_over(*args) def request_step_over(*args): - """request_step_over() -> bool""" + """ + request_step_over() -> bool + """ return _idaapi.request_step_over(*args) def run_to(*args): - """run_to(ea) -> bool""" + """ + run_to(ea) -> bool + """ return _idaapi.run_to(*args) def request_run_to(*args): - """request_run_to(ea) -> bool""" + """ + request_run_to(ea) -> bool + """ return _idaapi.request_run_to(*args) def step_until_ret(*args): - """step_until_ret() -> bool""" + """ + step_until_ret() -> bool + """ return _idaapi.step_until_ret(*args) def request_step_until_ret(*args): - """request_step_until_ret() -> bool""" + """ + request_step_until_ret() -> bool + """ return _idaapi.request_step_until_ret(*args) def get_reg_val(*args): - """get_reg_val(regname, regval) -> bool""" + """ + get_reg_val(regname, regval) -> bool + """ return _idaapi.get_reg_val(*args) def request_set_reg_val(*args): - """request_set_reg_val(regname, regval) -> bool""" + """ + request_set_reg_val(regname, regval) -> bool + """ return _idaapi.request_set_reg_val(*args) def get_bpt_qty(*args): - """get_bpt_qty() -> int""" + """ + get_bpt_qty() -> int + """ return _idaapi.get_bpt_qty(*args) def getn_bpt(*args): - """getn_bpt(n, bpt) -> bool""" + """ + getn_bpt(n, bpt) -> bool + """ return _idaapi.getn_bpt(*args) def get_bpt(*args): - """get_bpt(ea, bpt) -> bool""" + """ + get_bpt(ea, bpt) -> bool + """ return _idaapi.get_bpt(*args) def find_bpt(*args): - """find_bpt(bptloc, bpt) -> bool""" + """ + find_bpt(bptloc, bpt) -> bool + """ return _idaapi.find_bpt(*args) def add_bpt(*args): @@ -23403,7 +24490,9 @@ def request_del_bpt(*args): return _idaapi.request_del_bpt(*args) def update_bpt(*args): - """update_bpt(bpt) -> bool""" + """ + update_bpt(bpt) -> bool + """ return _idaapi.update_bpt(*args) def enable_bpt(*args): @@ -23421,367 +24510,555 @@ def request_enable_bpt(*args): return _idaapi.request_enable_bpt(*args) def set_trace_size(*args): - """set_trace_size(size) -> bool""" + """ + set_trace_size(size) -> bool + """ return _idaapi.set_trace_size(*args) def clear_trace(*args): - """clear_trace()""" + """ + clear_trace() + """ return _idaapi.clear_trace(*args) def request_clear_trace(*args): - """request_clear_trace()""" + """ + request_clear_trace() + """ return _idaapi.request_clear_trace(*args) def is_step_trace_enabled(*args): - """is_step_trace_enabled() -> bool""" + """ + is_step_trace_enabled() -> bool + """ return _idaapi.is_step_trace_enabled(*args) def enable_step_trace(*args): - """enable_step_trace(enable) -> bool""" + """ + enable_step_trace(enable) -> bool + """ return _idaapi.enable_step_trace(*args) def request_enable_step_trace(*args): - """request_enable_step_trace(enable) -> bool""" + """ + request_enable_step_trace(enable) -> bool + """ return _idaapi.request_enable_step_trace(*args) def get_step_trace_options(*args): - """get_step_trace_options() -> int""" + """ + get_step_trace_options() -> int + """ return _idaapi.get_step_trace_options(*args) def set_step_trace_options(*args): - """set_step_trace_options(options)""" + """ + set_step_trace_options(options) + """ return _idaapi.set_step_trace_options(*args) def request_set_step_trace_options(*args): - """request_set_step_trace_options(options)""" + """ + request_set_step_trace_options(options) + """ return _idaapi.request_set_step_trace_options(*args) def is_insn_trace_enabled(*args): - """is_insn_trace_enabled() -> bool""" + """ + is_insn_trace_enabled() -> bool + """ return _idaapi.is_insn_trace_enabled(*args) def enable_insn_trace(*args): - """enable_insn_trace(enable) -> bool""" + """ + enable_insn_trace(enable) -> bool + """ return _idaapi.enable_insn_trace(*args) def request_enable_insn_trace(*args): - """request_enable_insn_trace(enable) -> bool""" + """ + request_enable_insn_trace(enable) -> bool + """ return _idaapi.request_enable_insn_trace(*args) def get_insn_trace_options(*args): - """get_insn_trace_options() -> int""" + """ + get_insn_trace_options() -> int + """ return _idaapi.get_insn_trace_options(*args) def set_insn_trace_options(*args): - """set_insn_trace_options(options)""" + """ + set_insn_trace_options(options) + """ return _idaapi.set_insn_trace_options(*args) def request_set_insn_trace_options(*args): - """request_set_insn_trace_options(options)""" + """ + request_set_insn_trace_options(options) + """ return _idaapi.request_set_insn_trace_options(*args) def is_func_trace_enabled(*args): - """is_func_trace_enabled() -> bool""" + """ + is_func_trace_enabled() -> bool + """ return _idaapi.is_func_trace_enabled(*args) def enable_func_trace(*args): - """enable_func_trace(enable) -> bool""" + """ + enable_func_trace(enable) -> bool + """ return _idaapi.enable_func_trace(*args) def request_enable_func_trace(*args): - """request_enable_func_trace(enable) -> bool""" + """ + request_enable_func_trace(enable) -> bool + """ return _idaapi.request_enable_func_trace(*args) def get_func_trace_options(*args): - """get_func_trace_options() -> int""" + """ + get_func_trace_options() -> int + """ return _idaapi.get_func_trace_options(*args) def set_func_trace_options(*args): - """set_func_trace_options(options)""" + """ + set_func_trace_options(options) + """ return _idaapi.set_func_trace_options(*args) def request_set_func_trace_options(*args): - """request_set_func_trace_options(options)""" + """ + request_set_func_trace_options(options) + """ return _idaapi.request_set_func_trace_options(*args) def set_highlight_trace_options(*args): - """set_highlight_trace_options(hilight, color, diff)""" + """ + set_highlight_trace_options(highlight, color, diff) + """ return _idaapi.set_highlight_trace_options(*args) def is_bblk_trace_enabled(*args): - """is_bblk_trace_enabled() -> bool""" + """ + is_bblk_trace_enabled() -> bool + """ return _idaapi.is_bblk_trace_enabled(*args) def enable_bblk_trace(*args): - """enable_bblk_trace(enable) -> bool""" + """ + enable_bblk_trace(enable) -> bool + """ return _idaapi.enable_bblk_trace(*args) def request_enable_bblk_trace(*args): - """request_enable_bblk_trace(enable) -> bool""" + """ + request_enable_bblk_trace(enable) -> bool + """ return _idaapi.request_enable_bblk_trace(*args) def get_bblk_trace_options(*args): - """get_bblk_trace_options() -> int""" + """ + get_bblk_trace_options() -> int + """ return _idaapi.get_bblk_trace_options(*args) def set_bblk_trace_options(*args): - """set_bblk_trace_options(options)""" + """ + set_bblk_trace_options(options) + """ return _idaapi.set_bblk_trace_options(*args) def request_set_bblk_trace_options(*args): - """request_set_bblk_trace_options(options)""" + """ + request_set_bblk_trace_options(options) + """ return _idaapi.request_set_bblk_trace_options(*args) def get_tev_qty(*args): - """get_tev_qty() -> int""" + """ + get_tev_qty() -> int + """ return _idaapi.get_tev_qty(*args) def get_tev_info(*args): - """get_tev_info(n, tev_info) -> bool""" + """ + get_tev_info(n, tev_info) -> bool + """ return _idaapi.get_tev_info(*args) def get_insn_tev_reg_val(*args): - """get_insn_tev_reg_val(n, regname, regval) -> bool""" + """ + get_insn_tev_reg_val(n, regname, regval) -> bool + """ return _idaapi.get_insn_tev_reg_val(*args) def get_insn_tev_reg_mem(*args): - """get_insn_tev_reg_mem(n, memmap) -> bool""" + """ + get_insn_tev_reg_mem(n, memmap) -> bool + """ return _idaapi.get_insn_tev_reg_mem(*args) def get_insn_tev_reg_result(*args): - """get_insn_tev_reg_result(n, regname, regval) -> bool""" + """ + get_insn_tev_reg_result(n, regname, regval) -> bool + """ return _idaapi.get_insn_tev_reg_result(*args) def get_call_tev_callee(*args): - """get_call_tev_callee(n) -> ea_t""" + """ + get_call_tev_callee(n) -> ea_t + """ return _idaapi.get_call_tev_callee(*args) def get_ret_tev_return(*args): - """get_ret_tev_return(n) -> ea_t""" + """ + get_ret_tev_return(n) -> ea_t + """ return _idaapi.get_ret_tev_return(*args) def get_bpt_tev_ea(*args): - """get_bpt_tev_ea(n) -> ea_t""" + """ + get_bpt_tev_ea(n) -> ea_t + """ return _idaapi.get_bpt_tev_ea(*args) def get_tev_memory_info(*args): - """get_tev_memory_info(n, mi) -> bool""" + """ + get_tev_memory_info(n, mi) -> bool + """ return _idaapi.get_tev_memory_info(*args) def get_tev_event(*args): - """get_tev_event(n, d) -> bool""" + """ + get_tev_event(n, d) -> bool + """ return _idaapi.get_tev_event(*args) def get_tev_ea(*args): - """get_tev_ea(n) -> ea_t""" + """ + get_tev_ea(n) -> ea_t + """ return _idaapi.get_tev_ea(*args) def get_tev_type(*args): - """get_tev_type(n) -> int""" + """ + get_tev_type(n) -> int + """ return _idaapi.get_tev_type(*args) def get_tev_tid(*args): - """get_tev_tid(n) -> int""" + """ + get_tev_tid(n) -> int + """ return _idaapi.get_tev_tid(*args) def get_tev_reg_val(*args): - """get_tev_reg_val(n, regname) -> ea_t""" + """ + get_tev_reg_val(n, regname) -> ea_t + """ return _idaapi.get_tev_reg_val(*args) def get_tev_reg_mem_qty(*args): - """get_tev_reg_mem_qty(n) -> int""" + """ + get_tev_reg_mem_qty(n) -> int + """ return _idaapi.get_tev_reg_mem_qty(*args) def get_tev_reg_mem_ea(*args): - """get_tev_reg_mem_ea(n, idx) -> ea_t""" + """ + get_tev_reg_mem_ea(n, idx) -> ea_t + """ return _idaapi.get_tev_reg_mem_ea(*args) def get_trace_base_address(*args): - """get_trace_base_address() -> ea_t""" + """ + get_trace_base_address() -> ea_t + """ return _idaapi.get_trace_base_address(*args) def load_trace_file(*args): - """load_trace_file(filename) -> bool""" + """ + load_trace_file(filename) -> bool + """ return _idaapi.load_trace_file(*args) def save_trace_file(*args): - """save_trace_file(filename, description) -> bool""" + """ + save_trace_file(filename, description) -> bool + """ return _idaapi.save_trace_file(*args) def is_valid_trace_file(*args): - """is_valid_trace_file(filename) -> bool""" + """ + is_valid_trace_file(filename) -> bool + """ return _idaapi.is_valid_trace_file(*args) def set_trace_file_desc(*args): - """set_trace_file_desc(filename, description) -> bool""" + """ + set_trace_file_desc(filename, description) -> bool + """ return _idaapi.set_trace_file_desc(*args) def get_trace_file_desc(*args): - """get_trace_file_desc(filename) -> bool""" + """ + get_trace_file_desc(filename) -> bool + """ return _idaapi.get_trace_file_desc(*args) def choose_trace_file(*args): - """choose_trace_file() -> bool""" + """ + choose_trace_file() -> bool + """ return _idaapi.choose_trace_file(*args) def diff_trace_file(*args): - """diff_trace_file(filename) -> bool""" + """ + diff_trace_file(filename) -> bool + """ return _idaapi.diff_trace_file(*args) def set_trace_platform(*args): - """set_trace_platform(platform)""" + """ + set_trace_platform(platform) + """ return _idaapi.set_trace_platform(*args) def get_trace_platform(*args): - """get_trace_platform() -> char const *""" + """ + get_trace_platform() -> char const * + """ return _idaapi.get_trace_platform(*args) def graph_trace(*args): - """graph_trace() -> bool""" + """ + graph_trace() -> bool + """ return _idaapi.graph_trace(*args) def set_trace_base_address(*args): - """set_trace_base_address(ea)""" + """ + set_trace_base_address(ea) + """ return _idaapi.set_trace_base_address(*args) def dbg_add_thread(*args): - """dbg_add_thread(tid)""" + """ + dbg_add_thread(tid) + """ return _idaapi.dbg_add_thread(*args) def dbg_del_thread(*args): - """dbg_del_thread(tid)""" + """ + dbg_del_thread(tid) + """ return _idaapi.dbg_del_thread(*args) def dbg_add_tev(*args): - """dbg_add_tev(type, tid, address)""" + """ + dbg_add_tev(type, tid, address) + """ return _idaapi.dbg_add_tev(*args) def dbg_add_many_tevs(*args): - """dbg_add_many_tevs(new_tevs) -> bool""" + """ + dbg_add_many_tevs(new_tevs) -> bool + """ return _idaapi.dbg_add_many_tevs(*args) def dbg_add_insn_tev(*args): - """dbg_add_insn_tev(tid, ea, save) -> bool""" + """ + dbg_add_insn_tev(tid, ea, save) -> bool + """ return _idaapi.dbg_add_insn_tev(*args) def dbg_add_bpt_tev(*args): - """dbg_add_bpt_tev(tid, ea, bp) -> bool""" + """ + dbg_add_bpt_tev(tid, ea, bp) -> bool + """ return _idaapi.dbg_add_bpt_tev(*args) def dbg_add_call_tev(*args): - """dbg_add_call_tev(tid, caller, callee)""" + """ + dbg_add_call_tev(tid, caller, callee) + """ return _idaapi.dbg_add_call_tev(*args) def dbg_add_ret_tev(*args): - """dbg_add_ret_tev(tid, ret_insn, return_to)""" + """ + dbg_add_ret_tev(tid, ret_insn, return_to) + """ return _idaapi.dbg_add_ret_tev(*args) def dbg_add_debug_event(*args): - """dbg_add_debug_event(event)""" + """ + dbg_add_debug_event(event) + """ return _idaapi.dbg_add_debug_event(*args) def is_reg_integer(*args): - """is_reg_integer(regname) -> bool""" + """ + is_reg_integer(regname) -> bool + """ return _idaapi.is_reg_integer(*args) def is_reg_float(*args): - """is_reg_float(regname) -> bool""" + """ + is_reg_float(regname) -> bool + """ return _idaapi.is_reg_float(*args) def is_reg_custom(*args): - """is_reg_custom(regname) -> bool""" + """ + is_reg_custom(regname) -> bool + """ return _idaapi.is_reg_custom(*args) def get_first_module(*args): - """get_first_module(modinfo) -> bool""" + """ + get_first_module(modinfo) -> bool + """ return _idaapi.get_first_module(*args) def get_next_module(*args): - """get_next_module(modinfo) -> bool""" + """ + get_next_module(modinfo) -> bool + """ return _idaapi.get_next_module(*args) def bring_debugger_to_front(*args): - """bring_debugger_to_front()""" + """ + bring_debugger_to_front() + """ return _idaapi.bring_debugger_to_front(*args) def get_current_thread(*args): - """get_current_thread() -> thid_t""" + """ + get_current_thread() -> thid_t + """ return _idaapi.get_current_thread(*args) def get_debugger_event_cond(*args): - """get_debugger_event_cond() -> char const *""" + """ + get_debugger_event_cond() -> char const * + """ return _idaapi.get_debugger_event_cond(*args) def set_debugger_event_cond(*args): - """set_debugger_event_cond(cond)""" + """ + set_debugger_event_cond(cond) + """ return _idaapi.set_debugger_event_cond(*args) def load_debugger(*args): - """load_debugger(dbgname, use_remote) -> bool""" + """ + load_debugger(dbgname, use_remote) -> bool + """ return _idaapi.load_debugger(*args) def suspend_thread(*args): - """suspend_thread(tid) -> int""" + """ + suspend_thread(tid) -> int + """ return _idaapi.suspend_thread(*args) def request_suspend_thread(*args): - """request_suspend_thread(tid) -> int""" + """ + request_suspend_thread(tid) -> int + """ return _idaapi.request_suspend_thread(*args) def resume_thread(*args): - """resume_thread(tid) -> int""" + """ + resume_thread(tid) -> int + """ return _idaapi.resume_thread(*args) def request_resume_thread(*args): - """request_resume_thread(tid) -> int""" + """ + request_resume_thread(tid) -> int + """ return _idaapi.request_resume_thread(*args) def check_bpt(*args): - """check_bpt(ea) -> int""" + """ + check_bpt(ea) -> int + """ return _idaapi.check_bpt(*args) def set_process_state(*args): - """set_process_state(newstate, p_thid, dbginv) -> int""" + """ + set_process_state(newstate, p_thid, dbginv) -> int + """ return _idaapi.set_process_state(*args) def edit_manual_regions(*args): - """edit_manual_regions()""" + """ + edit_manual_regions() + """ return _idaapi.edit_manual_regions(*args) def enable_manual_regions(*args): - """enable_manual_regions(enable)""" + """ + enable_manual_regions(enable) + """ return _idaapi.enable_manual_regions(*args) def is_debugger_busy(*args): - """is_debugger_busy() -> bool""" + """ + is_debugger_busy() -> bool + """ return _idaapi.is_debugger_busy(*args) def hide_all_bpts(*args): - """hide_all_bpts() -> int""" + """ + hide_all_bpts() -> int + """ return _idaapi.hide_all_bpts(*args) def add_virt_module(*args): - """add_virt_module(mod) -> bool""" + """ + add_virt_module(mod) -> bool + """ return _idaapi.add_virt_module(*args) def del_virt_module(*args): - """del_virt_module(base) -> bool""" + """ + del_virt_module(base) -> bool + """ return _idaapi.del_virt_module(*args) +def internal_get_sreg_base(*args): + """ + internal_get_sreg_base(tid, sreg_value, answer) -> int + """ + return _idaapi.internal_get_sreg_base(*args) + def internal_ioctl(*args): - """internal_ioctl(fn, buf, size, poutbuf, poutsize) -> int""" + """ + internal_ioctl(fn, buf, size, poutbuf, poutsize) -> int + """ return _idaapi.internal_ioctl(*args) def read_dbg_memory(*args): - """read_dbg_memory(ea, buffer, size) -> ssize_t""" + """ + read_dbg_memory(ea, buffer, size) -> ssize_t + """ return _idaapi.read_dbg_memory(*args) def write_dbg_memory(*args): - """write_dbg_memory(ea, buffer, size) -> ssize_t""" + """ + write_dbg_memory(ea, buffer, size) -> ssize_t + """ return _idaapi.write_dbg_memory(*args) def get_reg_vals(*args): - """get_reg_vals(tid, clsmask, values) -> int""" + """ + get_reg_vals(tid, clsmask, values) -> int + """ return _idaapi.get_reg_vals(*args) def set_reg_val(*args): @@ -23792,132 +25069,178 @@ def set_reg_val(*args): return _idaapi.set_reg_val(*args) def get_dbg_memory_info(*args): - """get_dbg_memory_info(areas) -> int""" + """ + get_dbg_memory_info(areas) -> int + """ return _idaapi.get_dbg_memory_info(*args) -def set_bpt_group(*args): - """set_bpt_group(bpt, grp_name)""" - return _idaapi.set_bpt_group(*args) - -def set_bptloc_group(*args): - """set_bptloc_group(bptloc, grp_name) -> bool""" - return _idaapi.set_bptloc_group(*args) - -def get_bpt_group(*args): - """get_bpt_group(bptloc) -> bool""" - return _idaapi.get_bpt_group(*args) - -def rename_bptgrp(*args): - """rename_bptgrp(old_name, new_name) -> bool""" - return _idaapi.rename_bptgrp(*args) - -def del_bptgrp(*args): - """del_bptgrp(name) -> bool""" - return _idaapi.del_bptgrp(*args) - -def get_grp_bpts(*args): - """get_grp_bpts(bpts, grp_name) -> ssize_t""" - return _idaapi.get_grp_bpts(*args) +def move_bpt_to_grp(*args): + """ + move_bpt_to_grp(bpt, grp_name) + """ + return _idaapi.move_bpt_to_grp(*args) def get_manual_regions(*args): - """get_manual_regions() -> PyObject *""" + """ + get_manual_regions() -> PyObject * + + + Returns the manual memory regions + @return: list(startEA, endEA, name, sclass, sbase, bitness, perm) + """ return _idaapi.get_manual_regions(*args) def dbg_is_loaded(*args): - """dbg_is_loaded() -> bool""" + """ + dbg_is_loaded() -> bool + + + Checks if a debugger is loaded + @return: Boolean + """ return _idaapi.dbg_is_loaded(*args) def refresh_debugger_memory(*args): - """refresh_debugger_memory() -> PyObject *""" + """ + refresh_debugger_memory() -> PyObject * + + + Refreshes the debugger memory + @return: Nothing + """ return _idaapi.refresh_debugger_memory(*args) class DBG_Hooks(object): - """Proxy of C++ DBG_Hooks class""" + """ + Proxy of C++ DBG_Hooks class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr __swig_destroy__ = _idaapi.delete_DBG_Hooks __del__ = lambda self : None; def hook(self, *args): - """hook(self) -> bool""" + """ + hook(self) -> bool + """ return _idaapi.DBG_Hooks_hook(self, *args) def unhook(self, *args): - """unhook(self) -> bool""" + """ + unhook(self) -> bool + """ return _idaapi.DBG_Hooks_unhook(self, *args) def dbg_process_start(self, *args): - """dbg_process_start(self, pid, tid, ea, name, base, size)""" + """ + dbg_process_start(self, pid, tid, ea, name, base, size) + """ return _idaapi.DBG_Hooks_dbg_process_start(self, *args) def dbg_process_exit(self, *args): - """dbg_process_exit(self, pid, tid, ea, exit_code)""" + """ + dbg_process_exit(self, pid, tid, ea, exit_code) + """ return _idaapi.DBG_Hooks_dbg_process_exit(self, *args) def dbg_process_attach(self, *args): - """dbg_process_attach(self, pid, tid, ea, name, base, size)""" + """ + dbg_process_attach(self, pid, tid, ea, name, base, size) + """ return _idaapi.DBG_Hooks_dbg_process_attach(self, *args) def dbg_process_detach(self, *args): - """dbg_process_detach(self, pid, tid, ea)""" + """ + dbg_process_detach(self, pid, tid, ea) + """ return _idaapi.DBG_Hooks_dbg_process_detach(self, *args) def dbg_thread_start(self, *args): - """dbg_thread_start(self, pid, tid, ea)""" + """ + dbg_thread_start(self, pid, tid, ea) + """ return _idaapi.DBG_Hooks_dbg_thread_start(self, *args) def dbg_thread_exit(self, *args): - """dbg_thread_exit(self, pid, tid, ea, exit_code)""" + """ + dbg_thread_exit(self, pid, tid, ea, exit_code) + """ return _idaapi.DBG_Hooks_dbg_thread_exit(self, *args) def dbg_library_load(self, *args): - """dbg_library_load(self, pid, tid, ea, name, base, size)""" + """ + dbg_library_load(self, pid, tid, ea, name, base, size) + """ return _idaapi.DBG_Hooks_dbg_library_load(self, *args) def dbg_library_unload(self, *args): - """dbg_library_unload(self, pid, tid, ea, libname)""" + """ + dbg_library_unload(self, pid, tid, ea, libname) + """ return _idaapi.DBG_Hooks_dbg_library_unload(self, *args) def dbg_information(self, *args): - """dbg_information(self, pid, tid, ea, info)""" + """ + dbg_information(self, pid, tid, ea, info) + """ return _idaapi.DBG_Hooks_dbg_information(self, *args) def dbg_exception(self, *args): - """dbg_exception(self, pid, tid, ea, code, can_cont, exc_ea, info) -> int""" + """ + dbg_exception(self, pid, tid, ea, code, can_cont, exc_ea, info) -> int + """ return _idaapi.DBG_Hooks_dbg_exception(self, *args) def dbg_suspend_process(self, *args): - """dbg_suspend_process(self)""" + """ + dbg_suspend_process(self) + """ return _idaapi.DBG_Hooks_dbg_suspend_process(self, *args) def dbg_bpt(self, *args): - """dbg_bpt(self, tid, breakpoint_ea) -> int""" + """ + dbg_bpt(self, tid, breakpoint_ea) -> int + """ return _idaapi.DBG_Hooks_dbg_bpt(self, *args) def dbg_trace(self, *args): - """dbg_trace(self, tid, ip) -> int""" + """ + dbg_trace(self, tid, ip) -> int + """ return _idaapi.DBG_Hooks_dbg_trace(self, *args) def dbg_request_error(self, *args): - """dbg_request_error(self, failed_command, failed_dbg_notification)""" + """ + dbg_request_error(self, failed_command, failed_dbg_notification) + """ return _idaapi.DBG_Hooks_dbg_request_error(self, *args) def dbg_step_into(self, *args): - """dbg_step_into(self)""" + """ + dbg_step_into(self) + """ return _idaapi.DBG_Hooks_dbg_step_into(self, *args) def dbg_step_over(self, *args): - """dbg_step_over(self)""" + """ + dbg_step_over(self) + """ return _idaapi.DBG_Hooks_dbg_step_over(self, *args) def dbg_run_to(self, *args): - """dbg_run_to(self, pid, tid, ea)""" + """ + dbg_run_to(self, pid, tid, ea) + """ return _idaapi.DBG_Hooks_dbg_run_to(self, *args) def dbg_step_until_ret(self, *args): - """dbg_step_until_ret(self)""" + """ + dbg_step_until_ret(self) + """ return _idaapi.DBG_Hooks_dbg_step_until_ret(self, *args) - def __init__(self, *args): - """__init__(self) -> DBG_Hooks""" + def __init__(self, *args): + """ + __init__(self) -> DBG_Hooks + """ if self.__class__ == DBG_Hooks: _self = None else: @@ -23933,27 +25256,16 @@ DBG_Hooks_swigregister = _idaapi.DBG_Hooks_swigregister DBG_Hooks_swigregister(DBG_Hooks) -def list_bptgrps(*args): - """ - list_bptgrps(bptgrps) -> size_t - list_bptgrps() -> PyObject * - """ - return _idaapi.list_bptgrps(*args) - -def move_bpt_to_grp(*args): - """move_bpt_to_grp(bpt, grp_name)""" - return _idaapi.move_bpt_to_grp(*args) - -def internal_get_sreg_base(*args): - """internal_get_sreg_base(tid, sreg_value) -> ea_t""" - return _idaapi.internal_get_sreg_base(*args) - def idadir(*args): - """idadir(subdir) -> char const *""" + """ + idadir(subdir) -> char const * + """ return _idaapi.idadir(*args) def getsysfile(*args): - """getsysfile(filename, subdir) -> char *""" + """ + getsysfile(filename, subdir) -> char * + """ return _idaapi.getsysfile(*args) CFG_SUBDIR = _idaapi.CFG_SUBDIR IDC_SUBDIR = _idaapi.IDC_SUBDIR @@ -23965,11 +25277,15 @@ TIL_SUBDIR = _idaapi.TIL_SUBDIR PLG_SUBDIR = _idaapi.PLG_SUBDIR def get_user_idadir(*args): - """get_user_idadir() -> char const *""" + """ + get_user_idadir() -> char const * + """ return _idaapi.get_user_idadir(*args) def get_special_folder(*args): - """get_special_folder(csidl) -> bool""" + """ + get_special_folder(csidl) -> bool + """ return _idaapi.get_special_folder(*args) CSIDL_APPDATA = _idaapi.CSIDL_APPDATA CSIDL_LOCAL_APPDATA = _idaapi.CSIDL_LOCAL_APPDATA @@ -23978,83 +25294,123 @@ CSIDL_PROGRAM_FILES_COMMON = _idaapi.CSIDL_PROGRAM_FILES_COMMON CSIDL_PROGRAM_FILESX86 = _idaapi.CSIDL_PROGRAM_FILESX86 def fopenWT(*args): - """fopenWT(file) -> FILE *""" + """ + fopenWT(file) -> FILE * + """ return _idaapi.fopenWT(*args) def fopenWB(*args): - """fopenWB(file) -> FILE *""" + """ + fopenWB(file) -> FILE * + """ return _idaapi.fopenWB(*args) def fopenRT(*args): - """fopenRT(file) -> FILE *""" + """ + fopenRT(file) -> FILE * + """ return _idaapi.fopenRT(*args) def fopenRB(*args): - """fopenRB(file) -> FILE *""" + """ + fopenRB(file) -> FILE * + """ return _idaapi.fopenRB(*args) def fopenM(*args): - """fopenM(file) -> FILE *""" + """ + fopenM(file) -> FILE * + """ return _idaapi.fopenM(*args) def fopenA(*args): - """fopenA(file) -> FILE *""" + """ + fopenA(file) -> FILE * + """ return _idaapi.fopenA(*args) def openR(*args): - """openR(file) -> FILE *""" + """ + openR(file) -> FILE * + """ return _idaapi.openR(*args) def openRT(*args): - """openRT(file) -> FILE *""" + """ + openRT(file) -> FILE * + """ return _idaapi.openRT(*args) def openM(*args): - """openM(file) -> FILE *""" + """ + openM(file) -> FILE * + """ return _idaapi.openM(*args) def ecreate(*args): - """ecreate(file) -> FILE *""" + """ + ecreate(file) -> FILE * + """ return _idaapi.ecreate(*args) def ecreateT(*args): - """ecreateT(file) -> FILE *""" + """ + ecreateT(file) -> FILE * + """ return _idaapi.ecreateT(*args) def eclose(*args): - """eclose(fp)""" + """ + eclose(fp) + """ return _idaapi.eclose(*args) def eseek(*args): - """eseek(fp, pos)""" + """ + eseek(fp, pos) + """ return _idaapi.eseek(*args) def eseek64(*args): - """eseek64(fp, pos)""" + """ + eseek64(fp, pos) + """ return _idaapi.eseek64(*args) def qfsize(*args): - """qfsize(fp) -> uint32""" + """ + qfsize(fp) -> uint32 + """ return _idaapi.qfsize(*args) def qfsize64(*args): - """qfsize64(fp) -> uint64""" + """ + qfsize64(fp) -> uint64 + """ return _idaapi.qfsize64(*args) def echsize(*args): - """echsize(fp, size)""" + """ + echsize(fp, size) + """ return _idaapi.echsize(*args) def echsize64(*args): - """echsize64(fp, size)""" + """ + echsize64(fp, size) + """ return _idaapi.echsize64(*args) def getdspace(*args): - """getdspace(path) -> uint64""" + """ + getdspace(path) -> uint64 + """ return _idaapi.getdspace(*args) def call_system(*args): - """call_system(command) -> int""" + """ + call_system(command) -> int + """ return _idaapi.call_system(*args) LINPUT_NONE = _idaapi.LINPUT_NONE LINPUT_LOCAL = _idaapi.LINPUT_LOCAL @@ -24063,41 +25419,59 @@ LINPUT_PROCMEM = _idaapi.LINPUT_PROCMEM LINPUT_GENERIC = _idaapi.LINPUT_GENERIC def qlgetz(*args): - """qlgetz(li, fpos) -> char *""" + """ + qlgetz(li, fpos) -> char * + """ return _idaapi.qlgetz(*args) def qlgetz64(*args): - """qlgetz64(li, fpos) -> char *""" + """ + qlgetz64(li, fpos) -> char * + """ return _idaapi.qlgetz64(*args) def qlsize64(*args): - """qlsize64(li) -> int64""" + """ + qlsize64(li) -> int64 + """ return _idaapi.qlsize64(*args) def qlseek64(*args): - """qlseek64(li, pos, whence=SEEK_SET) -> qoff64_t""" + """ + qlseek64(li, pos, whence=SEEK_SET) -> qoff64_t + """ return _idaapi.qlseek64(*args) def qltell64(*args): - """qltell64(li) -> int64""" + """ + qltell64(li) -> int64 + """ return _idaapi.qltell64(*args) def open_linput(*args): - """open_linput(file, remote) -> linput_t *""" + """ + open_linput(file, remote) -> linput_t * + """ return _idaapi.open_linput(*args) def close_linput(*args): - """close_linput(li)""" + """ + close_linput(li) + """ return _idaapi.close_linput(*args) class generic_linput_t(object): - """Proxy of C++ generic_linput_t class""" + """ + Proxy of C++ generic_linput_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr filesize = _swig_property(_idaapi.generic_linput_t_filesize_get, _idaapi.generic_linput_t_filesize_set) blocksize = _swig_property(_idaapi.generic_linput_t_blocksize_get, _idaapi.generic_linput_t_blocksize_set) def read(self, *args): - """read(self, off, buffer, nbytes) -> ssize_t""" + """ + read(self, off, buffer, nbytes) -> ssize_t + """ return _idaapi.generic_linput_t_read(self, *args) __swig_destroy__ = _idaapi.delete_generic_linput_t @@ -24106,14 +25480,18 @@ generic_linput_t_swigregister = _idaapi.generic_linput_t_swigregister generic_linput_t_swigregister(generic_linput_t) class generic_linput64_t(object): - """Proxy of C++ generic_linput64_t class""" + """ + Proxy of C++ generic_linput64_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr filesize = _swig_property(_idaapi.generic_linput64_t_filesize_get, _idaapi.generic_linput64_t_filesize_set) blocksize = _swig_property(_idaapi.generic_linput64_t_blocksize_get, _idaapi.generic_linput64_t_blocksize_set) def read64(self, *args): - """read64(self, off, buffer, nbytes) -> ssize_t""" + """ + read64(self, off, buffer, nbytes) -> ssize_t + """ return _idaapi.generic_linput64_t_read64(self, *args) __swig_destroy__ = _idaapi.delete_generic_linput64_t @@ -24123,39 +25501,57 @@ generic_linput64_t_swigregister(generic_linput64_t) def create_generic_linput(*args): - """create_generic_linput(gl) -> linput_t *""" + """ + create_generic_linput(gl) -> linput_t * + """ return _idaapi.create_generic_linput(*args) def create_generic_linput64(*args): - """create_generic_linput64(gl) -> linput_t *""" + """ + create_generic_linput64(gl) -> linput_t * + """ return _idaapi.create_generic_linput64(*args) def create_bytearray_linput(*args): - """create_bytearray_linput(start, size) -> linput_t *""" + """ + create_bytearray_linput(start, size) -> linput_t * + """ return _idaapi.create_bytearray_linput(*args) def create_memory_linput(*args): - """create_memory_linput(start, size) -> linput_t *""" + """ + create_memory_linput(start, size) -> linput_t * + """ return _idaapi.create_memory_linput(*args) def get_linput_type(*args): - """get_linput_type(li) -> linput_type_t""" + """ + get_linput_type(li) -> linput_type_t + """ return _idaapi.get_linput_type(*args) class linput_buffer_t(object): - """Proxy of C++ linput_buffer_t class""" + """ + Proxy of C++ linput_buffer_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, linput, size=0) -> linput_buffer_t""" + def __init__(self, *args): + """ + __init__(self, linput, size=0) -> linput_buffer_t + """ this = _idaapi.new_linput_buffer_t(*args) try: self.this.append(this) except: self.this = this def read(self, *args): - """read(self, buf, n) -> ssize_t""" + """ + read(self, buf, n) -> ssize_t + """ return _idaapi.linput_buffer_t_read(self, *args) def eof(self, *args): - """eof(self) -> bool""" + """ + eof(self) -> bool + """ return _idaapi.linput_buffer_t_eof(self, *args) __swig_destroy__ = _idaapi.delete_linput_buffer_t @@ -24164,299 +25560,500 @@ linput_buffer_t_swigregister = _idaapi.linput_buffer_t_swigregister linput_buffer_t_swigregister(linput_buffer_t) class loader_input_t(object): - """Proxy of C++ loader_input_t class""" + """ + Proxy of C++ loader_input_t class + + + A helper class to work with linput_t related functions. + This class is also used by file loaders scripts. + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr __idc_cvt_id__ = _swig_property(_idaapi.loader_input_t___idc_cvt_id___get, _idaapi.loader_input_t___idc_cvt_id___set) - def __init__(self, *args): - """__init__(self, pycobject=None) -> loader_input_t""" + def __init__(self, *args): + """ + __init__(self, pycobject=None) -> loader_input_t + + + Closes the file + """ this = _idaapi.new_loader_input_t(*args) try: self.this.append(this) except: self.this = this def close(self, *args): - """close(self)""" + """ + close(self) + """ return _idaapi.loader_input_t_close(self, *args) __swig_destroy__ = _idaapi.delete_loader_input_t __del__ = lambda self : None; def open(self, *args): - """open(self, filename, remote=False) -> bool""" + """ + open(self, filename, remote=False) -> bool + + + Opens a file (or a remote file) + @return: Boolean + """ return _idaapi.loader_input_t_open(self, *args) def set_linput(self, *args): - """set_linput(self, linput)""" + """ + set_linput(self, linput) + + + Links the current loader_input_t instance to a linput_t instance + """ return _idaapi.loader_input_t_set_linput(self, *args) def from_linput(*args): - """from_linput(linput) -> loader_input_t""" + """ + from_linput(linput) -> loader_input_t + """ return _idaapi.loader_input_t_from_linput(*args) from_linput = staticmethod(from_linput) def from_cobject(*args): - """from_cobject(pycobject) -> loader_input_t""" + """ + from_cobject(pycobject) -> loader_input_t + """ return _idaapi.loader_input_t_from_cobject(*args) from_cobject = staticmethod(from_cobject) def from_fp(*args): - """from_fp(fp) -> loader_input_t""" + """ + from_fp(fp) -> loader_input_t + + + A static method to construct an instance from a FILE* + """ return _idaapi.loader_input_t_from_fp(*args) from_fp = staticmethod(from_fp) def get_linput(self, *args): - """get_linput(self) -> linput_t *""" + """ + get_linput(self) -> linput_t * + """ return _idaapi.loader_input_t_get_linput(self, *args) def open_memory(self, *args): - """open_memory(self, start, size=0) -> bool""" + """ + open_memory(self, start, size=0) -> bool + + + Create a linput for process memory (By internally calling idaapi.create_memory_linput()) + This linput will use dbg->read_memory() to read data + @param start: starting address of the input + @param size: size of the memory area to represent as linput + if unknown, may be passed as 0 + """ return _idaapi.loader_input_t_open_memory(self, *args) def seek(self, *args): - """seek(self, pos, whence=SEEK_SET) -> int32""" + """ + seek(self, pos, whence=SEEK_SET) -> int32 + + + Set input source position + @return: the new position (not 0 as fseek!) + """ return _idaapi.loader_input_t_seek(self, *args) def tell(self, *args): - """tell(self) -> int32""" + """ + tell(self) -> int32 + + + Returns the current position + """ return _idaapi.loader_input_t_tell(self, *args) def getz(self, *args): - """getz(self, sz, fpos=-1) -> PyObject *""" + """ + getz(self, sz, fpos=-1) -> PyObject * + + + Returns a zero terminated string at the given position + @param sz: maximum size of the string + @param fpos: if != -1 then seek will be performed before reading + @return: The string or None on failure. + """ return _idaapi.loader_input_t_getz(self, *args) def gets(self, *args): - """gets(self, len) -> PyObject *""" + """ + gets(self, len) -> PyObject * + + + Reads a line from the input file. Returns the read line or None + """ return _idaapi.loader_input_t_gets(self, *args) def read(self, *args): - """read(self, size) -> PyObject *""" + """ + read(self, size) -> PyObject * + + + Reads from the file. Returns the buffer or None + """ return _idaapi.loader_input_t_read(self, *args) def opened(self, *args): - """opened(self) -> bool""" + """ + opened(self) -> bool + + + Checks if the file is opened or not + """ return _idaapi.loader_input_t_opened(self, *args) def readbytes(self, *args): - """readbytes(self, size, big_endian) -> PyObject *""" + """ + readbytes(self, size, big_endian) -> PyObject * + + + Similar to read() but it respect the endianness + """ return _idaapi.loader_input_t_readbytes(self, *args) def file2base(self, *args): - """file2base(self, pos, ea1, ea2, patchable) -> int""" + """ + file2base(self, pos, ea1, ea2, patchable) -> int + + + Load portion of file into the database + This function will include (ea1..ea2) into the addressing space of the + program (make it enabled) + @param li: pointer ot input source + @param pos: position in the file + @param (ea1..ea2): range of destination linear addresses + @param patchable: should the kernel remember correspondance of + file offsets to linear addresses. + @return: 1-ok,0-read error, a warning is displayed + """ return _idaapi.loader_input_t_file2base(self, *args) def size(self, *args): - """size(self) -> int32""" + """ + size(self) -> int32 + """ return _idaapi.loader_input_t_size(self, *args) def filename(self, *args): - """filename(self) -> PyObject *""" + """ + filename(self) -> PyObject * + """ return _idaapi.loader_input_t_filename(self, *args) def get_char(self, *args): - """get_char(self) -> PyObject *""" + """ + get_char(self) -> PyObject * + + + Reads a single character from the file. Returns None if EOF or the read character + """ return _idaapi.loader_input_t_get_char(self, *args) loader_input_t_swigregister = _idaapi.loader_input_t_swigregister loader_input_t_swigregister(loader_input_t) def loader_input_t_from_linput(*args): - """loader_input_t_from_linput(linput) -> loader_input_t""" + """ + loader_input_t_from_linput(linput) -> loader_input_t + """ return _idaapi.loader_input_t_from_linput(*args) def loader_input_t_from_cobject(*args): - """loader_input_t_from_cobject(pycobject) -> loader_input_t""" + """ + loader_input_t_from_cobject(pycobject) -> loader_input_t + """ return _idaapi.loader_input_t_from_cobject(*args) def loader_input_t_from_fp(*args): - """loader_input_t_from_fp(fp) -> loader_input_t""" + """ + loader_input_t_from_fp(fp) -> loader_input_t + """ return _idaapi.loader_input_t_from_fp(*args) def enumerate_files(*args): - """enumerate_files(path, fname, callback) -> PyObject *""" + """ + enumerate_files(path, fname, callback) -> PyObject * + + + Enumerate files in the specified directory while the callback returns 0. + @param path: directory to enumerate files in + @param fname: mask of file names to enumerate + @param callback: a callable object that takes the filename as + its first argument and it returns 0 to continue + enumeration or non-zero to stop enumeration. + @return: + None in case of script errors + tuple(code, fname) : If the callback returns non-zero + """ return _idaapi.enumerate_files(*args) # def enumerate_system_files(subdir, fname, callback): - """Similar to enumerate_files() however it searches inside IDA directory or its subdirectories""" + """ + Similar to enumerate_files() however it searches inside IDA directory or its subdirectories + """ return enumerate_files(idadir(subdir), fname, callback) # def get_entry_qty(*args): - """get_entry_qty() -> size_t""" + """ + get_entry_qty() -> size_t + """ return _idaapi.get_entry_qty(*args) def add_entry(*args): - """add_entry(ord, ea, name, makecode) -> bool""" + """ + add_entry(ord, ea, name, makecode) -> bool + """ return _idaapi.add_entry(*args) def get_entry_ordinal(*args): - """get_entry_ordinal(idx) -> uval_t""" + """ + get_entry_ordinal(idx) -> uval_t + """ return _idaapi.get_entry_ordinal(*args) def get_entry(*args): - """get_entry(ord) -> ea_t""" + """ + get_entry(ord) -> ea_t + """ return _idaapi.get_entry(*args) def get_entry_name(*args): - """get_entry_name(ord) -> ssize_t""" + """ + get_entry_name(ord) -> ssize_t + """ return _idaapi.get_entry_name(*args) def rename_entry(*args): - """rename_entry(ord, name) -> bool""" + """ + rename_entry(ord, name) -> bool + """ return _idaapi.rename_entry(*args) ENUM_FLAGS_FROMTIL = _idaapi.ENUM_FLAGS_FROMTIL ENUM_FLAGS_WIDTH = _idaapi.ENUM_FLAGS_WIDTH -ENUM_FLAGS_GHOST = _idaapi.ENUM_FLAGS_GHOST def get_enum_qty(*args): - """get_enum_qty() -> size_t""" + """ + get_enum_qty() -> size_t + """ return _idaapi.get_enum_qty(*args) def getn_enum(*args): - """getn_enum(n) -> enum_t""" + """ + getn_enum(n) -> enum_t + """ return _idaapi.getn_enum(*args) def get_enum_idx(*args): - """get_enum_idx(id) -> uval_t""" + """ + get_enum_idx(id) -> uval_t + """ return _idaapi.get_enum_idx(*args) def get_enum(*args): - """get_enum(name) -> enum_t""" + """ + get_enum(name) -> enum_t + """ return _idaapi.get_enum(*args) def is_bf(*args): - """is_bf(id) -> bool""" + """ + is_bf(id) -> bool + """ return _idaapi.is_bf(*args) def is_enum_hidden(*args): - """is_enum_hidden(id) -> bool""" + """ + is_enum_hidden(id) -> bool + """ return _idaapi.is_enum_hidden(*args) def set_enum_hidden(*args): - """set_enum_hidden(id, hidden) -> bool""" + """ + set_enum_hidden(id, hidden) -> bool + """ return _idaapi.set_enum_hidden(*args) def is_enum_fromtil(*args): - """is_enum_fromtil(id) -> bool""" + """ + is_enum_fromtil(id) -> bool + """ return _idaapi.is_enum_fromtil(*args) def set_enum_fromtil(*args): - """set_enum_fromtil(id, fromtil) -> bool""" + """ + set_enum_fromtil(id, fromtil) -> bool + """ return _idaapi.set_enum_fromtil(*args) -def is_ghost_enum(*args): - """is_ghost_enum(id) -> bool""" - return _idaapi.is_ghost_enum(*args) - -def set_enum_ghost(*args): - """set_enum_ghost(id, ghost) -> bool""" - return _idaapi.set_enum_ghost(*args) - def get_enum_name(*args): - """get_enum_name(id) -> ssize_t""" + """ + get_enum_name(id) -> ssize_t + """ return _idaapi.get_enum_name(*args) def get_enum_width(*args): - """get_enum_width(id) -> size_t""" + """ + get_enum_width(id) -> size_t + """ return _idaapi.get_enum_width(*args) def set_enum_width(*args): - """set_enum_width(id, width) -> bool""" + """ + set_enum_width(id, width) -> bool + """ return _idaapi.set_enum_width(*args) def get_enum_cmt(*args): - """get_enum_cmt(id, repeatable) -> ssize_t""" + """ + get_enum_cmt(id, repeatable) -> ssize_t + """ return _idaapi.get_enum_cmt(*args) def get_enum_size(*args): - """get_enum_size(id) -> size_t""" + """ + get_enum_size(id) -> size_t + """ return _idaapi.get_enum_size(*args) def get_enum_flag(*args): - """get_enum_flag(id) -> flags_t""" + """ + get_enum_flag(id) -> flags_t + """ return _idaapi.get_enum_flag(*args) def get_enum_member_by_name(*args): - """get_enum_member_by_name(name) -> const_t""" + """ + get_enum_member_by_name(name) -> const_t + """ return _idaapi.get_enum_member_by_name(*args) def get_enum_member_value(*args): - """get_enum_member_value(id) -> uval_t""" + """ + get_enum_member_value(id) -> uval_t + """ return _idaapi.get_enum_member_value(*args) def get_enum_member_enum(*args): - """get_enum_member_enum(id) -> enum_t""" + """ + get_enum_member_enum(id) -> enum_t + """ return _idaapi.get_enum_member_enum(*args) def get_enum_member_bmask(*args): - """get_enum_member_bmask(id) -> bmask_t""" + """ + get_enum_member_bmask(id) -> bmask_t + """ return _idaapi.get_enum_member_bmask(*args) def get_enum_member(*args): - """get_enum_member(id, value, serial, mask) -> const_t""" + """ + get_enum_member(id, value, serial, mask) -> const_t + """ return _idaapi.get_enum_member(*args) def get_first_bmask(*args): - """get_first_bmask(id) -> bmask_t""" + """ + get_first_bmask(id) -> bmask_t + """ return _idaapi.get_first_bmask(*args) def get_last_bmask(*args): - """get_last_bmask(id) -> bmask_t""" + """ + get_last_bmask(id) -> bmask_t + """ return _idaapi.get_last_bmask(*args) def get_next_bmask(*args): - """get_next_bmask(id, bmask) -> bmask_t""" + """ + get_next_bmask(id, bmask) -> bmask_t + """ return _idaapi.get_next_bmask(*args) def get_prev_bmask(*args): - """get_prev_bmask(id, bmask) -> bmask_t""" + """ + get_prev_bmask(id, bmask) -> bmask_t + """ return _idaapi.get_prev_bmask(*args) def get_first_enum_member(*args): - """get_first_enum_member(id, bmask=(bmask_t(-1))) -> uval_t""" + """ + get_first_enum_member(id, bmask=(bmask_t(-1))) -> uval_t + """ return _idaapi.get_first_enum_member(*args) def get_last_enum_member(*args): - """get_last_enum_member(id, bmask=(bmask_t(-1))) -> uval_t""" + """ + get_last_enum_member(id, bmask=(bmask_t(-1))) -> uval_t + """ return _idaapi.get_last_enum_member(*args) def get_next_enum_member(*args): - """get_next_enum_member(id, value, bmask=(bmask_t(-1))) -> uval_t""" + """ + get_next_enum_member(id, value, bmask=(bmask_t(-1))) -> uval_t + """ return _idaapi.get_next_enum_member(*args) def get_prev_enum_member(*args): - """get_prev_enum_member(id, value, bmask=(bmask_t(-1))) -> uval_t""" + """ + get_prev_enum_member(id, value, bmask=(bmask_t(-1))) -> uval_t + """ return _idaapi.get_prev_enum_member(*args) def get_enum_member_name(*args): - """get_enum_member_name(id) -> ssize_t""" + """ + get_enum_member_name(id) -> ssize_t + """ return _idaapi.get_enum_member_name(*args) def get_enum_member_cmt(*args): - """get_enum_member_cmt(id, repeatable) -> ssize_t""" + """ + get_enum_member_cmt(id, repeatable) -> ssize_t + """ return _idaapi.get_enum_member_cmt(*args) def get_first_serial_enum_member(*args): - """get_first_serial_enum_member(id, value, bmask) -> const_t""" + """ + get_first_serial_enum_member(id, value, bmask) -> const_t + """ return _idaapi.get_first_serial_enum_member(*args) def get_last_serial_enum_member(*args): - """get_last_serial_enum_member(id, value, bmask) -> const_t""" + """ + get_last_serial_enum_member(id, value, bmask) -> const_t + """ return _idaapi.get_last_serial_enum_member(*args) def get_next_serial_enum_member(*args): - """get_next_serial_enum_member(first_cid, in_out_serial) -> const_t""" + """ + get_next_serial_enum_member(first_cid, in_out_serial) -> const_t + """ return _idaapi.get_next_serial_enum_member(*args) def get_prev_serial_enum_member(*args): - """get_prev_serial_enum_member(first_cid, in_out_serial) -> const_t""" + """ + get_prev_serial_enum_member(first_cid, in_out_serial) -> const_t + """ return _idaapi.get_prev_serial_enum_member(*args) class enum_member_visitor_t(object): - """Proxy of C++ enum_member_visitor_t class""" + """ + Proxy of C++ enum_member_visitor_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr def visit_enum_member(self, *args): - """visit_enum_member(self, cid, value) -> int""" + """ + visit_enum_member(self, cid, value) -> int + """ return _idaapi.enum_member_visitor_t_visit_enum_member(self, *args) __swig_destroy__ = _idaapi.delete_enum_member_visitor_t @@ -24467,47 +26064,69 @@ MAX_ENUM_SERIAL = cvar.MAX_ENUM_SERIAL def for_all_enum_members(*args): - """for_all_enum_members(id, cv) -> int""" + """ + for_all_enum_members(id, cv) -> int + """ return _idaapi.for_all_enum_members(*args) def get_enum_member_serial(*args): - """get_enum_member_serial(cid) -> uchar""" + """ + get_enum_member_serial(cid) -> uchar + """ return _idaapi.get_enum_member_serial(*args) def get_enum_type_ordinal(*args): - """get_enum_type_ordinal(id) -> int32""" + """ + get_enum_type_ordinal(id) -> int32 + """ return _idaapi.get_enum_type_ordinal(*args) def set_enum_type_ordinal(*args): - """set_enum_type_ordinal(id, ord)""" + """ + set_enum_type_ordinal(id, ord) + """ return _idaapi.set_enum_type_ordinal(*args) def add_enum(*args): - """add_enum(idx, name, flag) -> enum_t""" + """ + add_enum(idx, name, flag) -> enum_t + """ return _idaapi.add_enum(*args) def del_enum(*args): - """del_enum(id)""" + """ + del_enum(id) + """ return _idaapi.del_enum(*args) def set_enum_idx(*args): - """set_enum_idx(id, idx) -> bool""" + """ + set_enum_idx(id, idx) -> bool + """ return _idaapi.set_enum_idx(*args) def set_enum_bf(*args): - """set_enum_bf(id, bf) -> bool""" + """ + set_enum_bf(id, bf) -> bool + """ return _idaapi.set_enum_bf(*args) def set_enum_name(*args): - """set_enum_name(id, name) -> bool""" + """ + set_enum_name(id, name) -> bool + """ return _idaapi.set_enum_name(*args) def set_enum_cmt(*args): - """set_enum_cmt(id, cmt, repeatable) -> bool""" + """ + set_enum_cmt(id, cmt, repeatable) -> bool + """ return _idaapi.set_enum_cmt(*args) def add_enum_member(*args): - """add_enum_member(id, name, value, bmask=(bmask_t(-1))) -> int""" + """ + add_enum_member(id, name, value, bmask=(bmask_t(-1))) -> int + """ return _idaapi.add_enum_member(*args) ENUM_MEMBER_ERROR_NAME = _idaapi.ENUM_MEMBER_ERROR_NAME ENUM_MEMBER_ERROR_VALUE = _idaapi.ENUM_MEMBER_ERROR_VALUE @@ -24516,43 +26135,75 @@ ENUM_MEMBER_ERROR_MASK = _idaapi.ENUM_MEMBER_ERROR_MASK ENUM_MEMBER_ERROR_ILLV = _idaapi.ENUM_MEMBER_ERROR_ILLV def del_enum_member(*args): - """del_enum_member(id, value, serial, bmask) -> bool""" + """ + del_enum_member(id, value, serial, bmask) -> bool + """ return _idaapi.del_enum_member(*args) def set_enum_member_name(*args): - """set_enum_member_name(id, name) -> bool""" + """ + set_enum_member_name(id, name) -> bool + """ return _idaapi.set_enum_member_name(*args) def set_enum_member_cmt(*args): - """set_enum_member_cmt(id, cmt, repeatable) -> bool""" + """ + set_enum_member_cmt(id, cmt, repeatable) -> bool + """ return _idaapi.set_enum_member_cmt(*args) def is_one_bit_mask(*args): - """is_one_bit_mask(mask) -> bool""" + """ + is_one_bit_mask(mask) -> bool + """ return _idaapi.is_one_bit_mask(*args) def get_bmask_node(*args): - """get_bmask_node(id, bmask) -> netnode""" + """ + get_bmask_node(id, bmask) -> netnode + """ return _idaapi.get_bmask_node(*args) def set_bmask_name(*args): - """set_bmask_name(id, bmask, name) -> bool""" + """ + set_bmask_name(id, bmask, name) -> bool + """ return _idaapi.set_bmask_name(*args) def get_bmask_name(*args): - """get_bmask_name(id, bmask) -> ssize_t""" + """ + get_bmask_name(id, bmask) -> ssize_t + """ return _idaapi.get_bmask_name(*args) def set_bmask_cmt(*args): - """set_bmask_cmt(id, bmask, cmt, repeatable) -> bool""" + """ + set_bmask_cmt(id, bmask, cmt, repeatable) -> bool + """ return _idaapi.set_bmask_cmt(*args) def get_bmask_cmt(*args): - """get_bmask_cmt(id, bmask, repeatable) -> ssize_t""" + """ + get_bmask_cmt(id, bmask, repeatable) -> ssize_t + """ return _idaapi.get_bmask_cmt(*args) +def enum_encode(*args): + """ + enum_encode(id, serial) -> uval_t + """ + return _idaapi.enum_encode(*args) + +def enum_decode(*args): + """ + enum_decode(code) -> enum_t + """ + return _idaapi.enum_decode(*args) + def add_const(*args): - """add_const(id, name, value, bmask=(bmask_t(-1))) -> int""" + """ + add_const(id, name, value, bmask=(bmask_t(-1))) -> int + """ return _idaapi.add_const(*args) CONST_ERROR_NAME = _idaapi.CONST_ERROR_NAME CONST_ERROR_VALUE = _idaapi.CONST_ERROR_VALUE @@ -24561,83 +26212,123 @@ CONST_ERROR_MASK = _idaapi.CONST_ERROR_MASK CONST_ERROR_ILLV = _idaapi.CONST_ERROR_ILLV def del_const(*args): - """del_const(id, value, serial, bmask) -> bool""" + """ + del_const(id, value, serial, bmask) -> bool + """ return _idaapi.del_const(*args) def set_const_name(*args): - """set_const_name(id, name) -> bool""" + """ + set_const_name(id, name) -> bool + """ return _idaapi.set_const_name(*args) def set_const_cmt(*args): - """set_const_cmt(id, cmt, repeatable) -> bool""" + """ + set_const_cmt(id, cmt, repeatable) -> bool + """ return _idaapi.set_const_cmt(*args) def get_const_by_name(*args): - """get_const_by_name(name) -> const_t""" + """ + get_const_by_name(name) -> const_t + """ return _idaapi.get_const_by_name(*args) def get_const_value(*args): - """get_const_value(id) -> uval_t""" + """ + get_const_value(id) -> uval_t + """ return _idaapi.get_const_value(*args) def get_const_enum(*args): - """get_const_enum(id) -> enum_t""" + """ + get_const_enum(id) -> enum_t + """ return _idaapi.get_const_enum(*args) def get_const_bmask(*args): - """get_const_bmask(id) -> bmask_t""" + """ + get_const_bmask(id) -> bmask_t + """ return _idaapi.get_const_bmask(*args) def get_const(*args): - """get_const(id, value, serial, mask) -> const_t""" + """ + get_const(id, value, serial, mask) -> const_t + """ return _idaapi.get_const(*args) def get_first_const(*args): - """get_first_const(id, bmask=(bmask_t(-1))) -> uval_t""" + """ + get_first_const(id, bmask=(bmask_t(-1))) -> uval_t + """ return _idaapi.get_first_const(*args) def get_last_const(*args): - """get_last_const(id, bmask=(bmask_t(-1))) -> uval_t""" + """ + get_last_const(id, bmask=(bmask_t(-1))) -> uval_t + """ return _idaapi.get_last_const(*args) def get_next_const(*args): - """get_next_const(id, value, bmask=(bmask_t(-1))) -> uval_t""" + """ + get_next_const(id, value, bmask=(bmask_t(-1))) -> uval_t + """ return _idaapi.get_next_const(*args) def get_prev_const(*args): - """get_prev_const(id, value, bmask=(bmask_t(-1))) -> uval_t""" + """ + get_prev_const(id, value, bmask=(bmask_t(-1))) -> uval_t + """ return _idaapi.get_prev_const(*args) def get_const_name(*args): - """get_const_name(id) -> ssize_t""" + """ + get_const_name(id) -> ssize_t + """ return _idaapi.get_const_name(*args) def get_const_cmt(*args): - """get_const_cmt(id, repeatable) -> ssize_t""" + """ + get_const_cmt(id, repeatable) -> ssize_t + """ return _idaapi.get_const_cmt(*args) def get_first_serial_const(*args): - """get_first_serial_const(id, value, bmask) -> const_t""" + """ + get_first_serial_const(id, value, bmask) -> const_t + """ return _idaapi.get_first_serial_const(*args) def get_last_serial_const(*args): - """get_last_serial_const(id, value, bmask) -> const_t""" + """ + get_last_serial_const(id, value, bmask) -> const_t + """ return _idaapi.get_last_serial_const(*args) def get_next_serial_const(*args): - """get_next_serial_const(first_cid) -> const_t""" + """ + get_next_serial_const(first_cid) -> const_t + """ return _idaapi.get_next_serial_const(*args) def get_prev_serial_const(*args): - """get_prev_serial_const(first_cid) -> const_t""" + """ + get_prev_serial_const(first_cid) -> const_t + """ return _idaapi.get_prev_serial_const(*args) class const_visitor_t(object): - """Proxy of C++ const_visitor_t class""" + """ + Proxy of C++ const_visitor_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr def visit_const(self, *args): - """visit_const(self, cid, value) -> int""" + """ + visit_const(self, cid, value) -> int + """ return _idaapi.const_visitor_t_visit_const(self, *args) __swig_destroy__ = _idaapi.delete_const_visitor_t @@ -24647,151 +26338,223 @@ const_visitor_t_swigregister(const_visitor_t) def for_all_consts(*args): - """for_all_consts(id, cv) -> int""" + """ + for_all_consts(id, cv) -> int + """ return _idaapi.for_all_consts(*args) def get_const_serial(*args): - """get_const_serial(cid) -> uchar""" + """ + get_const_serial(cid) -> uchar + """ return _idaapi.get_const_serial(*args) def py_get_call_idc_func(*args): - """py_get_call_idc_func() -> size_t""" + """ + py_get_call_idc_func() -> size_t + """ return _idaapi.py_get_call_idc_func(*args) def pyw_register_idc_func(*args): - """pyw_register_idc_func(name, args, py_fp) -> size_t""" + """ + pyw_register_idc_func(name, args, py_fp) -> size_t + """ return _idaapi.pyw_register_idc_func(*args) def pyw_unregister_idc_func(*args): - """pyw_unregister_idc_func(ctxptr) -> bool""" + """ + pyw_unregister_idc_func(ctxptr) -> bool + """ return _idaapi.pyw_unregister_idc_func(*args) def py_set_idc_func_ex(*args): - """py_set_idc_func_ex(name, fp_ptr, args, flags) -> bool""" + """ + py_set_idc_func_ex(name, fp_ptr, args, flags) -> bool + """ return _idaapi.py_set_idc_func_ex(*args) def CompileEx(*args): - """CompileEx(file, del_macros) -> bool""" + """ + CompileEx(file, del_macros) -> bool + """ return _idaapi.CompileEx(*args) def Compile(*args): - """Compile(file) -> bool""" + """ + Compile(file) -> bool + """ return _idaapi.Compile(*args) def calcexpr(*args): - """calcexpr(where, line, rv) -> bool""" + """ + calcexpr(where, line, rv) -> bool + """ return _idaapi.calcexpr(*args) def calc_idc_expr(*args): - """calc_idc_expr(where, line, rv) -> bool""" + """ + calc_idc_expr(where, line, rv) -> bool + """ return _idaapi.calc_idc_expr(*args) def CompileLine(*args): - """CompileLine(line) -> bool""" + """ + CompileLine(line) -> bool + """ return _idaapi.CompileLine(*args) IDC_LANG_EXT = _idaapi.IDC_LANG_EXT def VarInt64(*args): - """VarInt64(v) -> error_t""" + """ + VarInt64(v) -> error_t + """ return _idaapi.VarInt64(*args) def VarString2(*args): - """VarString2(v) -> error_t""" + """ + VarString2(v) -> error_t + """ return _idaapi.VarString2(*args) def VarObject(*args): - """VarObject(v, icls=None) -> error_t""" + """ + VarObject(v, icls=None) -> error_t + """ return _idaapi.VarObject(*args) def VarCopy(*args): - """VarCopy(dst, src) -> error_t""" + """ + VarCopy(dst, src) -> error_t + """ return _idaapi.VarCopy(*args) def VarSwap(*args): - """VarSwap(v1, v2)""" + """ + VarSwap(v1, v2) + """ return _idaapi.VarSwap(*args) def VarGetClassName(*args): - """VarGetClassName(obj, name) -> error_t""" + """ + VarGetClassName(obj, name) -> error_t + """ return _idaapi.VarGetClassName(*args) def VarGetAttr(*args): - """VarGetAttr(obj, attr, res, may_use_getattr=False) -> error_t""" + """ + VarGetAttr(obj, attr, res, may_use_getattr=False) -> error_t + """ return _idaapi.VarGetAttr(*args) def VarSetAttr(*args): - """VarSetAttr(obj, attr, value, may_use_setattr=False) -> error_t""" + """ + VarSetAttr(obj, attr, value, may_use_setattr=False) -> error_t + """ return _idaapi.VarSetAttr(*args) def VarDelAttr(*args): - """VarDelAttr(obj, attr) -> error_t""" + """ + VarDelAttr(obj, attr) -> error_t + """ return _idaapi.VarDelAttr(*args) def VarFirstAttr(*args): - """VarFirstAttr(obj) -> char const *""" + """ + VarFirstAttr(obj) -> char const * + """ return _idaapi.VarFirstAttr(*args) def VarLastAttr(*args): - """VarLastAttr(obj) -> char const *""" + """ + VarLastAttr(obj) -> char const * + """ return _idaapi.VarLastAttr(*args) def VarNextAttr(*args): - """VarNextAttr(obj, attr) -> char const *""" + """ + VarNextAttr(obj, attr) -> char const * + """ return _idaapi.VarNextAttr(*args) def VarPrevAttr(*args): - """VarPrevAttr(obj, attr) -> char const *""" + """ + VarPrevAttr(obj, attr) -> char const * + """ return _idaapi.VarPrevAttr(*args) def VarAssign(*args): - """VarAssign(dst, src) -> error_t""" + """ + VarAssign(dst, src) -> error_t + """ return _idaapi.VarAssign(*args) def VarMove(*args): - """VarMove(dst, src) -> error_t""" + """ + VarMove(dst, src) -> error_t + """ return _idaapi.VarMove(*args) def VarPrint(*args): - """VarPrint(v, name=None, indent=0) -> bool""" + """ + VarPrint(out, v, name=None, indent=0) + """ return _idaapi.VarPrint(*args) def VarGetSlice(*args): - """VarGetSlice(v, i1, i2, res, flags=0) -> error_t""" + """ + VarGetSlice(v, i1, i2, res, flags=0) -> error_t + """ return _idaapi.VarGetSlice(*args) VARSLICE_SINGLE = _idaapi.VARSLICE_SINGLE def VarSetSlice(*args): - """VarSetSlice(v, i1, i2, _in, flags=0) -> error_t""" + """ + VarSetSlice(v, i1, i2, _in, flags=0) -> error_t + """ return _idaapi.VarSetSlice(*args) def add_idc_class(*args): - """add_idc_class(name, super=None) -> idc_class_t *""" + """ + add_idc_class(name, super=None) -> idc_class_t * + """ return _idaapi.add_idc_class(*args) def find_idc_class(*args): - """find_idc_class(name) -> idc_class_t *""" + """ + find_idc_class(name) -> idc_class_t * + """ return _idaapi.find_idc_class(*args) def VarDeref(*args): - """VarDeref(v, vref_flags) -> idc_value_t""" + """ + VarDeref(v, vref_flags) -> idc_value_t + """ return _idaapi.VarDeref(*args) VREF_LOOP = _idaapi.VREF_LOOP VREF_ONCE = _idaapi.VREF_ONCE VREF_COPY = _idaapi.VREF_COPY def VarRef(*args): - """VarRef(ref, v) -> bool""" + """ + VarRef(ref, v) -> bool + """ return _idaapi.VarRef(*args) def add_idc_gvar(*args): - """add_idc_gvar(name) -> idc_value_t""" + """ + add_idc_gvar(name) -> idc_value_t + """ return _idaapi.add_idc_gvar(*args) def find_idc_gvar(*args): - """find_idc_gvar(name) -> idc_value_t""" + """ + find_idc_gvar(name) -> idc_value_t + """ return _idaapi.find_idc_gvar(*args) class idc_value_t(object): - """Proxy of C++ idc_value_t class""" + """ + Proxy of C++ idc_value_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr vtype = _swig_property(_idaapi.idc_value_t_vtype_get, _idaapi.idc_value_t_vtype_set) @@ -24803,7 +26566,7 @@ class idc_value_t(object): pvoid = _swig_property(_idaapi.idc_value_t_pvoid_get, _idaapi.idc_value_t_pvoid_set) i64 = _swig_property(_idaapi.idc_value_t_i64_get, _idaapi.idc_value_t_i64_set) reserve = _swig_property(_idaapi.idc_value_t_reserve_get, _idaapi.idc_value_t_reserve_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self, n=0) -> idc_value_t __init__(self, r) -> idc_value_t @@ -24816,7 +26579,9 @@ class idc_value_t(object): __swig_destroy__ = _idaapi.delete_idc_value_t __del__ = lambda self : None; def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.idc_value_t_clear(self, *args) def qstr(self, *args): @@ -24827,31 +26592,45 @@ class idc_value_t(object): return _idaapi.idc_value_t_qstr(self, *args) def c_str(self, *args): - """c_str(self) -> char const *""" + """ + c_str(self) -> char const * + """ return _idaapi.idc_value_t_c_str(self, *args) def u_str(self, *args): - """u_str(self) -> uchar const *""" + """ + u_str(self) -> uchar const * + """ return _idaapi.idc_value_t_u_str(self, *args) def swap(self, *args): - """swap(self, v)""" + """ + swap(self, v) + """ return _idaapi.idc_value_t_swap(self, *args) def is_zero(self, *args): - """is_zero(self) -> bool""" + """ + is_zero(self) -> bool + """ return _idaapi.idc_value_t_is_zero(self, *args) def is_integral(self, *args): - """is_integral(self) -> bool""" + """ + is_integral(self) -> bool + """ return _idaapi.idc_value_t_is_integral(self, *args) def is_convertible(self, *args): - """is_convertible(self) -> bool""" + """ + is_convertible(self) -> bool + """ return _idaapi.idc_value_t_is_convertible(self, *args) def _create_empty_string(self, *args): - """_create_empty_string(self)""" + """ + _create_empty_string(self) + """ return _idaapi.idc_value_t__create_empty_string(self, *args) def _set_string(self, *args): @@ -24863,11 +26642,15 @@ class idc_value_t(object): return _idaapi.idc_value_t__set_string(self, *args) def _set_long(self, *args): - """_set_long(self, v)""" + """ + _set_long(self, v) + """ return _idaapi.idc_value_t__set_long(self, *args) def create_empty_string(self, *args): - """create_empty_string(self)""" + """ + create_empty_string(self) + """ return _idaapi.idc_value_t_create_empty_string(self, *args) def set_string(self, *args): @@ -24879,19 +26662,27 @@ class idc_value_t(object): return _idaapi.idc_value_t_set_string(self, *args) def set_long(self, *args): - """set_long(self, v)""" + """ + set_long(self, v) + """ return _idaapi.idc_value_t_set_long(self, *args) def set_pvoid(self, *args): - """set_pvoid(self, p)""" + """ + set_pvoid(self, p) + """ return _idaapi.idc_value_t_set_pvoid(self, *args) def set_int64(self, *args): - """set_int64(self, v)""" + """ + set_int64(self, v) + """ return _idaapi.idc_value_t_set_int64(self, *args) def set_float(self, *args): - """set_float(self, f)""" + """ + set_float(self, f) + """ return _idaapi.idc_value_t_set_float(self, *args) idc_value_t_swigregister = _idaapi.idc_value_t_swigregister @@ -24908,12 +26699,14 @@ VT_INT64 = _idaapi.VT_INT64 VT_REF = _idaapi.VT_REF class idc_global_t(object): - """Proxy of C++ idc_global_t class""" + """ + Proxy of C++ idc_global_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr name = _swig_property(_idaapi.idc_global_t_name_get, _idaapi.idc_global_t_name_set) value = _swig_property(_idaapi.idc_global_t_value_get, _idaapi.idc_global_t_value_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> idc_global_t __init__(self, n) -> idc_global_t @@ -24929,90 +26722,132 @@ idc_global_t_swigregister(idc_global_t) eExecThrow = _idaapi.eExecThrow def install_extlang(*args): - """install_extlang(el) -> bool""" + """ + install_extlang(el) -> bool + """ return _idaapi.install_extlang(*args) def remove_extlang(*args): - """remove_extlang(el) -> bool""" + """ + remove_extlang(el) -> bool + """ return _idaapi.remove_extlang(*args) def select_extlang(*args): - """select_extlang(el) -> bool""" + """ + select_extlang(el) -> bool + """ return _idaapi.select_extlang(*args) def get_extlang_fileext(*args): - """get_extlang_fileext() -> char const *""" + """ + get_extlang_fileext() -> char const * + """ return _idaapi.get_extlang_fileext(*args) def find_extlang_by_ext(*args): - """find_extlang_by_ext(ext) -> extlang_t const *""" + """ + find_extlang_by_ext(ext) -> extlang_t const * + """ return _idaapi.find_extlang_by_ext(*args) def find_extlang_by_name(*args): - """find_extlang_by_name(name) -> extlang_t const *""" + """ + find_extlang_by_name(name) -> extlang_t const * + """ return _idaapi.find_extlang_by_name(*args) def get_idcpath(*args): - """get_idcpath() -> char const *""" + """ + get_idcpath() -> char const * + """ return _idaapi.get_idcpath(*args) def set_header_path(*args): - """set_header_path(path, add) -> bool""" + """ + set_header_path(path, add) -> bool + """ return _idaapi.set_header_path(*args) def get_idc_filename(*args): - """get_idc_filename(file) -> char *""" + """ + get_idc_filename(file) -> char * + """ return _idaapi.get_idc_filename(*args) def dosysfile(*args): - """dosysfile(complain_if_no_file, file) -> bool""" + """ + dosysfile(complain_if_no_file, file) -> bool + """ return _idaapi.dosysfile(*args) def execute(*args): - """execute(line) -> bool""" + """ + execute(line) -> bool + """ return _idaapi.execute(*args) CPL_DEL_MACROS = _idaapi.CPL_DEL_MACROS CPL_USE_LABELS = _idaapi.CPL_USE_LABELS CPL_ONLY_SAFE = _idaapi.CPL_ONLY_SAFE def extlang_compile_file_exists(*args): - """extlang_compile_file_exists(el=None) -> bool""" + """ + extlang_compile_file_exists(el=None) -> bool + """ return _idaapi.extlang_compile_file_exists(*args) def compile_script_file(*args): - """compile_script_file(file) -> bool""" + """ + compile_script_file(file) -> bool + """ return _idaapi.compile_script_file(*args) def extlang_unload_procmod(*args): - """extlang_unload_procmod(file) -> bool""" + """ + extlang_unload_procmod(file) -> bool + """ return _idaapi.extlang_unload_procmod(*args) def compile_script_func(*args): - """compile_script_func(name, current_ea, expr) -> bool""" + """ + compile_script_func(name, current_ea, expr) -> bool + """ return _idaapi.compile_script_func(*args) def extlang_set_attr_exists(*args): - """extlang_set_attr_exists() -> bool""" + """ + extlang_set_attr_exists() -> bool + """ return _idaapi.extlang_set_attr_exists(*args) def call_idc_method(*args): - """call_idc_method(obj, name, nargs, args, result) -> bool""" + """ + call_idc_method(obj, name, nargs, args, result) -> bool + """ return _idaapi.call_idc_method(*args) def extlang_call_method_exists(*args): - """extlang_call_method_exists() -> bool""" + """ + extlang_call_method_exists() -> bool + """ return _idaapi.extlang_call_method_exists(*args) def call_script_method(*args): - """call_script_method(obj, name, nargs, args, result) -> bool""" + """ + call_script_method(obj, name, nargs, args, result) -> bool + """ return _idaapi.call_script_method(*args) def extlang_run_statements_exists(*args): - """extlang_run_statements_exists(elang=None) -> bool""" + """ + extlang_run_statements_exists(elang=None) -> bool + """ return _idaapi.extlang_run_statements_exists(*args) def run_statements(*args): - """run_statements(str, elang=None) -> bool""" + """ + run_statements(str, elang=None) -> bool + """ return _idaapi.run_statements(*args) # try: @@ -25037,11 +26872,17 @@ except: # -------------------------------------------------------------------------- EXTFUN_BASE = 0x0001 -"""requires open database""" +""" +requires open database +""" EXTFUN_NORET = 0x0002 -"""does not return. the interpreter may clean up its state before calling it.""" +""" +does not return. the interpreter may clean up its state before calling it. +""" EXTFUN_SAFE = 0x0004 -"""thread safe function. may be called""" +""" +thread safe function. may be called +""" # -------------------------------------------------------------------------- class _IdcFunction(object): @@ -25128,7 +26969,9 @@ def set_idc_func_ex(name, fp=None, args=(), flags=0): # class fixup_data_t(object): - """Proxy of C++ fixup_data_t class""" + """ + Proxy of C++ fixup_data_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr type = _swig_property(_idaapi.fixup_data_t_type_get, _idaapi.fixup_data_t_type_set) @@ -25136,15 +26979,21 @@ class fixup_data_t(object): off = _swig_property(_idaapi.fixup_data_t_off_get, _idaapi.fixup_data_t_off_set) displacement = _swig_property(_idaapi.fixup_data_t_displacement_get, _idaapi.fixup_data_t_displacement_set) def is_custom(self, *args): - """is_custom(self) -> bool""" + """ + is_custom(self) -> bool + """ return _idaapi.fixup_data_t_is_custom(self, *args) def get_type(self, *args): - """get_type(self) -> uchar""" + """ + get_type(self) -> uchar + """ return _idaapi.fixup_data_t_get_type(self, *args) - def __init__(self, *args): - """__init__(self) -> fixup_data_t""" + def __init__(self, *args): + """ + __init__(self) -> fixup_data_t + """ this = _idaapi.new_fixup_data_t(*args) try: self.this.append(this) except: self.this = this @@ -25175,35 +27024,51 @@ FIXUP_CREATED = _idaapi.FIXUP_CREATED def set_fixup(*args): - """set_fixup(source, fp)""" + """ + set_fixup(source, fp) + """ return _idaapi.set_fixup(*args) def set_fixup_ex(*args): - """set_fixup_ex(source, fd, offset_base)""" + """ + set_fixup_ex(source, fd, offset_base) + """ return _idaapi.set_fixup_ex(*args) def del_fixup(*args): - """del_fixup(source)""" + """ + del_fixup(source) + """ return _idaapi.del_fixup(*args) def get_fixup(*args): - """get_fixup(source, fd) -> bool""" + """ + get_fixup(source, fd) -> bool + """ return _idaapi.get_fixup(*args) def get_first_fixup_ea(*args): - """get_first_fixup_ea() -> ea_t""" + """ + get_first_fixup_ea() -> ea_t + """ return _idaapi.get_first_fixup_ea(*args) def get_next_fixup_ea(*args): - """get_next_fixup_ea(ea) -> ea_t""" + """ + get_next_fixup_ea(ea) -> ea_t + """ return _idaapi.get_next_fixup_ea(*args) def get_prev_fixup_ea(*args): - """get_prev_fixup_ea(ea) -> ea_t""" + """ + get_prev_fixup_ea(ea) -> ea_t + """ return _idaapi.get_prev_fixup_ea(*args) def get_fixup_base(*args): - """get_fixup_base(source, fd) -> ea_t""" + """ + get_fixup_base(source, fd) -> ea_t + """ return _idaapi.get_fixup_base(*args) def get_fixup_extdef_ea(*args): @@ -25221,198 +27086,77 @@ def get_fixup_segdef_sel(*args): return _idaapi.get_fixup_segdef_sel(*args) def get_fixup_desc(*args): - """get_fixup_desc(source, fdp) -> char *""" + """ + get_fixup_desc(source, fdp) -> char * + """ return _idaapi.get_fixup_desc(*args) def contains_fixups(*args): - """contains_fixups(ea, size) -> bool""" + """ + contains_fixups(ea, size) -> bool + """ return _idaapi.contains_fixups(*args) def gen_fix_fixups(*args): - """gen_fix_fixups(frm, to, size)""" + """ + gen_fix_fixups(frm, to, size) + """ return _idaapi.gen_fix_fixups(*args) -class xreflist_t(object): - """Proxy of C++ qvector<(xreflist_entry_t)> class""" +class stkpnt_t(object): + """ + Proxy of C++ stkpnt_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + ea = _swig_property(_idaapi.stkpnt_t_ea_get, _idaapi.stkpnt_t_ea_set) + spd = _swig_property(_idaapi.stkpnt_t_spd_get, _idaapi.stkpnt_t_spd_set) + def __lt__(self, *args): """ - __init__(self) -> xreflist_t - __init__(self, x) -> xreflist_t + __lt__(self, r) -> bool """ - this = _idaapi.new_xreflist_t(*args) + return _idaapi.stkpnt_t___lt__(self, *args) + + def __init__(self, *args): + """ + __init__(self) -> stkpnt_t + """ + this = _idaapi.new_stkpnt_t(*args) try: self.this.append(this) except: self.this = this - __swig_destroy__ = _idaapi.delete_xreflist_t + __swig_destroy__ = _idaapi.delete_stkpnt_t __del__ = lambda self : None; - def push_back(self, *args): - """ - push_back(self, x) - push_back(self) -> xreflist_entry_t - """ - return _idaapi.xreflist_t_push_back(self, *args) - - def pop_back(self, *args): - """pop_back(self)""" - return _idaapi.xreflist_t_pop_back(self, *args) - - def size(self, *args): - """size(self) -> size_t""" - return _idaapi.xreflist_t_size(self, *args) - - def empty(self, *args): - """empty(self) -> bool""" - return _idaapi.xreflist_t_empty(self, *args) - - def at(self, *args): - """at(self, _idx) -> xreflist_entry_t""" - return _idaapi.xreflist_t_at(self, *args) - - def front(self, *args): - """ - front(self) -> xreflist_entry_t - front(self) -> xreflist_entry_t - """ - return _idaapi.xreflist_t_front(self, *args) - - def back(self, *args): - """ - back(self) -> xreflist_entry_t - back(self) -> xreflist_entry_t - """ - return _idaapi.xreflist_t_back(self, *args) - - def qclear(self, *args): - """qclear(self)""" - return _idaapi.xreflist_t_qclear(self, *args) - - def clear(self, *args): - """clear(self)""" - return _idaapi.xreflist_t_clear(self, *args) - - def resize(self, *args): - """ - resize(self, _newsize, x) - resize(self, _newsize) - """ - return _idaapi.xreflist_t_resize(self, *args) - - def grow(self, *args): - """grow(self, x=xreflist_entry_t())""" - return _idaapi.xreflist_t_grow(self, *args) - - def capacity(self, *args): - """capacity(self) -> size_t""" - return _idaapi.xreflist_t_capacity(self, *args) - - def reserve(self, *args): - """reserve(self, cnt)""" - return _idaapi.xreflist_t_reserve(self, *args) - - def truncate(self, *args): - """truncate(self)""" - return _idaapi.xreflist_t_truncate(self, *args) - - def swap(self, *args): - """swap(self, r)""" - return _idaapi.xreflist_t_swap(self, *args) - - def extract(self, *args): - """extract(self) -> xreflist_entry_t""" - return _idaapi.xreflist_t_extract(self, *args) - - def inject(self, *args): - """inject(self, s, len)""" - return _idaapi.xreflist_t_inject(self, *args) - - def __eq__(self, *args): - """__eq__(self, r) -> bool""" - return _idaapi.xreflist_t___eq__(self, *args) - - def __ne__(self, *args): - """__ne__(self, r) -> bool""" - return _idaapi.xreflist_t___ne__(self, *args) - - def begin(self, *args): - """ - begin(self) -> xreflist_entry_t - begin(self) -> xreflist_entry_t - """ - return _idaapi.xreflist_t_begin(self, *args) - - def end(self, *args): - """ - end(self) -> xreflist_entry_t - end(self) -> xreflist_entry_t - """ - return _idaapi.xreflist_t_end(self, *args) - - def insert(self, *args): - """insert(self, it, x) -> xreflist_entry_t""" - return _idaapi.xreflist_t_insert(self, *args) - - def erase(self, *args): - """ - erase(self, it) -> xreflist_entry_t - erase(self, first, last) -> xreflist_entry_t - """ - return _idaapi.xreflist_t_erase(self, *args) - - def find(self, *args): - """ - find(self, x) -> xreflist_entry_t - find(self, x) -> xreflist_entry_t - """ - return _idaapi.xreflist_t_find(self, *args) - - def has(self, *args): - """has(self, x) -> bool""" - return _idaapi.xreflist_t_has(self, *args) - - def add_unique(self, *args): - """add_unique(self, x) -> bool""" - return _idaapi.xreflist_t_add_unique(self, *args) - - def _del(self, *args): - """_del(self, x) -> bool""" - return _idaapi.xreflist_t__del(self, *args) - - def __len__(self, *args): - """__len__(self) -> size_t""" - return _idaapi.xreflist_t___len__(self, *args) - - def __getitem__(self, *args): - """__getitem__(self, i) -> xreflist_entry_t""" - return _idaapi.xreflist_t___getitem__(self, *args) - - def __setitem__(self, *args): - """__setitem__(self, i, v)""" - return _idaapi.xreflist_t___setitem__(self, *args) - - __iter__ = _bounded_getitem_iterator - -xreflist_t_swigregister = _idaapi.xreflist_t_swigregister -xreflist_t_swigregister(xreflist_t) +stkpnt_t_swigregister = _idaapi.stkpnt_t_swigregister +stkpnt_t_swigregister(stkpnt_t) def add_frame(*args): - """add_frame(pfn, frsize, frregs, argsize) -> bool""" + """ + add_frame(pfn, frsize, frregs, argsize) -> bool + """ return _idaapi.add_frame(*args) def del_frame(*args): - """del_frame(pfn) -> bool""" + """ + del_frame(pfn) -> bool + """ return _idaapi.del_frame(*args) def set_frame_size(*args): - """set_frame_size(pfn, frsize, frregs, argsize) -> bool""" + """ + set_frame_size(pfn, frsize, frregs, argsize) -> bool + """ return _idaapi.set_frame_size(*args) def get_frame_size(*args): - """get_frame_size(pfn) -> asize_t""" + """ + get_frame_size(pfn) -> asize_t + """ return _idaapi.get_frame_size(*args) def get_frame_retsize(*args): - """get_frame_retsize(pfn) -> int""" + """ + get_frame_retsize(pfn) -> int + """ return _idaapi.get_frame_retsize(*args) FPC_ARGS = _idaapi.FPC_ARGS FPC_RETADDR = _idaapi.FPC_RETADDR @@ -25420,31 +27164,45 @@ FPC_SAVREGS = _idaapi.FPC_SAVREGS FPC_LVARS = _idaapi.FPC_LVARS def get_frame_part(*args): - """get_frame_part(pfn, part, range)""" + """ + get_frame_part(pfn, part, range) + """ return _idaapi.get_frame_part(*args) def frame_off_args(*args): - """frame_off_args(pfn) -> ea_t""" + """ + frame_off_args(pfn) -> ea_t + """ return _idaapi.frame_off_args(*args) def frame_off_retaddr(*args): - """frame_off_retaddr(pfn) -> ea_t""" + """ + frame_off_retaddr(pfn) -> ea_t + """ return _idaapi.frame_off_retaddr(*args) def frame_off_savregs(*args): - """frame_off_savregs(pfn) -> ea_t""" + """ + frame_off_savregs(pfn) -> ea_t + """ return _idaapi.frame_off_savregs(*args) def frame_off_lvars(*args): - """frame_off_lvars(pfn) -> ea_t""" + """ + frame_off_lvars(pfn) -> ea_t + """ return _idaapi.frame_off_lvars(*args) def is_funcarg_off(*args): - """is_funcarg_off(pfn, frameoff) -> bool""" + """ + is_funcarg_off(pfn, frameoff) -> bool + """ return _idaapi.is_funcarg_off(*args) def lvar_off(*args): - """lvar_off(pfn, frameoff) -> sval_t""" + """ + lvar_off(pfn, frameoff) -> sval_t + """ return _idaapi.lvar_off(*args) def get_frame(*args): @@ -25455,46 +27213,66 @@ def get_frame(*args): return _idaapi.get_frame(*args) def update_fpd(*args): - """update_fpd(pfn, fpd) -> bool""" + """ + update_fpd(pfn, fpd) -> bool + """ return _idaapi.update_fpd(*args) def set_purged(*args): - """set_purged(ea, nbytes, override_old_value) -> bool""" + """ + set_purged(ea, nbytes, override_old_value) -> bool + """ return _idaapi.set_purged(*args) def get_func_by_frame(*args): - """get_func_by_frame(frame_id) -> ea_t""" + """ + get_func_by_frame(frame_id) -> ea_t + """ return _idaapi.get_func_by_frame(*args) STKVAR_VALID_SIZE = _idaapi.STKVAR_VALID_SIZE def add_stkvar2(*args): - """add_stkvar2(pfn, name, off, flags, ti, nbytes) -> bool""" + """ + add_stkvar2(pfn, name, off, flags, ti, nbytes) -> bool + """ return _idaapi.add_stkvar2(*args) def build_stkvar_name(*args): - """build_stkvar_name(pfn, v) -> char *""" + """ + build_stkvar_name(pfn, v) -> char * + """ return _idaapi.build_stkvar_name(*args) def calc_stkvar_struc_offset(*args): - """calc_stkvar_struc_offset(pfn, ea, n) -> ea_t""" + """ + calc_stkvar_struc_offset(pfn, ea, n) -> ea_t + """ return _idaapi.calc_stkvar_struc_offset(*args) def delete_unreferenced_stkvars(*args): - """delete_unreferenced_stkvars(pfn) -> int""" + """ + delete_unreferenced_stkvars(pfn) -> int + """ return _idaapi.delete_unreferenced_stkvars(*args) def delete_wrong_stkvar_ops(*args): - """delete_wrong_stkvar_ops(pfn) -> int""" + """ + delete_wrong_stkvar_ops(pfn) -> int + """ return _idaapi.delete_wrong_stkvar_ops(*args) class regvar_t(area_t): - """Proxy of C++ regvar_t class""" + """ + Proxy of C++ regvar_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr canon = _swig_property(_idaapi.regvar_t_canon_get, _idaapi.regvar_t_canon_set) user = _swig_property(_idaapi.regvar_t_user_get, _idaapi.regvar_t_user_set) cmt = _swig_property(_idaapi.regvar_t_cmt_get, _idaapi.regvar_t_cmt_set) - def __init__(self, *args): - """__init__(self) -> regvar_t""" + def __init__(self, *args): + """ + __init__(self) -> regvar_t + """ this = _idaapi.new_regvar_t(*args) try: self.this.append(this) except: self.this = this @@ -25505,7 +27283,9 @@ regvar_t_swigregister(regvar_t) def add_regvar(*args): - """add_regvar(pfn, ea1, ea2, canon, user, cmt) -> int""" + """ + add_regvar(pfn, ea1, ea2, canon, user, cmt) -> int + """ return _idaapi.add_regvar(*args) REGVAR_ERROR_OK = _idaapi.REGVAR_ERROR_OK REGVAR_ERROR_ARG = _idaapi.REGVAR_ERROR_ARG @@ -25520,24 +27300,34 @@ def find_regvar(*args): return _idaapi.find_regvar(*args) def rename_regvar(*args): - """rename_regvar(pfn, v, user) -> int""" + """ + rename_regvar(pfn, v, user) -> int + """ return _idaapi.rename_regvar(*args) def set_regvar_cmt(*args): - """set_regvar_cmt(pfn, v, cmt) -> int""" + """ + set_regvar_cmt(pfn, v, cmt) -> int + """ return _idaapi.set_regvar_cmt(*args) def del_regvar(*args): - """del_regvar(pfn, ea1, ea2, canon) -> int""" + """ + del_regvar(pfn, ea1, ea2, canon) -> int + """ return _idaapi.del_regvar(*args) class llabel_t(object): - """Proxy of C++ llabel_t class""" + """ + Proxy of C++ llabel_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr ea = _swig_property(_idaapi.llabel_t_ea_get, _idaapi.llabel_t_ea_set) name = _swig_property(_idaapi.llabel_t_name_get, _idaapi.llabel_t_name_set) - def __init__(self, *args): - """__init__(self) -> llabel_t""" + def __init__(self, *args): + """ + __init__(self) -> llabel_t + """ this = _idaapi.new_llabel_t(*args) try: self.this.append(this) except: self.this = this @@ -25548,78 +27338,71 @@ llabel_t_swigregister(llabel_t) def add_auto_stkpnt2(*args): - """add_auto_stkpnt2(pfn, ea, delta) -> bool""" + """ + add_auto_stkpnt2(pfn, ea, delta) -> bool + """ return _idaapi.add_auto_stkpnt2(*args) def add_user_stkpnt(*args): - """add_user_stkpnt(ea, delta) -> bool""" + """ + add_user_stkpnt(ea, delta) -> bool + """ return _idaapi.add_user_stkpnt(*args) def del_stkpnt(*args): - """del_stkpnt(pfn, ea) -> bool""" + """ + del_stkpnt(pfn, ea) -> bool + """ return _idaapi.del_stkpnt(*args) def get_spd(*args): - """get_spd(pfn, ea) -> sval_t""" + """ + get_spd(pfn, ea) -> sval_t + """ return _idaapi.get_spd(*args) def get_effective_spd(*args): - """get_effective_spd(pfn, ea) -> sval_t""" + """ + get_effective_spd(pfn, ea) -> sval_t + """ return _idaapi.get_effective_spd(*args) def get_sp_delta(*args): - """get_sp_delta(pfn, ea) -> sval_t""" + """ + get_sp_delta(pfn, ea) -> sval_t + """ return _idaapi.get_sp_delta(*args) def get_min_spd_ea(*args): - """get_min_spd_ea(pfn) -> ea_t""" + """ + get_min_spd_ea(pfn) -> ea_t + """ return _idaapi.get_min_spd_ea(*args) def recalc_spd(*args): - """recalc_spd(cur_ea) -> bool""" + """ + recalc_spd(cur_ea) -> bool + """ return _idaapi.recalc_spd(*args) -class xreflist_entry_t(object): - """Proxy of C++ xreflist_entry_t class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - ea = _swig_property(_idaapi.xreflist_entry_t_ea_get, _idaapi.xreflist_entry_t_ea_set) - opnum = _swig_property(_idaapi.xreflist_entry_t_opnum_get, _idaapi.xreflist_entry_t_opnum_set) - type = _swig_property(_idaapi.xreflist_entry_t_type_get, _idaapi.xreflist_entry_t_type_set) - def __eq__(self, *args): - """__eq__(self, r) -> bool""" - return _idaapi.xreflist_entry_t___eq__(self, *args) - - def __ne__(self, *args): - """__ne__(self, r) -> bool""" - return _idaapi.xreflist_entry_t___ne__(self, *args) - - def __init__(self, *args): - """__init__(self) -> xreflist_entry_t""" - this = _idaapi.new_xreflist_entry_t(*args) - try: self.this.append(this) - except: self.this = this - __swig_destroy__ = _idaapi.delete_xreflist_entry_t - __del__ = lambda self : None; -xreflist_entry_t_swigregister = _idaapi.xreflist_entry_t_swigregister -xreflist_entry_t_swigregister(xreflist_entry_t) - - -def build_stkvar_xrefs(*args): - """build_stkvar_xrefs(out, pfn, mptr)""" - return _idaapi.build_stkvar_xrefs(*args) def add_auto_stkpnt(*args): - """add_auto_stkpnt(ea, delta) -> bool""" + """ + add_auto_stkpnt(ea, delta) -> bool + """ return _idaapi.add_auto_stkpnt(*args) class regarg_t(object): - """Proxy of C++ regarg_t class""" + """ + Proxy of C++ regarg_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr reg = _swig_property(_idaapi.regarg_t_reg_get, _idaapi.regarg_t_reg_set) type = _swig_property(_idaapi.regarg_t_type_get, _idaapi.regarg_t_type_set) name = _swig_property(_idaapi.regarg_t_name_get, _idaapi.regarg_t_name_set) - def __init__(self, *args): - """__init__(self) -> regarg_t""" + def __init__(self, *args): + """ + __init__(self) -> regarg_t + """ this = _idaapi.new_regarg_t(*args) try: self.this.append(this) except: self.this = this @@ -25629,20 +27412,28 @@ regarg_t_swigregister = _idaapi.regarg_t_swigregister regarg_t_swigregister(regarg_t) class func_t(area_t): - """Proxy of C++ func_t class""" + """ + Proxy of C++ func_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr flags = _swig_property(_idaapi.func_t_flags_get, _idaapi.func_t_flags_set) def is_far(self, *args): - """is_far(self) -> bool""" + """ + is_far(self) -> bool + """ return _idaapi.func_t_is_far(self, *args) def does_return(self, *args): - """does_return(self) -> bool""" + """ + does_return(self) -> bool + """ return _idaapi.func_t_does_return(self, *args) def analyzed_sp(self, *args): - """analyzed_sp(self) -> bool""" + """ + analyzed_sp(self) -> bool + """ return _idaapi.func_t_analyzed_sp(self, *args) frame = _swig_property(_idaapi.func_t_frame_get, _idaapi.func_t_frame_set) @@ -25664,8 +27455,10 @@ class func_t(area_t): owner = _swig_property(_idaapi.func_t_owner_get, _idaapi.func_t_owner_set) refqty = _swig_property(_idaapi.func_t_refqty_get, _idaapi.func_t_refqty_set) referers = _swig_property(_idaapi.func_t_referers_get, _idaapi.func_t_referers_set) - def __init__(self, *args): - """__init__(self) -> func_t""" + def __init__(self, *args): + """ + __init__(self) -> func_t + """ this = _idaapi.new_func_t(*args) try: self.this.append(this) except: self.this = this @@ -25689,18 +27482,26 @@ FUNC_TAIL = _idaapi.FUNC_TAIL def is_func_entry(*args): - """is_func_entry(pfn) -> bool""" + """ + is_func_entry(pfn) -> bool + """ return _idaapi.is_func_entry(*args) def is_func_tail(*args): - """is_func_tail(pfn) -> bool""" + """ + is_func_tail(pfn) -> bool + """ return _idaapi.is_func_tail(*args) class lock_func(object): - """Proxy of C++ lock_func class""" + """ + Proxy of C++ lock_func class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, _pfn) -> lock_func""" + def __init__(self, *args): + """ + __init__(self, _pfn) -> lock_func + """ this = _idaapi.new_lock_func(*args) try: self.this.append(this) except: self.this = this @@ -25711,71 +27512,105 @@ lock_func_swigregister(lock_func) def is_func_locked(*args): - """is_func_locked(pfn) -> bool""" + """ + is_func_locked(pfn) -> bool + """ return _idaapi.is_func_locked(*args) def get_func(*args): - """get_func(ea) -> func_t""" + """ + get_func(ea) -> func_t + """ return _idaapi.get_func(*args) def get_func_chunknum(*args): - """get_func_chunknum(pfn, ea) -> int""" + """ + get_func_chunknum(pfn, ea) -> int + """ return _idaapi.get_func_chunknum(*args) def func_contains(*args): - """func_contains(pfn, ea) -> bool""" + """ + func_contains(pfn, ea) -> bool + """ return _idaapi.func_contains(*args) def getn_func(*args): - """getn_func(n) -> func_t""" + """ + getn_func(n) -> func_t + """ return _idaapi.getn_func(*args) def get_func_qty(*args): - """get_func_qty() -> size_t""" + """ + get_func_qty() -> size_t + """ return _idaapi.get_func_qty(*args) def get_func_num(*args): - """get_func_num(ea) -> int""" + """ + get_func_num(ea) -> int + """ return _idaapi.get_func_num(*args) def get_prev_func(*args): - """get_prev_func(ea) -> func_t""" + """ + get_prev_func(ea) -> func_t + """ return _idaapi.get_prev_func(*args) def get_next_func(*args): - """get_next_func(ea) -> func_t""" + """ + get_next_func(ea) -> func_t + """ return _idaapi.get_next_func(*args) def get_func_limits(*args): - """get_func_limits(pfn, limits) -> bool""" + """ + get_func_limits(pfn, limits) -> bool + """ return _idaapi.get_func_limits(*args) def set_func_cmt(*args): - """set_func_cmt(fn, cmt, repeatable) -> bool""" + """ + set_func_cmt(fn, cmt, repeatable) -> bool + """ return _idaapi.set_func_cmt(*args) def del_func_cmt(*args): - """del_func_cmt(fn, repeatable)""" + """ + del_func_cmt(fn, repeatable) + """ return _idaapi.del_func_cmt(*args) def update_func(*args): - """update_func(fn) -> bool""" + """ + update_func(fn) -> bool + """ return _idaapi.update_func(*args) def add_func_ex(*args): - """add_func_ex(fn) -> bool""" + """ + add_func_ex(fn) -> bool + """ return _idaapi.add_func_ex(*args) def add_func(*args): - """add_func(ea1, ea2) -> bool""" + """ + add_func(ea1, ea2) -> bool + """ return _idaapi.add_func(*args) def del_func(*args): - """del_func(ea) -> bool""" + """ + del_func(ea) -> bool + """ return _idaapi.del_func(*args) def func_setstart(*args): - """func_setstart(ea, newstart) -> int""" + """ + func_setstart(ea, newstart) -> int + """ return _idaapi.func_setstart(*args) MOVE_FUNC_OK = _idaapi.MOVE_FUNC_OK MOVE_FUNC_NOCODE = _idaapi.MOVE_FUNC_NOCODE @@ -25784,159 +27619,233 @@ MOVE_FUNC_NOFUNC = _idaapi.MOVE_FUNC_NOFUNC MOVE_FUNC_REFUSED = _idaapi.MOVE_FUNC_REFUSED def func_setend(*args): - """func_setend(ea, newend) -> bool""" + """ + func_setend(ea, newend) -> bool + """ return _idaapi.func_setend(*args) def reanalyze_function(*args): - """reanalyze_function(pfn, ea1=0, ea2=BADADDR, analyze_parents=False)""" + """ + reanalyze_function(pfn, ea1=0, ea2=BADADDR, analyze_parents=False) + """ return _idaapi.reanalyze_function(*args) def clear_func_struct(*args): - """clear_func_struct(fn)""" + """ + clear_func_struct(fn) + """ return _idaapi.clear_func_struct(*args) - -def find_func_bounds(*args): - """find_func_bounds(ea, nfn, flags) -> int""" - return _idaapi.find_func_bounds(*args) FIND_FUNC_NORMAL = _idaapi.FIND_FUNC_NORMAL FIND_FUNC_DEFINE = _idaapi.FIND_FUNC_DEFINE FIND_FUNC_IGNOREFN = _idaapi.FIND_FUNC_IGNOREFN + +def find_func_bounds(*args): + """ + find_func_bounds(ea, nfn, flags) -> int + """ + return _idaapi.find_func_bounds(*args) FIND_FUNC_UNDEF = _idaapi.FIND_FUNC_UNDEF FIND_FUNC_OK = _idaapi.FIND_FUNC_OK FIND_FUNC_EXIST = _idaapi.FIND_FUNC_EXIST -def get_func_name2(*args): - """get_func_name2(ea) -> ssize_t""" - return _idaapi.get_func_name2(*args) +def get_func_name(*args): + """ + get_func_name(ea) -> char * + """ + return _idaapi.get_func_name(*args) def get_func_bitness(*args): - """get_func_bitness(pfn) -> int""" + """ + get_func_bitness(pfn) -> int + """ return _idaapi.get_func_bitness(*args) def get_func_bits(*args): - """get_func_bits(pfn) -> int""" + """ + get_func_bits(pfn) -> int + """ return _idaapi.get_func_bits(*args) def get_func_bytes(*args): - """get_func_bytes(pfn) -> int""" + """ + get_func_bytes(pfn) -> int + """ return _idaapi.get_func_bytes(*args) def is_visible_func(*args): - """is_visible_func(pfn) -> bool""" + """ + is_visible_func(pfn) -> bool + """ return _idaapi.is_visible_func(*args) def is_finally_visible_func(*args): - """is_finally_visible_func(pfn) -> bool""" + """ + is_finally_visible_func(pfn) -> bool + """ return _idaapi.is_finally_visible_func(*args) def set_visible_func(*args): - """set_visible_func(pfn, visible)""" + """ + set_visible_func(pfn, visible) + """ return _idaapi.set_visible_func(*args) def set_func_name_if_jumpfunc(*args): - """set_func_name_if_jumpfunc(fn, oldname) -> int""" + """ + set_func_name_if_jumpfunc(fn, oldname) -> int + """ return _idaapi.set_func_name_if_jumpfunc(*args) def calc_thunk_func_target(*args): - """calc_thunk_func_target(fn, fptr) -> ea_t""" + """ + calc_thunk_func_target(fn, fptr) -> ea_t + """ return _idaapi.calc_thunk_func_target(*args) def a2funcoff(*args): - """a2funcoff(ea) -> char *""" + """ + a2funcoff(ea) -> char * + """ return _idaapi.a2funcoff(*args) def std_gen_func_header(*args): - """std_gen_func_header(pfn)""" + """ + std_gen_func_header(pfn) + """ return _idaapi.std_gen_func_header(*args) def func_does_return(*args): - """func_does_return(callee) -> bool""" + """ + func_does_return(callee) -> bool + """ return _idaapi.func_does_return(*args) def set_noret_insn(*args): - """set_noret_insn(insn_ea, noret) -> bool""" + """ + set_noret_insn(insn_ea, noret) -> bool + """ return _idaapi.set_noret_insn(*args) def get_fchunk(*args): - """get_fchunk(ea) -> func_t""" + """ + get_fchunk(ea) -> func_t + """ return _idaapi.get_fchunk(*args) def getn_fchunk(*args): - """getn_fchunk(n) -> func_t""" + """ + getn_fchunk(n) -> func_t + """ return _idaapi.getn_fchunk(*args) def get_fchunk_qty(*args): - """get_fchunk_qty() -> size_t""" + """ + get_fchunk_qty() -> size_t + """ return _idaapi.get_fchunk_qty(*args) def get_fchunk_num(*args): - """get_fchunk_num(ea) -> int""" + """ + get_fchunk_num(ea) -> int + """ return _idaapi.get_fchunk_num(*args) def get_prev_fchunk(*args): - """get_prev_fchunk(ea) -> func_t""" + """ + get_prev_fchunk(ea) -> func_t + """ return _idaapi.get_prev_fchunk(*args) def get_next_fchunk(*args): - """get_next_fchunk(ea) -> func_t""" + """ + get_next_fchunk(ea) -> func_t + """ return _idaapi.get_next_fchunk(*args) def append_func_tail(*args): - """append_func_tail(pfn, ea1, ea2) -> bool""" + """ + append_func_tail(pfn, ea1, ea2) -> bool + """ return _idaapi.append_func_tail(*args) def remove_func_tail(*args): - """remove_func_tail(pfn, tail_ea) -> bool""" + """ + remove_func_tail(pfn, tail_ea) -> bool + """ return _idaapi.remove_func_tail(*args) def set_tail_owner(*args): - """set_tail_owner(fnt, func_start) -> bool""" + """ + set_tail_owner(fnt, func_start) -> bool + """ return _idaapi.set_tail_owner(*args) def func_tail_iterator_set(*args): - """func_tail_iterator_set(fti, pfn, ea) -> bool""" + """ + func_tail_iterator_set(fti, pfn, ea) -> bool + """ return _idaapi.func_tail_iterator_set(*args) def func_tail_iterator_set2(*args): - """func_tail_iterator_set2(fti, pfn, ea) -> bool""" + """ + func_tail_iterator_set2(fti, pfn, ea) -> bool + """ return _idaapi.func_tail_iterator_set2(*args) def func_tail_iterator_set_ea(*args): - """func_tail_iterator_set_ea(fti, ea) -> bool""" + """ + func_tail_iterator_set_ea(fti, ea) -> bool + """ return _idaapi.func_tail_iterator_set_ea(*args) def func_parent_iterator_set(*args): - """func_parent_iterator_set(fpi, pfn) -> bool""" + """ + func_parent_iterator_set(fpi, pfn) -> bool + """ return _idaapi.func_parent_iterator_set(*args) def func_parent_iterator_set2(*args): - """func_parent_iterator_set2(fpi, pfn) -> bool""" + """ + func_parent_iterator_set2(fpi, pfn) -> bool + """ return _idaapi.func_parent_iterator_set2(*args) def func_item_iterator_next(*args): - """func_item_iterator_next(fii, testf, ud) -> bool""" + """ + func_item_iterator_next(fii, testf, ud) -> bool + """ return _idaapi.func_item_iterator_next(*args) def func_item_iterator_prev(*args): - """func_item_iterator_prev(fii, testf, ud) -> bool""" + """ + func_item_iterator_prev(fii, testf, ud) -> bool + """ return _idaapi.func_item_iterator_prev(*args) def func_item_iterator_decode_prev_insn(*args): - """func_item_iterator_decode_prev_insn(fii) -> bool""" + """ + func_item_iterator_decode_prev_insn(fii) -> bool + """ return _idaapi.func_item_iterator_decode_prev_insn(*args) def func_item_iterator_decode_preceding_insn(*args): - """func_item_iterator_decode_preceding_insn(fii, visited, p_farref) -> bool""" + """ + func_item_iterator_decode_preceding_insn(fii, visited, p_farref) -> bool + """ return _idaapi.func_item_iterator_decode_preceding_insn(*args) def f_any(*args): - """f_any(arg1, arg2) -> bool""" + """ + f_any(arg1, arg2) -> bool + """ return _idaapi.f_any(*args) class func_tail_iterator_t(object): - """Proxy of C++ func_tail_iterator_t class""" + """ + Proxy of C++ func_tail_iterator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> func_tail_iterator_t __init__(self, _pfn, ea=BADADDR) -> func_tail_iterator_t @@ -25947,49 +27856,69 @@ class func_tail_iterator_t(object): __swig_destroy__ = _idaapi.delete_func_tail_iterator_t __del__ = lambda self : None; def set(self, *args): - """set(self, _pfn, ea=BADADDR) -> bool""" + """ + set(self, _pfn, ea=BADADDR) -> bool + """ return _idaapi.func_tail_iterator_t_set(self, *args) def set_ea(self, *args): - """set_ea(self, ea) -> bool""" + """ + set_ea(self, ea) -> bool + """ return _idaapi.func_tail_iterator_t_set_ea(self, *args) def set_range(self, *args): - """set_range(self, ea1, ea2) -> bool""" + """ + set_range(self, ea1, ea2) -> bool + """ return _idaapi.func_tail_iterator_t_set_range(self, *args) def chunk(self, *args): - """chunk(self) -> area_t""" + """ + chunk(self) -> area_t + """ return _idaapi.func_tail_iterator_t_chunk(self, *args) def first(self, *args): - """first(self) -> bool""" + """ + first(self) -> bool + """ return _idaapi.func_tail_iterator_t_first(self, *args) def last(self, *args): - """last(self) -> bool""" + """ + last(self) -> bool + """ return _idaapi.func_tail_iterator_t_last(self, *args) def next(self, *args): - """next(self) -> bool""" + """ + next(self) -> bool + """ return _idaapi.func_tail_iterator_t_next(self, *args) def prev(self, *args): - """prev(self) -> bool""" + """ + prev(self) -> bool + """ return _idaapi.func_tail_iterator_t_prev(self, *args) def main(self, *args): - """main(self) -> bool""" + """ + main(self) -> bool + """ return _idaapi.func_tail_iterator_t_main(self, *args) func_tail_iterator_t_swigregister = _idaapi.func_tail_iterator_t_swigregister func_tail_iterator_t_swigregister(func_tail_iterator_t) class func_item_iterator_t(object): - """Proxy of C++ func_item_iterator_t class""" + """ + Proxy of C++ func_item_iterator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> func_item_iterator_t __init__(self, pfn, _ea=BADADDR) -> func_item_iterator_t @@ -25998,83 +27927,123 @@ class func_item_iterator_t(object): try: self.this.append(this) except: self.this = this def set(self, *args): - """set(self, pfn, _ea=BADADDR) -> bool""" + """ + set(self, pfn, _ea=BADADDR) -> bool + """ return _idaapi.func_item_iterator_t_set(self, *args) def set_range(self, *args): - """set_range(self, ea1, ea2) -> bool""" + """ + set_range(self, ea1, ea2) -> bool + """ return _idaapi.func_item_iterator_t_set_range(self, *args) def first(self, *args): - """first(self) -> bool""" + """ + first(self) -> bool + """ return _idaapi.func_item_iterator_t_first(self, *args) def last(self, *args): - """last(self) -> bool""" + """ + last(self) -> bool + """ return _idaapi.func_item_iterator_t_last(self, *args) def current(self, *args): - """current(self) -> ea_t""" + """ + current(self) -> ea_t + """ return _idaapi.func_item_iterator_t_current(self, *args) def chunk(self, *args): - """chunk(self) -> area_t""" + """ + chunk(self) -> area_t + """ return _idaapi.func_item_iterator_t_chunk(self, *args) def next(self, *args): - """next(self, func, ud) -> bool""" + """ + next(self, func, ud) -> bool + """ return _idaapi.func_item_iterator_t_next(self, *args) def prev(self, *args): - """prev(self, func, ud) -> bool""" + """ + prev(self, func, ud) -> bool + """ return _idaapi.func_item_iterator_t_prev(self, *args) def next_addr(self, *args): - """next_addr(self) -> bool""" + """ + next_addr(self) -> bool + """ return _idaapi.func_item_iterator_t_next_addr(self, *args) def next_head(self, *args): - """next_head(self) -> bool""" + """ + next_head(self) -> bool + """ return _idaapi.func_item_iterator_t_next_head(self, *args) def next_code(self, *args): - """next_code(self) -> bool""" + """ + next_code(self) -> bool + """ return _idaapi.func_item_iterator_t_next_code(self, *args) def next_data(self, *args): - """next_data(self) -> bool""" + """ + next_data(self) -> bool + """ return _idaapi.func_item_iterator_t_next_data(self, *args) def next_not_tail(self, *args): - """next_not_tail(self) -> bool""" + """ + next_not_tail(self) -> bool + """ return _idaapi.func_item_iterator_t_next_not_tail(self, *args) def prev_addr(self, *args): - """prev_addr(self) -> bool""" + """ + prev_addr(self) -> bool + """ return _idaapi.func_item_iterator_t_prev_addr(self, *args) def prev_head(self, *args): - """prev_head(self) -> bool""" + """ + prev_head(self) -> bool + """ return _idaapi.func_item_iterator_t_prev_head(self, *args) def prev_code(self, *args): - """prev_code(self) -> bool""" + """ + prev_code(self) -> bool + """ return _idaapi.func_item_iterator_t_prev_code(self, *args) def prev_data(self, *args): - """prev_data(self) -> bool""" + """ + prev_data(self) -> bool + """ return _idaapi.func_item_iterator_t_prev_data(self, *args) def prev_not_tail(self, *args): - """prev_not_tail(self) -> bool""" + """ + prev_not_tail(self) -> bool + """ return _idaapi.func_item_iterator_t_prev_not_tail(self, *args) def decode_prev_insn(self, *args): - """decode_prev_insn(self) -> bool""" + """ + decode_prev_insn(self) -> bool + """ return _idaapi.func_item_iterator_t_decode_prev_insn(self, *args) def decode_preceding_insn(self, *args): - """decode_preceding_insn(self, visited, p_farref) -> bool""" + """ + decode_preceding_insn(self, visited, p_farref) -> bool + """ return _idaapi.func_item_iterator_t_decode_preceding_insn(self, *args) __swig_destroy__ = _idaapi.delete_func_item_iterator_t @@ -26083,10 +28052,12 @@ func_item_iterator_t_swigregister = _idaapi.func_item_iterator_t_swigregister func_item_iterator_t_swigregister(func_item_iterator_t) class func_parent_iterator_t(object): - """Proxy of C++ func_parent_iterator_t class""" + """ + Proxy of C++ func_parent_iterator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> func_parent_iterator_t __init__(self, _fnt) -> func_parent_iterator_t @@ -26097,31 +28068,45 @@ class func_parent_iterator_t(object): __swig_destroy__ = _idaapi.delete_func_parent_iterator_t __del__ = lambda self : None; def set(self, *args): - """set(self, _fnt) -> bool""" + """ + set(self, _fnt) -> bool + """ return _idaapi.func_parent_iterator_t_set(self, *args) def parent(self, *args): - """parent(self) -> ea_t""" + """ + parent(self) -> ea_t + """ return _idaapi.func_parent_iterator_t_parent(self, *args) def first(self, *args): - """first(self) -> bool""" + """ + first(self) -> bool + """ return _idaapi.func_parent_iterator_t_first(self, *args) def last(self, *args): - """last(self) -> bool""" + """ + last(self) -> bool + """ return _idaapi.func_parent_iterator_t_last(self, *args) def next(self, *args): - """next(self) -> bool""" + """ + next(self) -> bool + """ return _idaapi.func_parent_iterator_t_next(self, *args) def prev(self, *args): - """prev(self) -> bool""" + """ + prev(self) -> bool + """ return _idaapi.func_parent_iterator_t_prev(self, *args) def reset_fnt(self, *args): - """reset_fnt(self, _fnt)""" + """ + reset_fnt(self, _fnt) + """ return _idaapi.func_parent_iterator_t_reset_fnt(self, *args) func_parent_iterator_t_swigregister = _idaapi.func_parent_iterator_t_swigregister @@ -26129,19 +28114,27 @@ func_parent_iterator_t_swigregister(func_parent_iterator_t) def get_prev_func_addr(*args): - """get_prev_func_addr(pfn, ea) -> ea_t""" + """ + get_prev_func_addr(pfn, ea) -> ea_t + """ return _idaapi.get_prev_func_addr(*args) def get_next_func_addr(*args): - """get_next_func_addr(pfn, ea) -> ea_t""" + """ + get_next_func_addr(pfn, ea) -> ea_t + """ return _idaapi.get_next_func_addr(*args) def read_regargs(*args): - """read_regargs(pfn)""" + """ + read_regargs(pfn) + """ return _idaapi.read_regargs(*args) def add_regarg2(*args): - """add_regarg2(pfn, reg, tif, name)""" + """ + add_regarg2(pfn, reg, tif, name) + """ return _idaapi.add_regarg2(*args) IDASGN_OK = _idaapi.IDASGN_OK IDASGN_BADARG = _idaapi.IDASGN_BADARG @@ -26150,573 +28143,373 @@ IDASGN_CURRENT = _idaapi.IDASGN_CURRENT IDASGN_PLANNED = _idaapi.IDASGN_PLANNED def plan_to_apply_idasgn(*args): - """plan_to_apply_idasgn(fname) -> int""" + """ + plan_to_apply_idasgn(fname) -> int + """ return _idaapi.plan_to_apply_idasgn(*args) def apply_idasgn(*args): - """apply_idasgn(advance) -> bool""" + """ + apply_idasgn(advance) -> bool + """ return _idaapi.apply_idasgn(*args) def apply_idasgn_to(*args): - """apply_idasgn_to(signame, ea, is_startup) -> int""" + """ + apply_idasgn_to(signame, ea, is_startup) -> int + """ return _idaapi.apply_idasgn_to(*args) def get_idasgn_qty(*args): - """get_idasgn_qty() -> int""" + """ + get_idasgn_qty() -> int + """ return _idaapi.get_idasgn_qty(*args) def get_current_idasgn(*args): - """get_current_idasgn() -> int""" + """ + get_current_idasgn() -> int + """ return _idaapi.get_current_idasgn(*args) def calc_idasgn_state(*args): - """calc_idasgn_state(n) -> int""" + """ + calc_idasgn_state(n) -> int + """ return _idaapi.calc_idasgn_state(*args) def del_idasgn(*args): - """del_idasgn(n) -> int""" + """ + del_idasgn(n) -> int + """ return _idaapi.del_idasgn(*args) def get_sig_filename(*args): - """get_sig_filename(signame) -> char *""" + """ + get_sig_filename(signame) -> char * + """ return _idaapi.get_sig_filename(*args) def get_idasgn_title(*args): - """get_idasgn_title(name) -> char *""" + """ + get_idasgn_title(name) -> char * + """ return _idaapi.get_idasgn_title(*args) def apply_startup_sig(*args): - """apply_startup_sig(ea, startup) -> bool""" + """ + apply_startup_sig(ea, startup) -> bool + """ return _idaapi.apply_startup_sig(*args) def try_to_add_libfunc(*args): - """try_to_add_libfunc(ea) -> int""" + """ + try_to_add_libfunc(ea) -> int + """ return _idaapi.try_to_add_libfunc(*args) LIBFUNC_FOUND = _idaapi.LIBFUNC_FOUND LIBFUNC_NONE = _idaapi.LIBFUNC_NONE LIBFUNC_DELAY = _idaapi.LIBFUNC_DELAY def add_regarg(*args): - """add_regarg(pfn, reg, type, name)""" + """ + add_regarg(pfn, reg, type, name) + """ return _idaapi.add_regarg(*args) - -def get_func_name(*args): - """get_func_name(ea) -> char *""" - return _idaapi.get_func_name(*args) FUNC_STATICDEF = _idaapi.FUNC_STATICDEF def get_fchunk_referer(*args): - """get_fchunk_referer(ea, idx) -> ea_t""" + """ + get_fchunk_referer(ea, idx) -> ea_t + + + """ return _idaapi.get_fchunk_referer(*args) def get_idasgn_desc(*args): - """get_idasgn_desc(n) -> PyObject *""" + """ + get_idasgn_desc(n) -> PyObject * + + + Get information about a signature in the list. + It returns both: the name of the signature, and names of the + optional libraries + + @param n: number of signature in the list (0..get_idasgn_qty()-1) + @return: None on failure or tuple(signame, optlibs) + """ return _idaapi.get_idasgn_desc(*args) def get_func_cmt(*args): - """get_func_cmt(fn, repeatable) -> PyObject *""" + """ + get_func_cmt(fn, repeatable) -> PyObject * + + + Retrieve function comment + @param fn: function instance + @param repeatable: retrieve repeatable or non-repeatable comments + @return: None on failure or the comment + """ return _idaapi.get_func_cmt(*args) -class funcargvec_t(object): - """Proxy of C++ qvector<(funcarg_t)> class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args): - """ - __init__(self) -> funcargvec_t - __init__(self, x) -> funcargvec_t - """ - this = _idaapi.new_funcargvec_t(*args) - try: self.this.append(this) - except: self.this = this - __swig_destroy__ = _idaapi.delete_funcargvec_t - __del__ = lambda self : None; - def push_back(self, *args): - """ - push_back(self, x) - push_back(self) -> funcarg_t - """ - return _idaapi.funcargvec_t_push_back(self, *args) - - def pop_back(self, *args): - """pop_back(self)""" - return _idaapi.funcargvec_t_pop_back(self, *args) - - def size(self, *args): - """size(self) -> size_t""" - return _idaapi.funcargvec_t_size(self, *args) - - def empty(self, *args): - """empty(self) -> bool""" - return _idaapi.funcargvec_t_empty(self, *args) - - def at(self, *args): - """at(self, _idx) -> funcarg_t""" - return _idaapi.funcargvec_t_at(self, *args) - - def front(self, *args): - """ - front(self) -> funcarg_t - front(self) -> funcarg_t - """ - return _idaapi.funcargvec_t_front(self, *args) - - def back(self, *args): - """ - back(self) -> funcarg_t - back(self) -> funcarg_t - """ - return _idaapi.funcargvec_t_back(self, *args) - - def qclear(self, *args): - """qclear(self)""" - return _idaapi.funcargvec_t_qclear(self, *args) - - def clear(self, *args): - """clear(self)""" - return _idaapi.funcargvec_t_clear(self, *args) - - def resize(self, *args): - """ - resize(self, _newsize, x) - resize(self, _newsize) - """ - return _idaapi.funcargvec_t_resize(self, *args) - - def grow(self, *args): - """grow(self, x=funcarg_t())""" - return _idaapi.funcargvec_t_grow(self, *args) - - def capacity(self, *args): - """capacity(self) -> size_t""" - return _idaapi.funcargvec_t_capacity(self, *args) - - def reserve(self, *args): - """reserve(self, cnt)""" - return _idaapi.funcargvec_t_reserve(self, *args) - - def truncate(self, *args): - """truncate(self)""" - return _idaapi.funcargvec_t_truncate(self, *args) - - def swap(self, *args): - """swap(self, r)""" - return _idaapi.funcargvec_t_swap(self, *args) - - def extract(self, *args): - """extract(self) -> funcarg_t""" - return _idaapi.funcargvec_t_extract(self, *args) - - def inject(self, *args): - """inject(self, s, len)""" - return _idaapi.funcargvec_t_inject(self, *args) - - def __eq__(self, *args): - """__eq__(self, r) -> bool""" - return _idaapi.funcargvec_t___eq__(self, *args) - - def __ne__(self, *args): - """__ne__(self, r) -> bool""" - return _idaapi.funcargvec_t___ne__(self, *args) - - def begin(self, *args): - """ - begin(self) -> funcarg_t - begin(self) -> funcarg_t - """ - return _idaapi.funcargvec_t_begin(self, *args) - - def end(self, *args): - """ - end(self) -> funcarg_t - end(self) -> funcarg_t - """ - return _idaapi.funcargvec_t_end(self, *args) - - def insert(self, *args): - """insert(self, it, x) -> funcarg_t""" - return _idaapi.funcargvec_t_insert(self, *args) - - def erase(self, *args): - """ - erase(self, it) -> funcarg_t - erase(self, first, last) -> funcarg_t - """ - return _idaapi.funcargvec_t_erase(self, *args) - - def find(self, *args): - """ - find(self, x) -> funcarg_t - find(self, x) -> funcarg_t - """ - return _idaapi.funcargvec_t_find(self, *args) - - def has(self, *args): - """has(self, x) -> bool""" - return _idaapi.funcargvec_t_has(self, *args) - - def add_unique(self, *args): - """add_unique(self, x) -> bool""" - return _idaapi.funcargvec_t_add_unique(self, *args) - - def _del(self, *args): - """_del(self, x) -> bool""" - return _idaapi.funcargvec_t__del(self, *args) - - def __len__(self, *args): - """__len__(self) -> size_t""" - return _idaapi.funcargvec_t___len__(self, *args) - - def __getitem__(self, *args): - """__getitem__(self, i) -> funcarg_t""" - return _idaapi.funcargvec_t___getitem__(self, *args) - - def __setitem__(self, *args): - """__setitem__(self, i, v)""" - return _idaapi.funcargvec_t___setitem__(self, *args) - - __iter__ = _bounded_getitem_iterator - -funcargvec_t_swigregister = _idaapi.funcargvec_t_swigregister -funcargvec_t_swigregister(funcargvec_t) - -class udtmembervec_t(object): - """Proxy of C++ qvector<(udt_member_t)> class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args): - """ - __init__(self) -> udtmembervec_t - __init__(self, x) -> udtmembervec_t - """ - this = _idaapi.new_udtmembervec_t(*args) - try: self.this.append(this) - except: self.this = this - __swig_destroy__ = _idaapi.delete_udtmembervec_t - __del__ = lambda self : None; - def push_back(self, *args): - """ - push_back(self, x) - push_back(self) -> udt_member_t - """ - return _idaapi.udtmembervec_t_push_back(self, *args) - - def pop_back(self, *args): - """pop_back(self)""" - return _idaapi.udtmembervec_t_pop_back(self, *args) - - def size(self, *args): - """size(self) -> size_t""" - return _idaapi.udtmembervec_t_size(self, *args) - - def empty(self, *args): - """empty(self) -> bool""" - return _idaapi.udtmembervec_t_empty(self, *args) - - def at(self, *args): - """at(self, _idx) -> udt_member_t""" - return _idaapi.udtmembervec_t_at(self, *args) - - def front(self, *args): - """ - front(self) -> udt_member_t - front(self) -> udt_member_t - """ - return _idaapi.udtmembervec_t_front(self, *args) - - def back(self, *args): - """ - back(self) -> udt_member_t - back(self) -> udt_member_t - """ - return _idaapi.udtmembervec_t_back(self, *args) - - def qclear(self, *args): - """qclear(self)""" - return _idaapi.udtmembervec_t_qclear(self, *args) - - def clear(self, *args): - """clear(self)""" - return _idaapi.udtmembervec_t_clear(self, *args) - - def resize(self, *args): - """ - resize(self, _newsize, x) - resize(self, _newsize) - """ - return _idaapi.udtmembervec_t_resize(self, *args) - - def grow(self, *args): - """grow(self, x=udt_member_t())""" - return _idaapi.udtmembervec_t_grow(self, *args) - - def capacity(self, *args): - """capacity(self) -> size_t""" - return _idaapi.udtmembervec_t_capacity(self, *args) - - def reserve(self, *args): - """reserve(self, cnt)""" - return _idaapi.udtmembervec_t_reserve(self, *args) - - def truncate(self, *args): - """truncate(self)""" - return _idaapi.udtmembervec_t_truncate(self, *args) - - def swap(self, *args): - """swap(self, r)""" - return _idaapi.udtmembervec_t_swap(self, *args) - - def extract(self, *args): - """extract(self) -> udt_member_t""" - return _idaapi.udtmembervec_t_extract(self, *args) - - def inject(self, *args): - """inject(self, s, len)""" - return _idaapi.udtmembervec_t_inject(self, *args) - - def __eq__(self, *args): - """__eq__(self, r) -> bool""" - return _idaapi.udtmembervec_t___eq__(self, *args) - - def __ne__(self, *args): - """__ne__(self, r) -> bool""" - return _idaapi.udtmembervec_t___ne__(self, *args) - - def begin(self, *args): - """ - begin(self) -> udt_member_t - begin(self) -> udt_member_t - """ - return _idaapi.udtmembervec_t_begin(self, *args) - - def end(self, *args): - """ - end(self) -> udt_member_t - end(self) -> udt_member_t - """ - return _idaapi.udtmembervec_t_end(self, *args) - - def insert(self, *args): - """insert(self, it, x) -> udt_member_t""" - return _idaapi.udtmembervec_t_insert(self, *args) - - def erase(self, *args): - """ - erase(self, it) -> udt_member_t - erase(self, first, last) -> udt_member_t - """ - return _idaapi.udtmembervec_t_erase(self, *args) - - def find(self, *args): - """ - find(self, x) -> udt_member_t - find(self, x) -> udt_member_t - """ - return _idaapi.udtmembervec_t_find(self, *args) - - def has(self, *args): - """has(self, x) -> bool""" - return _idaapi.udtmembervec_t_has(self, *args) - - def add_unique(self, *args): - """add_unique(self, x) -> bool""" - return _idaapi.udtmembervec_t_add_unique(self, *args) - - def _del(self, *args): - """_del(self, x) -> bool""" - return _idaapi.udtmembervec_t__del(self, *args) - - def __len__(self, *args): - """__len__(self) -> size_t""" - return _idaapi.udtmembervec_t___len__(self, *args) - - def __getitem__(self, *args): - """__getitem__(self, i) -> udt_member_t""" - return _idaapi.udtmembervec_t___getitem__(self, *args) - - def __setitem__(self, *args): - """__setitem__(self, i, v)""" - return _idaapi.udtmembervec_t___setitem__(self, *args) - - __iter__ = _bounded_getitem_iterator - -udtmembervec_t_swigregister = _idaapi.udtmembervec_t_swigregister -udtmembervec_t_swigregister(udtmembervec_t) - RESERVED_BYTE = _idaapi.RESERVED_BYTE def is_type_const(*args): - """is_type_const(t) -> bool""" + """ + is_type_const(t) -> bool + """ return _idaapi.is_type_const(*args) def is_type_volatile(*args): - """is_type_volatile(t) -> bool""" + """ + is_type_volatile(t) -> bool + """ return _idaapi.is_type_volatile(*args) def get_base_type(*args): - """get_base_type(t) -> type_t""" + """ + get_base_type(t) -> type_t + """ return _idaapi.get_base_type(*args) def get_type_flags(*args): - """get_type_flags(t) -> type_t""" + """ + get_type_flags(t) -> type_t + """ return _idaapi.get_type_flags(*args) def get_full_type(*args): - """get_full_type(t) -> type_t""" + """ + get_full_type(t) -> type_t + """ return _idaapi.get_full_type(*args) def is_typeid_last(*args): - """is_typeid_last(t) -> bool""" + """ + is_typeid_last(t) -> bool + """ return _idaapi.is_typeid_last(*args) def is_type_partial(*args): - """is_type_partial(t) -> bool""" + """ + is_type_partial(t) -> bool + """ return _idaapi.is_type_partial(*args) def is_type_void(*args): - """is_type_void(t) -> bool""" + """ + is_type_void(t) -> bool + """ return _idaapi.is_type_void(*args) def is_type_unknown(*args): - """is_type_unknown(t) -> bool""" + """ + is_type_unknown(t) -> bool + """ return _idaapi.is_type_unknown(*args) def is_type_ptr(*args): - """is_type_ptr(t) -> bool""" + """ + is_type_ptr(t) -> bool + """ return _idaapi.is_type_ptr(*args) def is_type_complex(*args): - """is_type_complex(t) -> bool""" + """ + is_type_complex(t) -> bool + """ return _idaapi.is_type_complex(*args) def is_type_func(*args): - """is_type_func(t) -> bool""" + """ + is_type_func(t) -> bool + """ return _idaapi.is_type_func(*args) def is_type_array(*args): - """is_type_array(t) -> bool""" + """ + is_type_array(t) -> bool + """ return _idaapi.is_type_array(*args) def is_type_typedef(*args): - """is_type_typedef(t) -> bool""" + """ + is_type_typedef(t) -> bool + """ return _idaapi.is_type_typedef(*args) def is_type_sue(*args): - """is_type_sue(t) -> bool""" + """ + is_type_sue(t) -> bool + """ return _idaapi.is_type_sue(*args) def is_type_struct(*args): - """is_type_struct(t) -> bool""" + """ + is_type_struct(t) -> bool + """ return _idaapi.is_type_struct(*args) def is_type_union(*args): - """is_type_union(t) -> bool""" + """ + is_type_union(t) -> bool + """ return _idaapi.is_type_union(*args) def is_type_struni(*args): - """is_type_struni(t) -> bool""" + """ + is_type_struni(t) -> bool + """ return _idaapi.is_type_struni(*args) def is_type_enum(*args): - """is_type_enum(t) -> bool""" + """ + is_type_enum(t) -> bool + """ return _idaapi.is_type_enum(*args) def is_type_bitfld(*args): - """is_type_bitfld(t) -> bool""" + """ + is_type_bitfld(t) -> bool + """ return _idaapi.is_type_bitfld(*args) def is_type_int(*args): - """is_type_int(bt) -> bool""" + """ + is_type_int(bt) -> bool + """ return _idaapi.is_type_int(*args) def is_type_int128(*args): - """is_type_int128(t) -> bool""" + """ + is_type_int128(t) -> bool + """ return _idaapi.is_type_int128(*args) def is_type_int64(*args): - """is_type_int64(t) -> bool""" + """ + is_type_int64(t) -> bool + """ return _idaapi.is_type_int64(*args) def is_type_int32(*args): - """is_type_int32(t) -> bool""" + """ + is_type_int32(t) -> bool + """ return _idaapi.is_type_int32(*args) def is_type_int16(*args): - """is_type_int16(t) -> bool""" + """ + is_type_int16(t) -> bool + """ return _idaapi.is_type_int16(*args) def is_type_char(*args): - """is_type_char(t) -> bool""" + """ + is_type_char(t) -> bool + """ return _idaapi.is_type_char(*args) def is_type_paf(*args): - """is_type_paf(t) -> bool""" + """ + is_type_paf(t) -> bool + """ return _idaapi.is_type_paf(*args) def is_type_ptr_or_array(*args): - """is_type_ptr_or_array(t) -> bool""" + """ + is_type_ptr_or_array(t) -> bool + """ return _idaapi.is_type_ptr_or_array(*args) def is_type_floating(*args): - """is_type_floating(t) -> bool""" + """ + is_type_floating(t) -> bool + """ return _idaapi.is_type_floating(*args) def is_type_integral(*args): - """is_type_integral(t) -> bool""" + """ + is_type_integral(t) -> bool + """ return _idaapi.is_type_integral(*args) def is_type_ext_integral(*args): - """is_type_ext_integral(t) -> bool""" + """ + is_type_ext_integral(t) -> bool + """ return _idaapi.is_type_ext_integral(*args) def is_type_arithmetic(*args): - """is_type_arithmetic(t) -> bool""" + """ + is_type_arithmetic(t) -> bool + """ return _idaapi.is_type_arithmetic(*args) def is_type_ext_arithmetic(*args): - """is_type_ext_arithmetic(t) -> bool""" + """ + is_type_ext_arithmetic(t) -> bool + """ return _idaapi.is_type_ext_arithmetic(*args) def is_type_uint(*args): - """is_type_uint(t) -> bool""" + """ + is_type_uint(t) -> bool + """ return _idaapi.is_type_uint(*args) def is_type_uchar(*args): - """is_type_uchar(t) -> bool""" + """ + is_type_uchar(t) -> bool + """ return _idaapi.is_type_uchar(*args) def is_type_uint16(*args): - """is_type_uint16(t) -> bool""" + """ + is_type_uint16(t) -> bool + """ return _idaapi.is_type_uint16(*args) def is_type_uint32(*args): - """is_type_uint32(t) -> bool""" + """ + is_type_uint32(t) -> bool + """ return _idaapi.is_type_uint32(*args) def is_type_uint64(*args): - """is_type_uint64(t) -> bool""" + """ + is_type_uint64(t) -> bool + """ return _idaapi.is_type_uint64(*args) def is_type_uint128(*args): - """is_type_uint128(t) -> bool""" + """ + is_type_uint128(t) -> bool + """ return _idaapi.is_type_uint128(*args) def is_type_ldouble(*args): - """is_type_ldouble(t) -> bool""" + """ + is_type_ldouble(t) -> bool + """ return _idaapi.is_type_ldouble(*args) def is_type_double(*args): - """is_type_double(t) -> bool""" + """ + is_type_double(t) -> bool + """ return _idaapi.is_type_double(*args) def is_type_float(*args): - """is_type_float(t) -> bool""" + """ + is_type_float(t) -> bool + """ return _idaapi.is_type_float(*args) def is_type_bool(*args): - """is_type_bool(t) -> bool""" + """ + is_type_bool(t) -> bool + """ return _idaapi.is_type_bool(*args) -TAH_BYTE = _idaapi.TAH_BYTE -FAH_BYTE = _idaapi.FAH_BYTE MAX_DECL_ALIGN = _idaapi.MAX_DECL_ALIGN TAH_HASATTRS = _idaapi.TAH_HASATTRS TAUDT_UNALIGNED = _idaapi.TAUDT_UNALIGNED @@ -26730,22 +28523,32 @@ TAPTR_PTR64 = _idaapi.TAPTR_PTR64 TAPTR_RESTRICT = _idaapi.TAPTR_RESTRICT TAENUM_64BIT = _idaapi.TAENUM_64BIT TAH_ALL = _idaapi.TAH_ALL +TAH_BYTE = _idaapi.TAH_BYTE +FAH_BYTE = _idaapi.FAH_BYTE def is_tah_byte(*args): - """is_tah_byte(t) -> bool""" + """ + is_tah_byte(t) -> bool + """ return _idaapi.is_tah_byte(*args) def is_sdacl_byte(*args): - """is_sdacl_byte(t) -> bool""" + """ + is_sdacl_byte(t) -> bool + """ return _idaapi.is_sdacl_byte(*args) class type_attr_t(object): - """Proxy of C++ type_attr_t class""" + """ + Proxy of C++ type_attr_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr key = _swig_property(_idaapi.type_attr_t_key_get, _idaapi.type_attr_t_key_set) value = _swig_property(_idaapi.type_attr_t_value_get, _idaapi.type_attr_t_value_set) - def __init__(self, *args): - """__init__(self) -> type_attr_t""" + def __init__(self, *args): + """ + __init__(self) -> type_attr_t + """ this = _idaapi.new_type_attr_t(*args) try: self.this.append(this) except: self.this = this @@ -26763,6 +28566,12 @@ BTMT_SIZE0 = cvar.BTMT_SIZE0 BTMT_SIZE12 = cvar.BTMT_SIZE12 BTMT_SIZE48 = cvar.BTMT_SIZE48 BTMT_SIZE128 = cvar.BTMT_SIZE128 +BT_UNK_BYTE = cvar.BT_UNK_BYTE +BT_UNK_WORD = cvar.BT_UNK_WORD +BT_UNK_DWORD = cvar.BT_UNK_DWORD +BT_UNK_QWORD = cvar.BT_UNK_QWORD +BT_UNK_OWORD = cvar.BT_UNK_OWORD +BT_UNKNOWN = cvar.BT_UNKNOWN BT_INT8 = cvar.BT_INT8 BT_INT16 = cvar.BT_INT16 BT_INT32 = cvar.BT_INT32 @@ -26774,6 +28583,7 @@ BTMT_SIGNED = cvar.BTMT_SIGNED BTMT_USIGNED = cvar.BTMT_USIGNED BTMT_UNSIGNED = cvar.BTMT_UNSIGNED BTMT_CHAR = cvar.BTMT_CHAR +BT_SEGREG = cvar.BT_SEGREG BT_BOOL = cvar.BT_BOOL BTMT_DEFBOOL = cvar.BTMT_DEFBOOL BTMT_BOOL1 = cvar.BTMT_BOOL1 @@ -26820,13 +28630,6 @@ BTE_CHAR = cvar.BTE_CHAR BTE_SDEC = cvar.BTE_SDEC BTE_UDEC = cvar.BTE_UDEC BTE_ALWAYS = cvar.BTE_ALWAYS -BT_SEGREG = cvar.BT_SEGREG -BT_UNK_BYTE = cvar.BT_UNK_BYTE -BT_UNK_WORD = cvar.BT_UNK_WORD -BT_UNK_DWORD = cvar.BT_UNK_DWORD -BT_UNK_QWORD = cvar.BT_UNK_QWORD -BT_UNK_OWORD = cvar.BT_UNK_OWORD -BT_UNKNOWN = cvar.BT_UNKNOWN BTF_BYTE = cvar.BTF_BYTE BTF_UNK = cvar.BTF_UNK BTF_VOID = cvar.BTF_VOID @@ -26857,58 +28660,86 @@ BTF_TYPEDEF = cvar.BTF_TYPEDEF def append_argloc(*args): - """append_argloc(out, vloc) -> bool""" + """ + append_argloc(out, vloc) -> bool + """ return _idaapi.append_argloc(*args) def is_restype_const(*args): - """is_restype_const(til, type) -> bool""" + """ + is_restype_const(til, type) -> bool + """ return _idaapi.is_restype_const(*args) def is_restype_void(*args): - """is_restype_void(til, type) -> bool""" + """ + is_restype_void(til, type) -> bool + """ return _idaapi.is_restype_void(*args) def is_restype_ptr(*args): - """is_restype_ptr(til, type) -> bool""" + """ + is_restype_ptr(til, type) -> bool + """ return _idaapi.is_restype_ptr(*args) def is_restype_func(*args): - """is_restype_func(til, type) -> bool""" + """ + is_restype_func(til, type) -> bool + """ return _idaapi.is_restype_func(*args) def is_restype_array(*args): - """is_restype_array(til, type) -> bool""" + """ + is_restype_array(til, type) -> bool + """ return _idaapi.is_restype_array(*args) def is_restype_complex(*args): - """is_restype_complex(til, type) -> bool""" + """ + is_restype_complex(til, type) -> bool + """ return _idaapi.is_restype_complex(*args) def is_restype_struct(*args): - """is_restype_struct(til, type) -> bool""" + """ + is_restype_struct(til, type) -> bool + """ return _idaapi.is_restype_struct(*args) def is_restype_union(*args): - """is_restype_union(til, type) -> bool""" + """ + is_restype_union(til, type) -> bool + """ return _idaapi.is_restype_union(*args) def is_restype_struni(*args): - """is_restype_struni(til, type) -> bool""" + """ + is_restype_struni(til, type) -> bool + """ return _idaapi.is_restype_struni(*args) def is_restype_enum(*args): - """is_restype_enum(til, type) -> bool""" + """ + is_restype_enum(til, type) -> bool + """ return _idaapi.is_restype_enum(*args) def is_restype_bitfld(*args): - """is_restype_bitfld(til, type) -> bool""" + """ + is_restype_bitfld(til, type) -> bool + """ return _idaapi.is_restype_bitfld(*args) def is_restype_floating(*args): - """is_restype_floating(til, type) -> bool""" + """ + is_restype_floating(til, type) -> bool + """ return _idaapi.is_restype_floating(*args) class til_t(object): - """Proxy of C++ til_t class""" + """ + Proxy of C++ til_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr name = _swig_property(_idaapi.til_t_name_get, _idaapi.til_t_name_set) @@ -26916,26 +28747,28 @@ class til_t(object): nbases = _swig_property(_idaapi.til_t_nbases_get, _idaapi.til_t_nbases_set) flags = _swig_property(_idaapi.til_t_flags_get, _idaapi.til_t_flags_set) def is_dirty(self, *args): - """is_dirty(self) -> bool""" + """ + is_dirty(self) -> bool + """ return _idaapi.til_t_is_dirty(self, *args) def set_dirty(self, *args): - """set_dirty(self)""" + """ + set_dirty(self) + """ return _idaapi.til_t_set_dirty(self, *args) cc = _swig_property(_idaapi.til_t_cc_get, _idaapi.til_t_cc_set) nrefs = _swig_property(_idaapi.til_t_nrefs_get, _idaapi.til_t_nrefs_set) nstreams = _swig_property(_idaapi.til_t_nstreams_get, _idaapi.til_t_nstreams_set) streams = _swig_property(_idaapi.til_t_streams_get, _idaapi.til_t_streams_set) - def __init__(self, *args): - """__init__(self) -> til_t""" + def __init__(self, *args): + """ + __init__(self) -> til_t + """ this = _idaapi.new_til_t(*args) try: self.this.append(this) except: self.this = this - def base(self, *args): - """base(self, n) -> til_t""" - return _idaapi.til_t_base(self, *args) - __swig_destroy__ = _idaapi.delete_til_t __del__ = lambda self : None; til_t_swigregister = _idaapi.til_t_swigregister @@ -26954,39 +28787,55 @@ TIL_STM = _idaapi.TIL_STM def new_til(*args): - """new_til(name, desc) -> til_t""" + """ + new_til(name, desc) -> til_t + """ return _idaapi.new_til(*args) TIL_ADD_FAILED = _idaapi.TIL_ADD_FAILED TIL_ADD_OK = _idaapi.TIL_ADD_OK TIL_ADD_ALREADY = _idaapi.TIL_ADD_ALREADY def compact_til(*args): - """compact_til(ti) -> bool""" + """ + compact_til(ti) -> bool + """ return _idaapi.compact_til(*args) def store_til(*args): - """store_til(ti, tildir, name) -> bool""" + """ + store_til(ti, tildir, name) -> bool + """ return _idaapi.store_til(*args) def free_til(*args): - """free_til(ti)""" + """ + free_til(ti) + """ return _idaapi.free_til(*args) def is_code_far(*args): - """is_code_far(cm) -> bool""" + """ + is_code_far(cm) -> bool + """ return _idaapi.is_code_far(*args) def is_data_far(*args): - """is_data_far(cm) -> bool""" + """ + is_data_far(cm) -> bool + """ return _idaapi.is_data_far(*args) class rrel_t(object): - """Proxy of C++ rrel_t class""" + """ + Proxy of C++ rrel_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr off = _swig_property(_idaapi.rrel_t_off_get, _idaapi.rrel_t_off_set) reg = _swig_property(_idaapi.rrel_t_reg_get, _idaapi.rrel_t_reg_set) - def __init__(self, *args): - """__init__(self) -> rrel_t""" + def __init__(self, *args): + """ + __init__(self) -> rrel_t + """ this = _idaapi.new_rrel_t(*args) try: self.this.append(this) except: self.this = this @@ -27037,10 +28886,12 @@ ALOC_STATIC = cvar.ALOC_STATIC ALOC_CUSTOM = cvar.ALOC_CUSTOM class argloc_t(object): - """Proxy of C++ argloc_t class""" + """ + Proxy of C++ argloc_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> argloc_t __init__(self, r) -> argloc_t @@ -27051,75 +28902,111 @@ class argloc_t(object): __swig_destroy__ = _idaapi.delete_argloc_t __del__ = lambda self : None; def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.argloc_t_swap(self, *args) def atype(self, *args): - """atype(self) -> argloc_type_t""" + """ + atype(self) -> argloc_type_t + """ return _idaapi.argloc_t_atype(self, *args) def is_reg1(self, *args): - """is_reg1(self) -> bool""" + """ + is_reg1(self) -> bool + """ return _idaapi.argloc_t_is_reg1(self, *args) def is_reg2(self, *args): - """is_reg2(self) -> bool""" + """ + is_reg2(self) -> bool + """ return _idaapi.argloc_t_is_reg2(self, *args) def is_reg(self, *args): - """is_reg(self) -> bool""" + """ + is_reg(self) -> bool + """ return _idaapi.argloc_t_is_reg(self, *args) def is_rrel(self, *args): - """is_rrel(self) -> bool""" + """ + is_rrel(self) -> bool + """ return _idaapi.argloc_t_is_rrel(self, *args) def is_ea(self, *args): - """is_ea(self) -> bool""" + """ + is_ea(self) -> bool + """ return _idaapi.argloc_t_is_ea(self, *args) def is_stkoff(self, *args): - """is_stkoff(self) -> bool""" + """ + is_stkoff(self) -> bool + """ return _idaapi.argloc_t_is_stkoff(self, *args) def is_scattered(self, *args): - """is_scattered(self) -> bool""" + """ + is_scattered(self) -> bool + """ return _idaapi.argloc_t_is_scattered(self, *args) def is_fragmented(self, *args): - """is_fragmented(self) -> bool""" + """ + is_fragmented(self) -> bool + """ return _idaapi.argloc_t_is_fragmented(self, *args) def is_custom(self, *args): - """is_custom(self) -> bool""" + """ + is_custom(self) -> bool + """ return _idaapi.argloc_t_is_custom(self, *args) def is_badloc(self, *args): - """is_badloc(self) -> bool""" + """ + is_badloc(self) -> bool + """ return _idaapi.argloc_t_is_badloc(self, *args) def reg1(self, *args): - """reg1(self) -> int""" + """ + reg1(self) -> int + """ return _idaapi.argloc_t_reg1(self, *args) def regoff(self, *args): - """regoff(self) -> int""" + """ + regoff(self) -> int + """ return _idaapi.argloc_t_regoff(self, *args) def reg2(self, *args): - """reg2(self) -> int""" + """ + reg2(self) -> int + """ return _idaapi.argloc_t_reg2(self, *args) def get_reginfo(self, *args): - """get_reginfo(self) -> uint32""" + """ + get_reginfo(self) -> uint32 + """ return _idaapi.argloc_t_get_reginfo(self, *args) def stkoff(self, *args): - """stkoff(self) -> sval_t""" + """ + stkoff(self) -> sval_t + """ return _idaapi.argloc_t_stkoff(self, *args) def get_ea(self, *args): - """get_ea(self) -> ea_t""" + """ + get_ea(self) -> ea_t + """ return _idaapi.argloc_t_get_ea(self, *args) def scattered(self, *args): @@ -27137,141 +29024,207 @@ class argloc_t(object): return _idaapi.argloc_t_get_rrel(self, *args) def get_custom(self, *args): - """get_custom(self) -> void *""" + """ + get_custom(self) -> void * + """ return _idaapi.argloc_t_get_custom(self, *args) def get_biggest(self, *args): - """get_biggest(self) -> argloc_t::biggest_t""" + """ + get_biggest(self) -> argloc_t::biggest_t + """ return _idaapi.argloc_t_get_biggest(self, *args) def _set_badloc(self, *args): - """_set_badloc(self)""" + """ + _set_badloc(self) + """ return _idaapi.argloc_t__set_badloc(self, *args) def _set_reg1(self, *args): - """_set_reg1(self, reg, off=0)""" + """ + _set_reg1(self, reg, off=0) + """ return _idaapi.argloc_t__set_reg1(self, *args) def _set_reg2(self, *args): - """_set_reg2(self, _reg1, _reg2)""" + """ + _set_reg2(self, _reg1, _reg2) + """ return _idaapi.argloc_t__set_reg2(self, *args) def _set_stkoff(self, *args): - """_set_stkoff(self, off)""" + """ + _set_stkoff(self, off) + """ return _idaapi.argloc_t__set_stkoff(self, *args) def _set_ea(self, *args): - """_set_ea(self, _ea)""" + """ + _set_ea(self, _ea) + """ return _idaapi.argloc_t__set_ea(self, *args) def _consume_rrel(self, *args): - """_consume_rrel(self, p) -> bool""" + """ + _consume_rrel(self, p) -> bool + """ return _idaapi.argloc_t__consume_rrel(self, *args) def _consume_scattered(self, *args): - """_consume_scattered(self, p) -> bool""" + """ + _consume_scattered(self, p) -> bool + """ return _idaapi.argloc_t__consume_scattered(self, *args) def _set_custom(self, *args): - """_set_custom(self, ct, pdata)""" + """ + _set_custom(self, ct, pdata) + """ return _idaapi.argloc_t__set_custom(self, *args) def _set_biggest(self, *args): - """_set_biggest(self, ct, data)""" + """ + _set_biggest(self, ct, data) + """ return _idaapi.argloc_t__set_biggest(self, *args) def set_reg1(self, *args): - """set_reg1(self, reg, off=0)""" + """ + set_reg1(self, reg, off=0) + """ return _idaapi.argloc_t_set_reg1(self, *args) def set_reg2(self, *args): - """set_reg2(self, _reg1, _reg2)""" + """ + set_reg2(self, _reg1, _reg2) + """ return _idaapi.argloc_t_set_reg2(self, *args) def set_stkoff(self, *args): - """set_stkoff(self, off)""" + """ + set_stkoff(self, off) + """ return _idaapi.argloc_t_set_stkoff(self, *args) def set_ea(self, *args): - """set_ea(self, _ea)""" + """ + set_ea(self, _ea) + """ return _idaapi.argloc_t_set_ea(self, *args) def consume_rrel(self, *args): - """consume_rrel(self, p)""" + """ + consume_rrel(self, p) + """ return _idaapi.argloc_t_consume_rrel(self, *args) def consume_scattered(self, *args): - """consume_scattered(self, p)""" + """ + consume_scattered(self, p) + """ return _idaapi.argloc_t_consume_scattered(self, *args) def set_badloc(self, *args): - """set_badloc(self)""" + """ + set_badloc(self) + """ return _idaapi.argloc_t_set_badloc(self, *args) def calc_offset(self, *args): - """calc_offset(self) -> sval_t""" + """ + calc_offset(self) -> sval_t + """ return _idaapi.argloc_t_calc_offset(self, *args) def advance(self, *args): - """advance(self, delta) -> bool""" + """ + advance(self, delta) -> bool + """ return _idaapi.argloc_t_advance(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.argloc_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.argloc_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.argloc_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.argloc_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.argloc_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.argloc_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.argloc_t_compare(self, *args) argloc_t_swigregister = _idaapi.argloc_t_swigregister argloc_t_swigregister(argloc_t) class argpart_t(argloc_t): - """Proxy of C++ argpart_t class""" + """ + Proxy of C++ argpart_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr off = _swig_property(_idaapi.argpart_t_off_get, _idaapi.argpart_t_off_set) size = _swig_property(_idaapi.argpart_t_size_get, _idaapi.argpart_t_size_set) - def __init__(self, *args): - """__init__(self) -> argpart_t""" + def __init__(self, *args): + """ + __init__(self) -> argpart_t + """ this = _idaapi.new_argpart_t(*args) try: self.this.append(this) except: self.this = this def bad_offset(self, *args): - """bad_offset(self) -> bool""" + """ + bad_offset(self) -> bool + """ return _idaapi.argpart_t_bad_offset(self, *args) def bad_size(self, *args): - """bad_size(self) -> bool""" + """ + bad_size(self) -> bool + """ return _idaapi.argpart_t_bad_size(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.argpart_t___lt__(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.argpart_t_swap(self, *args) __swig_destroy__ = _idaapi.delete_argpart_t @@ -27280,11 +29233,15 @@ argpart_t_swigregister = _idaapi.argpart_t_swigregister argpart_t_swigregister(argpart_t) class scattered_aloc_t(object): - """Proxy of C++ scattered_aloc_t class""" + """ + Proxy of C++ scattered_aloc_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> scattered_aloc_t""" + def __init__(self, *args): + """ + __init__(self) -> scattered_aloc_t + """ this = _idaapi.new_scattered_aloc_t(*args) try: self.this.append(this) except: self.this = this @@ -27295,25 +29252,35 @@ scattered_aloc_t_swigregister(scattered_aloc_t) def verify_argloc(*args): - """verify_argloc(vloc, size, gaps) -> int""" + """ + verify_argloc(vloc, size, gaps) -> int + """ return _idaapi.verify_argloc(*args) def optimize_argloc(*args): - """optimize_argloc(vloc, size, gaps) -> bool""" + """ + optimize_argloc(vloc, size, gaps) -> bool + """ return _idaapi.optimize_argloc(*args) def print_argloc(*args): - """print_argloc(vloc, size=0, vflags=0) -> size_t""" + """ + print_argloc(vloc, size=0, vflags=0) -> size_t + """ return _idaapi.print_argloc(*args) PRALOC_VERIFY = _idaapi.PRALOC_VERIFY PRALOC_STKOFF = _idaapi.PRALOC_STKOFF class aloc_visitor_t(object): - """Proxy of C++ aloc_visitor_t class""" + """ + Proxy of C++ aloc_visitor_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr def visit_location(self, *args): - """visit_location(self, v, off, size) -> int""" + """ + visit_location(self, v, off, size) -> int + """ return _idaapi.aloc_visitor_t_visit_location(self, *args) __swig_destroy__ = _idaapi.delete_aloc_visitor_t @@ -27323,15 +29290,21 @@ aloc_visitor_t_swigregister(aloc_visitor_t) def for_all_arglocs(*args): - """for_all_arglocs(vv, vloc, size, off=0) -> int""" + """ + for_all_arglocs(vv, vloc, size, off=0) -> int + """ return _idaapi.for_all_arglocs(*args) class const_aloc_visitor_t(object): - """Proxy of C++ const_aloc_visitor_t class""" + """ + Proxy of C++ const_aloc_visitor_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr def visit_location(self, *args): - """visit_location(self, v, off, size) -> int""" + """ + visit_location(self, v, off, size) -> int + """ return _idaapi.const_aloc_visitor_t_visit_location(self, *args) __swig_destroy__ = _idaapi.delete_const_aloc_visitor_t @@ -27341,7 +29314,9 @@ const_aloc_visitor_t_swigregister(const_aloc_visitor_t) def for_all_const_arglocs(*args): - """for_all_const_arglocs(vv, vloc, size, off=0) -> int""" + """ + for_all_const_arglocs(vv, vloc, size, off=0) -> int + """ return _idaapi.for_all_const_arglocs(*args) ARGREGS_POLICY_UNDEFINED = _idaapi.ARGREGS_POLICY_UNDEFINED ARGREGS_GP_ONLY = _idaapi.ARGREGS_GP_ONLY @@ -27349,17 +29324,21 @@ ARGREGS_INDEPENDENT = _idaapi.ARGREGS_INDEPENDENT ARGREGS_BY_SLOTS = _idaapi.ARGREGS_BY_SLOTS def callregs_init_regs(*args): - """callregs_init_regs(_this, request)""" + """ + callregs_init_regs(_this, request) + """ return _idaapi.callregs_init_regs(*args) class callregs_t(object): - """Proxy of C++ callregs_t class""" + """ + Proxy of C++ callregs_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr policy = _swig_property(_idaapi.callregs_t_policy_get, _idaapi.callregs_t_policy_set) nregs = _swig_property(_idaapi.callregs_t_nregs_get, _idaapi.callregs_t_nregs_set) gpregs = _swig_property(_idaapi.callregs_t_gpregs_get, _idaapi.callregs_t_gpregs_set) fpregs = _swig_property(_idaapi.callregs_t_fpregs_get, _idaapi.callregs_t_fpregs_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> callregs_t __init__(self, request) -> callregs_t @@ -27368,24 +29347,34 @@ class callregs_t(object): try: self.this.append(this) except: self.this = this def init_regs(self, *args): - """init_regs(self, request)""" + """ + init_regs(self, request) + """ return _idaapi.callregs_t_init_regs(self, *args) def set(self, *args): - """set(self, _policy, gprs, fprs)""" + """ + set(self, _policy, gprs, fprs) + """ return _idaapi.callregs_t_set(self, *args) def reset(self, *args): - """reset(self)""" + """ + reset(self) + """ return _idaapi.callregs_t_reset(self, *args) def regcount(*args): - """regcount(request) -> int""" + """ + regcount(request) -> int + """ return _idaapi.callregs_t_regcount(*args) regcount = staticmethod(regcount) def reginds(self, *args): - """reginds(self, gp_ind, fp_ind, r) -> bool""" + """ + reginds(self, gp_ind, fp_ind, r) -> bool + """ return _idaapi.callregs_t_reginds(self, *args) __swig_destroy__ = _idaapi.delete_callregs_t @@ -27394,66 +29383,96 @@ callregs_t_swigregister = _idaapi.callregs_t_swigregister callregs_t_swigregister(callregs_t) def callregs_t_regcount(*args): - """callregs_t_regcount(request) -> int""" + """ + callregs_t_regcount(request) -> int + """ return _idaapi.callregs_t_regcount(*args) def is_user_cc(*args): - """is_user_cc(cm) -> bool""" + """ + is_user_cc(cm) -> bool + """ return _idaapi.is_user_cc(*args) def is_vararg_cc(*args): - """is_vararg_cc(cm) -> bool""" + """ + is_vararg_cc(cm) -> bool + """ return _idaapi.is_vararg_cc(*args) def is_purging_cc(*args): - """is_purging_cc(cm) -> bool""" + """ + is_purging_cc(cm) -> bool + """ return _idaapi.is_purging_cc(*args) def get_comp(*args): - """get_comp(comp) -> comp_t""" + """ + get_comp(comp) -> comp_t + """ return _idaapi.get_comp(*args) def get_compiler_name(*args): - """get_compiler_name(id) -> char const *""" + """ + get_compiler_name(id) -> char const * + """ return _idaapi.get_compiler_name(*args) def get_compiler_abbr(*args): - """get_compiler_abbr(id) -> char const *""" + """ + get_compiler_abbr(id) -> char const * + """ return _idaapi.get_compiler_abbr(*args) def get_compilers(*args): - """get_compilers(ids, names, abbrs)""" + """ + get_compilers(ids, names, abbrs) + """ return _idaapi.get_compilers(*args) def is_comp_unsure(*args): - """is_comp_unsure(comp) -> comp_t""" + """ + is_comp_unsure(comp) -> comp_t + """ return _idaapi.is_comp_unsure(*args) def default_compiler(*args): - """default_compiler() -> comp_t""" + """ + default_compiler() -> comp_t + """ return _idaapi.default_compiler(*args) def is_gcc(*args): - """is_gcc() -> bool""" + """ + is_gcc() -> bool + """ return _idaapi.is_gcc(*args) def is_gcc32(*args): - """is_gcc32() -> bool""" + """ + is_gcc32() -> bool + """ return _idaapi.is_gcc32(*args) def is_gcc64(*args): - """is_gcc64() -> bool""" + """ + is_gcc64() -> bool + """ return _idaapi.is_gcc64(*args) def set_compiler(*args): - """set_compiler(cc, flags) -> bool""" + """ + set_compiler(cc, flags) -> bool + """ return _idaapi.set_compiler(*args) SETCOMP_OVERRIDE = _idaapi.SETCOMP_OVERRIDE SETCOMP_ONLY_ID = _idaapi.SETCOMP_ONLY_ID def set_compiler_id(*args): - """set_compiler_id(id) -> bool""" + """ + set_compiler_id(id) -> bool + """ return _idaapi.set_compiler_id(*args) MAX_FUNC_ARGS = _idaapi.MAX_FUNC_ARGS abs_unk = _idaapi.abs_unk @@ -27491,7 +29510,9 @@ HTI_HIGH = _idaapi.HTI_HIGH HTI_LOWER = _idaapi.HTI_LOWER def parse_decl2(*args): - """parse_decl2(til, decl, name, tif, flags) -> bool""" + """ + parse_decl2(til, decl, name, tif, flags) -> bool + """ return _idaapi.parse_decl2(*args) PT_SIL = _idaapi.PT_SIL PT_NDC = _idaapi.PT_NDC @@ -27500,19 +29521,24 @@ PT_VAR = _idaapi.PT_VAR PT_PACKMASK = _idaapi.PT_PACKMASK PT_HIGH = _idaapi.PT_HIGH PT_LOWER = _idaapi.PT_LOWER -PT_REPLACE = _idaapi.PT_REPLACE def convert_pt_flags_to_hti(*args): - """convert_pt_flags_to_hti(pt_flags) -> int""" + """ + convert_pt_flags_to_hti(pt_flags) -> int + """ return _idaapi.convert_pt_flags_to_hti(*args) def parse_decls(*args): - """parse_decls(til, input, printer, hti_flags) -> int""" + """ + parse_decls(til, input, printer, hti_flags) -> int + """ return _idaapi.parse_decls(*args) -def print_type3(*args): - """print_type3(ea, prtype_flags) -> bool""" - return _idaapi.print_type3(*args) +def print_type2(*args): + """ + print_type2(ea, prtype_flags) -> bool + """ + return _idaapi.print_type2(*args) PRTYPE_1LINE = _idaapi.PRTYPE_1LINE PRTYPE_MULTI = _idaapi.PRTYPE_MULTI PRTYPE_TYPE = _idaapi.PRTYPE_TYPE @@ -27522,7 +29548,6 @@ PRTYPE_CPP = _idaapi.PRTYPE_CPP PRTYPE_DEF = _idaapi.PRTYPE_DEF PRTYPE_NOARGS = _idaapi.PRTYPE_NOARGS PRTYPE_NOARRS = _idaapi.PRTYPE_NOARRS -PRTYPE_NORES = _idaapi.PRTYPE_NORES NTF_TYPE = _idaapi.NTF_TYPE NTF_SYMU = _idaapi.NTF_SYMU NTF_SYMM = _idaapi.NTF_SYMM @@ -27532,90 +29557,133 @@ NTF_UMANGLED = _idaapi.NTF_UMANGLED NTF_NOCUR = _idaapi.NTF_NOCUR NTF_64BIT = _idaapi.NTF_64BIT +def get_named_type64(*args): + """ + get_named_type64(ti, name, ntf_flags, type=None, fields=None, cmt=None, fieldcmts=None, sclass=None, + value=None) -> int + """ + return _idaapi.get_named_type64(*args) + def set_named_type64(*args): - """set_named_type64(ti, name, ntf_flags, ptr, fields=None, cmt=None, fieldcmts=None, sclass=None, value=None) -> bool""" + """ + set_named_type64(ti, name, ntf_flags, ptr, fields=None, cmt=None, fieldcmts=None, sclass=None, value=None) -> bool + """ return _idaapi.set_named_type64(*args) def del_named_type(*args): - """del_named_type(ti, name, ntf_flags) -> bool""" + """ + del_named_type(ti, name, ntf_flags) -> bool + """ return _idaapi.del_named_type(*args) def rename_named_type(*args): - """rename_named_type(ti, frm, to, ntf_flags) -> int""" + """ + rename_named_type(ti, frm, to, ntf_flags) -> int + """ return _idaapi.rename_named_type(*args) def first_named_type(*args): - """first_named_type(ti, ntf_flags) -> char const *""" + """ + first_named_type(ti, ntf_flags) -> char const * + """ return _idaapi.first_named_type(*args) def next_named_type(*args): - """next_named_type(ti, name, ntf_flags) -> char const *""" + """ + next_named_type(ti, name, ntf_flags) -> char const * + """ return _idaapi.next_named_type(*args) def gen_decorate_name3(*args): - """gen_decorate_name3(name, mangle, cc) -> bool""" + """ + gen_decorate_name3(out, name, mangle, cc) -> bool + """ return _idaapi.gen_decorate_name3(*args) - -def calc_c_cpp_name4(*args): - """calc_c_cpp_name4(name, type, ccn_flags) -> ssize_t""" - return _idaapi.calc_c_cpp_name4(*args) CCN_C = _idaapi.CCN_C CCN_CPP = _idaapi.CCN_CPP def get_numbered_type(*args): - """get_numbered_type(ti, ordinal, type=None, fields=None, cmt=None, fieldcmts=None, sclass=None) -> bool""" + """ + get_numbered_type(ti, ordinal, type=None, fields=None, cmt=None, fieldcmts=None, sclass=None) -> bool + """ return _idaapi.get_numbered_type(*args) def alloc_type_ordinals(*args): - """alloc_type_ordinals(ti, qty) -> uint32""" + """ + alloc_type_ordinals(ti, qty) -> uint32 + """ return _idaapi.alloc_type_ordinals(*args) def alloc_type_ordinal(*args): - """alloc_type_ordinal(ti) -> uint32""" + """ + alloc_type_ordinal(ti) -> uint32 + """ return _idaapi.alloc_type_ordinal(*args) def get_ordinal_qty(*args): - """get_ordinal_qty(ti) -> uint32""" + """ + get_ordinal_qty(ti) -> uint32 + """ return _idaapi.get_ordinal_qty(*args) def set_numbered_type(*args): - """set_numbered_type(ti, ordinal, ntf_flags, name, type, fields=None, cmt=None, fldcmts=None, sclass=None) -> bool""" + """ + set_numbered_type(ti, ordinal, ntf_flags, name, type, fields=None, cmt=None, fldcmts=None, sclass=None) -> bool + """ return _idaapi.set_numbered_type(*args) def del_numbered_type(*args): - """del_numbered_type(ti, ordinal) -> bool""" + """ + del_numbered_type(ti, ordinal) -> bool + """ return _idaapi.del_numbered_type(*args) def set_type_alias(*args): - """set_type_alias(ti, src_ordinal, dst_ordinal) -> bool""" + """ + set_type_alias(ti, src_ordinal, dst_ordinal) -> bool + """ return _idaapi.set_type_alias(*args) def get_alias_target(*args): - """get_alias_target(ti, ordinal) -> uint32""" + """ + get_alias_target(ti, ordinal) -> uint32 + """ return _idaapi.get_alias_target(*args) def get_type_ordinal(*args): - """get_type_ordinal(ti, name) -> int32""" + """ + get_type_ordinal(ti, name) -> int32 + """ return _idaapi.get_type_ordinal(*args) def get_numbered_type_name(*args): - """get_numbered_type_name(ti, ordinal) -> char const *""" + """ + get_numbered_type_name(ti, ordinal) -> char const * + """ return _idaapi.get_numbered_type_name(*args) def create_numbered_type_name(*args): - """create_numbered_type_name(ord) -> size_t""" + """ + create_numbered_type_name(ord) -> size_t + """ return _idaapi.create_numbered_type_name(*args) def create_numbered_type_reference(*args): - """create_numbered_type_reference(out, ord) -> bool""" + """ + create_numbered_type_reference(out, ord) -> bool + """ return _idaapi.create_numbered_type_reference(*args) def is_ordinal_name(*args): - """is_ordinal_name(name, ord) -> bool""" + """ + is_ordinal_name(name, ord) -> bool + """ return _idaapi.is_ordinal_name(*args) def get_ordinal_from_idb_type(*args): - """get_ordinal_from_idb_type(name, type) -> int""" + """ + get_ordinal_from_idb_type(name, type) -> int + """ return _idaapi.get_ordinal_from_idb_type(*args) def is_autosync(*args): @@ -27626,30 +29694,42 @@ def is_autosync(*args): return _idaapi.is_autosync(*args) def get_referred_ordinal(*args): - """get_referred_ordinal(ptype) -> uint32""" + """ + get_referred_ordinal(ptype) -> uint32 + """ return _idaapi.get_referred_ordinal(*args) def deref_ptr2(*args): - """deref_ptr2(tif, ptr_ea, closure_obj=None) -> bool""" + """ + deref_ptr2(tif, ptr_ea, closure_obj=None) -> bool + """ return _idaapi.deref_ptr2(*args) def remove_tinfo_pointer(*args): - """remove_tinfo_pointer(til, tif, pname) -> bool""" + """ + remove_tinfo_pointer(til, tif, pname) -> bool + """ return _idaapi.remove_tinfo_pointer(*args) def get_stkarg_offset(*args): - """get_stkarg_offset() -> int""" + """ + get_stkarg_offset() -> int + """ return _idaapi.get_stkarg_offset(*args) - -def import_type(*args): - """import_type(til, idx, name, flags=0) -> tid_t""" - return _idaapi.import_type(*args) IMPTYPE_VERBOSE = _idaapi.IMPTYPE_VERBOSE IMPTYPE_OVERRIDE = _idaapi.IMPTYPE_OVERRIDE IMPTYPE_LOCAL = _idaapi.IMPTYPE_LOCAL +def import_type(*args): + """ + import_type(til, idx, name, flags=0) -> tid_t + """ + return _idaapi.import_type(*args) + def add_til2(*args): - """add_til2(name, flags) -> int""" + """ + add_til2(name, flags) -> int + """ return _idaapi.add_til2(*args) ADDTIL_DEFAULT = _idaapi.ADDTIL_DEFAULT ADDTIL_INCOMP = _idaapi.ADDTIL_INCOMP @@ -27659,62 +29739,100 @@ ADDTIL_OK = _idaapi.ADDTIL_OK ADDTIL_COMP = _idaapi.ADDTIL_COMP def del_til(*args): - """del_til(name) -> bool""" + """ + del_til(name) -> bool + """ return _idaapi.del_til(*args) def apply_named_type(*args): - """apply_named_type(ea, name) -> bool""" + """ + apply_named_type(ea, name) -> bool + """ return _idaapi.apply_named_type(*args) - -def apply_tinfo2(*args): - """apply_tinfo2(ea, tif, flags) -> bool""" - return _idaapi.apply_tinfo2(*args) TINFO_GUESSED = _idaapi.TINFO_GUESSED TINFO_DEFINITE = _idaapi.TINFO_DEFINITE TINFO_DELAYFUNC = _idaapi.TINFO_DELAYFUNC +def apply_tinfo2(*args): + """ + apply_tinfo2(ea, tif, flags) -> bool + """ + return _idaapi.apply_tinfo2(*args) + def apply_cdecl2(*args): - """apply_cdecl2(til, ea, decl, flags=0) -> bool""" + """ + apply_cdecl2(til, ea, decl, flags=0) -> bool + """ return _idaapi.apply_cdecl2(*args) def apply_callee_tinfo(*args): - """apply_callee_tinfo(caller, tif)""" + """ + apply_callee_tinfo(caller, tif) + """ return _idaapi.apply_callee_tinfo(*args) def apply_once_tinfo_and_name(*args): - """apply_once_tinfo_and_name(dea, tif, name) -> bool""" + """ + apply_once_tinfo_and_name(dea, tif, name) -> bool + """ return _idaapi.apply_once_tinfo_and_name(*args) -def guess_tinfo2(*args): - """guess_tinfo2(id, tif) -> int""" - return _idaapi.guess_tinfo2(*args) +def guess_func_tinfo2(*args): + """ + guess_func_tinfo2(pfn, tif) -> int + """ + return _idaapi.guess_func_tinfo2(*args) GUESS_FUNC_FAILED = _idaapi.GUESS_FUNC_FAILED GUESS_FUNC_TRIVIAL = _idaapi.GUESS_FUNC_TRIVIAL GUESS_FUNC_OK = _idaapi.GUESS_FUNC_OK +def guess_tinfo2(*args): + """ + guess_tinfo2(id, tif) -> int + """ + return _idaapi.guess_tinfo2(*args) + def set_c_header_path(*args): - """set_c_header_path(incdir)""" + """ + set_c_header_path(incdir) + """ return _idaapi.set_c_header_path(*args) def get_c_header_path(*args): - """get_c_header_path() -> ssize_t""" + """ + get_c_header_path() -> ssize_t + """ return _idaapi.get_c_header_path(*args) def set_c_macros(*args): - """set_c_macros(macros)""" + """ + set_c_macros(macros) + """ return _idaapi.set_c_macros(*args) def get_c_macros(*args): - """get_c_macros() -> ssize_t""" + """ + get_c_macros() -> ssize_t + """ return _idaapi.get_c_macros(*args) def get_tilpath(*args): - """get_tilpath(tilbuf, tilbufsize) -> char *""" + """ + get_tilpath(tilbuf, tilbufsize) -> char * + """ return _idaapi.get_tilpath(*args) def get_idainfo_by_type3(*args): - """get_idainfo_by_type3(tif, psize, pflags, mt, alsize=None) -> bool""" + """ + get_idainfo_by_type3(tif, psize, pflags, mt, alsize=None) -> bool + """ return _idaapi.get_idainfo_by_type3(*args) + +def lower_type(*args): + """ + lower_type(til, tif, name=None) -> int + """ + return _idaapi.lower_type(*args) STI_PCHAR = _idaapi.STI_PCHAR STI_PUCHAR = _idaapi.STI_PUCHAR STI_PCCHAR = _idaapi.STI_PCCHAR @@ -27734,7 +29852,7 @@ STI_FDELOP = _idaapi.STI_FDELOP STI_MSGSEND = _idaapi.STI_MSGSEND STI_AEABI_LCMP = _idaapi.STI_AEABI_LCMP STI_AEABI_ULCMP = _idaapi.STI_AEABI_ULCMP -STI_DONT_USE = _idaapi.STI_DONT_USE +STI_GET_TASK = _idaapi.STI_GET_TASK STI_LAST = _idaapi.STI_LAST GTD_CALC_LAYOUT = _idaapi.GTD_CALC_LAYOUT GTD_NO_LAYOUT = _idaapi.GTD_NO_LAYOUT @@ -27757,117 +29875,173 @@ SUDT_VOLATILE = _idaapi.SUDT_VOLATILE SUDT_TRUNC = _idaapi.SUDT_TRUNC def copy_tinfo_t(*args): - """copy_tinfo_t(_this, r)""" + """ + copy_tinfo_t(_this, r) + """ return _idaapi.copy_tinfo_t(*args) def clear_tinfo_t(*args): - """clear_tinfo_t(_this)""" + """ + clear_tinfo_t(_this) + """ return _idaapi.clear_tinfo_t(*args) def create_tinfo(*args): - """create_tinfo(_this, bt, bt2, ptr) -> bool""" + """ + create_tinfo(_this, bt, bt2, ptr) -> bool + """ return _idaapi.create_tinfo(*args) def verify_tinfo(*args): - """verify_tinfo(typid) -> int""" + """ + verify_tinfo(typid) -> int + """ return _idaapi.verify_tinfo(*args) def get_tinfo_details(*args): - """get_tinfo_details(typid, bt2, buf) -> bool""" + """ + get_tinfo_details(typid, bt2, buf) -> bool + """ return _idaapi.get_tinfo_details(*args) def get_tinfo_size(*args): - """get_tinfo_size(typid, p_effalign, gts_code) -> size_t""" + """ + get_tinfo_size(typid, p_effalign, gts_code) -> size_t + """ return _idaapi.get_tinfo_size(*args) def get_tinfo_pdata(*args): - """get_tinfo_pdata(typid, outptr, what) -> size_t""" + """ + get_tinfo_pdata(typid, outptr, what) -> size_t + """ return _idaapi.get_tinfo_pdata(*args) def get_tinfo_property(*args): - """get_tinfo_property(typid, gta_prop) -> size_t""" + """ + get_tinfo_property(typid, gta_prop) -> size_t + """ return _idaapi.get_tinfo_property(*args) def set_tinfo_property(*args): - """set_tinfo_property(tif, sta_prop, x) -> size_t""" + """ + set_tinfo_property(tif, sta_prop, x) -> size_t + """ return _idaapi.set_tinfo_property(*args) def serialize_tinfo(*args): - """serialize_tinfo(type, fields, fldcmts, tif, sudt_flags) -> bool""" + """ + serialize_tinfo(type, fields, fldcmts, tif, sudt_flags) -> bool + """ return _idaapi.serialize_tinfo(*args) def deserialize_tinfo(*args): - """deserialize_tinfo(tif, til, ptype, pfields, pfldcmts) -> bool""" + """ + deserialize_tinfo(tif, til, ptype, pfields, pfldcmts) -> bool + """ return _idaapi.deserialize_tinfo(*args) def find_tinfo_udt_member(*args): - """find_tinfo_udt_member(typid, strmem_flags, udm) -> int""" + """ + find_tinfo_udt_member(typid, strmem_flags, udm) -> int + """ return _idaapi.find_tinfo_udt_member(*args) def print_tinfo(*args): - """print_tinfo(prefix, indent, cmtindent, flags, tif, name, cmt) -> bool""" + """ + print_tinfo(prefix, indent, cmtindent, flags, tif, name, cmt) -> bool + """ return _idaapi.print_tinfo(*args) def dstr_tinfo(*args): - """dstr_tinfo(tif) -> char const *""" + """ + dstr_tinfo(tif) -> char const * + """ return _idaapi.dstr_tinfo(*args) def visit_subtypes(*args): - """visit_subtypes(visitor, out, tif, name, cmt) -> int""" + """ + visit_subtypes(visitor, out, tif, name, cmt) -> int + """ return _idaapi.visit_subtypes(*args) def compare_tinfo(*args): - """compare_tinfo(t1, t2, tcflags) -> bool""" + """ + compare_tinfo(t1, t2, tcflags) -> bool + """ return _idaapi.compare_tinfo(*args) def lexcompare_tinfo(*args): - """lexcompare_tinfo(t1, t2, arg3) -> int""" + """ + lexcompare_tinfo(t1, t2, arg3) -> int + """ return _idaapi.lexcompare_tinfo(*args) def get_stock_tinfo(*args): - """get_stock_tinfo(tif, id) -> bool""" + """ + get_stock_tinfo(tif, id) -> bool + """ return _idaapi.get_stock_tinfo(*args) def read_tinfo_bitfield_value(*args): - """read_tinfo_bitfield_value(typid, v, bitoff) -> uint64""" + """ + read_tinfo_bitfield_value(typid, v, bitoff) -> uint64 + """ return _idaapi.read_tinfo_bitfield_value(*args) def write_tinfo_bitfield_value(*args): - """write_tinfo_bitfield_value(typid, dst, v, bitoff) -> uint64""" + """ + write_tinfo_bitfield_value(typid, dst, v, bitoff) -> uint64 + """ return _idaapi.write_tinfo_bitfield_value(*args) def get_tinfo_attr(*args): - """get_tinfo_attr(typid, key, bv, all_attrs) -> bool""" + """ + get_tinfo_attr(typid, key, bv, all_attrs) -> bool + """ return _idaapi.get_tinfo_attr(*args) def set_tinfo_attr(*args): - """set_tinfo_attr(tif, ta, may_overwrite) -> bool""" + """ + set_tinfo_attr(tif, ta, may_overwrite) -> bool + """ return _idaapi.set_tinfo_attr(*args) def del_tinfo_attr(*args): - """del_tinfo_attr(tif, key) -> bool""" + """ + del_tinfo_attr(tif, key) -> bool + """ return _idaapi.del_tinfo_attr(*args) def get_tinfo_attrs(*args): - """get_tinfo_attrs(typid, tav, include_ref_attrs) -> bool""" + """ + get_tinfo_attrs(typid, tav, include_ref_attrs) -> bool + """ return _idaapi.get_tinfo_attrs(*args) def set_tinfo_attrs(*args): - """set_tinfo_attrs(tif, ta) -> bool""" + """ + set_tinfo_attrs(tif, ta) -> bool + """ return _idaapi.set_tinfo_attrs(*args) def score_tinfo(*args): - """score_tinfo(tif) -> uint32""" + """ + score_tinfo(tif) -> uint32 + """ return _idaapi.score_tinfo(*args) def save_tinfo(*args): - """save_tinfo(til, ord, name, ntf_flags, tif) -> tinfo_code_t""" + """ + save_tinfo(til, ord, name, ntf_flags, tif) -> tinfo_code_t + """ return _idaapi.save_tinfo(*args) class tinfo_t(object): - """Proxy of C++ tinfo_t class""" + """ + Proxy of C++ tinfo_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self, decl_type=BT_UNK) -> tinfo_t __init__(self, r) -> tinfo_t @@ -27876,559 +30050,831 @@ class tinfo_t(object): try: self.this.append(this) except: self.this = this def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.tinfo_t_clear(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.tinfo_t_swap(self, *args) - def get_named_type(self, *args): - """get_named_type(self, til, name, decl_type=BTF_TYPEDEF, resolve=True, try_ordinal=True) -> bool""" - return _idaapi.tinfo_t_get_named_type(self, *args) - def get_numbered_type(self, *args): - """get_numbered_type(self, til, ordinal, decl_type=BTF_TYPEDEF, resolve=True) -> bool""" + """ + get_numbered_type(self, til, ordinal, decl_type=BTF_TYPEDEF, resolve=True) -> bool + """ return _idaapi.tinfo_t_get_numbered_type(self, *args) def serialize(self, *args): - """serialize(self, type, fields=None, fldcmts=None, sudt_flags=0x0010|0x0100) -> bool""" + """ + serialize(self, type, fields=None, fldcmts=None, sudt_flags=0x0010|0x0100) -> bool + """ return _idaapi.tinfo_t_serialize(self, *args) def is_correct(self, *args): - """is_correct(self) -> bool""" + """ + is_correct(self) -> bool + """ return _idaapi.tinfo_t_is_correct(self, *args) def get_realtype(self, *args): - """get_realtype(self, full=False) -> type_t""" + """ + get_realtype(self, full=False) -> type_t + """ return _idaapi.tinfo_t_get_realtype(self, *args) def get_decltype(self, *args): - """get_decltype(self) -> type_t""" + """ + get_decltype(self) -> type_t + """ return _idaapi.tinfo_t_get_decltype(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.tinfo_t_empty(self, *args) def present(self, *args): - """present(self) -> bool""" + """ + present(self) -> bool + """ return _idaapi.tinfo_t_present(self, *args) def get_size(self, *args): - """get_size(self, p_effalign=None, gts_code=0) -> size_t""" + """ + get_size(self, p_effalign=None, gts_code=0) -> size_t + """ return _idaapi.tinfo_t_get_size(self, *args) def get_unpadded_size(self, *args): - """get_unpadded_size(self) -> size_t""" + """ + get_unpadded_size(self) -> size_t + """ return _idaapi.tinfo_t_get_unpadded_size(self, *args) def get_sign(self, *args): - """get_sign(self) -> type_sign_t""" + """ + get_sign(self) -> type_sign_t + """ return _idaapi.tinfo_t_get_sign(self, *args) def is_signed(self, *args): - """is_signed(self) -> bool""" + """ + is_signed(self) -> bool + """ return _idaapi.tinfo_t_is_signed(self, *args) def is_unsigned(self, *args): - """is_unsigned(self) -> bool""" + """ + is_unsigned(self) -> bool + """ return _idaapi.tinfo_t_is_unsigned(self, *args) def get_declalign(self, *args): - """get_declalign(self) -> uchar""" + """ + get_declalign(self) -> uchar + """ return _idaapi.tinfo_t_get_declalign(self, *args) def set_declalign(self, *args): - """set_declalign(self, declalign) -> bool""" + """ + set_declalign(self, declalign) -> bool + """ return _idaapi.tinfo_t_set_declalign(self, *args) def is_typeref(self, *args): - """is_typeref(self) -> bool""" + """ + is_typeref(self) -> bool + """ return _idaapi.tinfo_t_is_typeref(self, *args) def has_details(self, *args): - """has_details(self) -> bool""" + """ + has_details(self) -> bool + """ return _idaapi.tinfo_t_has_details(self, *args) def get_type_name(self, *args): - """get_type_name(self, name) -> bool""" + """ + get_type_name(self, name) -> bool + """ return _idaapi.tinfo_t_get_type_name(self, *args) def get_final_type_name(self, *args): - """get_final_type_name(self, name) -> bool""" + """ + get_final_type_name(self, name) -> bool + """ return _idaapi.tinfo_t_get_final_type_name(self, *args) def get_next_type_name(self, *args): - """get_next_type_name(self, name) -> bool""" + """ + get_next_type_name(self, name) -> bool + """ return _idaapi.tinfo_t_get_next_type_name(self, *args) def get_ordinal(self, *args): - """get_ordinal(self) -> uint32""" + """ + get_ordinal(self) -> uint32 + """ return _idaapi.tinfo_t_get_ordinal(self, *args) def get_final_ordinal(self, *args): - """get_final_ordinal(self) -> uint32""" + """ + get_final_ordinal(self) -> uint32 + """ return _idaapi.tinfo_t_get_final_ordinal(self, *args) def get_til(self, *args): - """get_til(self) -> til_t""" + """ + get_til(self) -> til_t + """ return _idaapi.tinfo_t_get_til(self, *args) def is_from_subtil(self, *args): - """is_from_subtil(self) -> bool""" + """ + is_from_subtil(self) -> bool + """ return _idaapi.tinfo_t_is_from_subtil(self, *args) def is_forward_decl(self, *args): - """is_forward_decl(self) -> bool""" + """ + is_forward_decl(self) -> bool + """ return _idaapi.tinfo_t_is_forward_decl(self, *args) def is_decl_const(self, *args): - """is_decl_const(self) -> bool""" + """ + is_decl_const(self) -> bool + """ return _idaapi.tinfo_t_is_decl_const(self, *args) def is_decl_volatile(self, *args): - """is_decl_volatile(self) -> bool""" + """ + is_decl_volatile(self) -> bool + """ return _idaapi.tinfo_t_is_decl_volatile(self, *args) def is_decl_void(self, *args): - """is_decl_void(self) -> bool""" + """ + is_decl_void(self) -> bool + """ return _idaapi.tinfo_t_is_decl_void(self, *args) def is_decl_partial(self, *args): - """is_decl_partial(self) -> bool""" + """ + is_decl_partial(self) -> bool + """ return _idaapi.tinfo_t_is_decl_partial(self, *args) def is_decl_unknown(self, *args): - """is_decl_unknown(self) -> bool""" + """ + is_decl_unknown(self) -> bool + """ return _idaapi.tinfo_t_is_decl_unknown(self, *args) def is_decl_last(self, *args): - """is_decl_last(self) -> bool""" + """ + is_decl_last(self) -> bool + """ return _idaapi.tinfo_t_is_decl_last(self, *args) def is_decl_ptr(self, *args): - """is_decl_ptr(self) -> bool""" + """ + is_decl_ptr(self) -> bool + """ return _idaapi.tinfo_t_is_decl_ptr(self, *args) def is_decl_array(self, *args): - """is_decl_array(self) -> bool""" + """ + is_decl_array(self) -> bool + """ return _idaapi.tinfo_t_is_decl_array(self, *args) def is_decl_func(self, *args): - """is_decl_func(self) -> bool""" + """ + is_decl_func(self) -> bool + """ return _idaapi.tinfo_t_is_decl_func(self, *args) def is_decl_complex(self, *args): - """is_decl_complex(self) -> bool""" + """ + is_decl_complex(self) -> bool + """ return _idaapi.tinfo_t_is_decl_complex(self, *args) def is_decl_typedef(self, *args): - """is_decl_typedef(self) -> bool""" + """ + is_decl_typedef(self) -> bool + """ return _idaapi.tinfo_t_is_decl_typedef(self, *args) def is_decl_sue(self, *args): - """is_decl_sue(self) -> bool""" + """ + is_decl_sue(self) -> bool + """ return _idaapi.tinfo_t_is_decl_sue(self, *args) def is_decl_struct(self, *args): - """is_decl_struct(self) -> bool""" + """ + is_decl_struct(self) -> bool + """ return _idaapi.tinfo_t_is_decl_struct(self, *args) def is_decl_union(self, *args): - """is_decl_union(self) -> bool""" + """ + is_decl_union(self) -> bool + """ return _idaapi.tinfo_t_is_decl_union(self, *args) def is_decl_udt(self, *args): - """is_decl_udt(self) -> bool""" + """ + is_decl_udt(self) -> bool + """ return _idaapi.tinfo_t_is_decl_udt(self, *args) def is_decl_enum(self, *args): - """is_decl_enum(self) -> bool""" + """ + is_decl_enum(self) -> bool + """ return _idaapi.tinfo_t_is_decl_enum(self, *args) def is_decl_bitfield(self, *args): - """is_decl_bitfield(self) -> bool""" + """ + is_decl_bitfield(self) -> bool + """ return _idaapi.tinfo_t_is_decl_bitfield(self, *args) def is_decl_int128(self, *args): - """is_decl_int128(self) -> bool""" + """ + is_decl_int128(self) -> bool + """ return _idaapi.tinfo_t_is_decl_int128(self, *args) def is_decl_int64(self, *args): - """is_decl_int64(self) -> bool""" + """ + is_decl_int64(self) -> bool + """ return _idaapi.tinfo_t_is_decl_int64(self, *args) def is_decl_int32(self, *args): - """is_decl_int32(self) -> bool""" + """ + is_decl_int32(self) -> bool + """ return _idaapi.tinfo_t_is_decl_int32(self, *args) def is_decl_int16(self, *args): - """is_decl_int16(self) -> bool""" + """ + is_decl_int16(self) -> bool + """ return _idaapi.tinfo_t_is_decl_int16(self, *args) def is_decl_char(self, *args): - """is_decl_char(self) -> bool""" + """ + is_decl_char(self) -> bool + """ return _idaapi.tinfo_t_is_decl_char(self, *args) def is_decl_uint(self, *args): - """is_decl_uint(self) -> bool""" + """ + is_decl_uint(self) -> bool + """ return _idaapi.tinfo_t_is_decl_uint(self, *args) def is_decl_uchar(self, *args): - """is_decl_uchar(self) -> bool""" + """ + is_decl_uchar(self) -> bool + """ return _idaapi.tinfo_t_is_decl_uchar(self, *args) def is_decl_uint16(self, *args): - """is_decl_uint16(self) -> bool""" + """ + is_decl_uint16(self) -> bool + """ return _idaapi.tinfo_t_is_decl_uint16(self, *args) def is_decl_uint32(self, *args): - """is_decl_uint32(self) -> bool""" + """ + is_decl_uint32(self) -> bool + """ return _idaapi.tinfo_t_is_decl_uint32(self, *args) def is_decl_uint64(self, *args): - """is_decl_uint64(self) -> bool""" + """ + is_decl_uint64(self) -> bool + """ return _idaapi.tinfo_t_is_decl_uint64(self, *args) def is_decl_uint128(self, *args): - """is_decl_uint128(self) -> bool""" + """ + is_decl_uint128(self) -> bool + """ return _idaapi.tinfo_t_is_decl_uint128(self, *args) def is_decl_ldouble(self, *args): - """is_decl_ldouble(self) -> bool""" + """ + is_decl_ldouble(self) -> bool + """ return _idaapi.tinfo_t_is_decl_ldouble(self, *args) def is_decl_double(self, *args): - """is_decl_double(self) -> bool""" + """ + is_decl_double(self) -> bool + """ return _idaapi.tinfo_t_is_decl_double(self, *args) def is_decl_float(self, *args): - """is_decl_float(self) -> bool""" + """ + is_decl_float(self) -> bool + """ return _idaapi.tinfo_t_is_decl_float(self, *args) def is_decl_floating(self, *args): - """is_decl_floating(self) -> bool""" + """ + is_decl_floating(self) -> bool + """ return _idaapi.tinfo_t_is_decl_floating(self, *args) def is_decl_bool(self, *args): - """is_decl_bool(self) -> bool""" + """ + is_decl_bool(self) -> bool + """ return _idaapi.tinfo_t_is_decl_bool(self, *args) def is_decl_paf(self, *args): - """is_decl_paf(self) -> bool""" + """ + is_decl_paf(self) -> bool + """ return _idaapi.tinfo_t_is_decl_paf(self, *args) def is_well_defined(self, *args): - """is_well_defined(self) -> bool""" + """ + is_well_defined(self) -> bool + """ return _idaapi.tinfo_t_is_well_defined(self, *args) def is_const(self, *args): - """is_const(self) -> bool""" + """ + is_const(self) -> bool + """ return _idaapi.tinfo_t_is_const(self, *args) def is_volatile(self, *args): - """is_volatile(self) -> bool""" + """ + is_volatile(self) -> bool + """ return _idaapi.tinfo_t_is_volatile(self, *args) def is_void(self, *args): - """is_void(self) -> bool""" + """ + is_void(self) -> bool + """ return _idaapi.tinfo_t_is_void(self, *args) def is_partial(self, *args): - """is_partial(self) -> bool""" + """ + is_partial(self) -> bool + """ return _idaapi.tinfo_t_is_partial(self, *args) def is_unknown(self, *args): - """is_unknown(self) -> bool""" + """ + is_unknown(self) -> bool + """ return _idaapi.tinfo_t_is_unknown(self, *args) def is_ptr(self, *args): - """is_ptr(self) -> bool""" + """ + is_ptr(self) -> bool + """ return _idaapi.tinfo_t_is_ptr(self, *args) def is_array(self, *args): - """is_array(self) -> bool""" + """ + is_array(self) -> bool + """ return _idaapi.tinfo_t_is_array(self, *args) def is_func(self, *args): - """is_func(self) -> bool""" + """ + is_func(self) -> bool + """ return _idaapi.tinfo_t_is_func(self, *args) def is_complex(self, *args): - """is_complex(self) -> bool""" + """ + is_complex(self) -> bool + """ return _idaapi.tinfo_t_is_complex(self, *args) def is_struct(self, *args): - """is_struct(self) -> bool""" + """ + is_struct(self) -> bool + """ return _idaapi.tinfo_t_is_struct(self, *args) def is_union(self, *args): - """is_union(self) -> bool""" + """ + is_union(self) -> bool + """ return _idaapi.tinfo_t_is_union(self, *args) def is_udt(self, *args): - """is_udt(self) -> bool""" + """ + is_udt(self) -> bool + """ return _idaapi.tinfo_t_is_udt(self, *args) def is_enum(self, *args): - """is_enum(self) -> bool""" + """ + is_enum(self) -> bool + """ return _idaapi.tinfo_t_is_enum(self, *args) def is_sue(self, *args): - """is_sue(self) -> bool""" + """ + is_sue(self) -> bool + """ return _idaapi.tinfo_t_is_sue(self, *args) def is_bitfield(self, *args): - """is_bitfield(self) -> bool""" + """ + is_bitfield(self) -> bool + """ return _idaapi.tinfo_t_is_bitfield(self, *args) def is_int128(self, *args): - """is_int128(self) -> bool""" + """ + is_int128(self) -> bool + """ return _idaapi.tinfo_t_is_int128(self, *args) def is_int64(self, *args): - """is_int64(self) -> bool""" + """ + is_int64(self) -> bool + """ return _idaapi.tinfo_t_is_int64(self, *args) def is_int32(self, *args): - """is_int32(self) -> bool""" + """ + is_int32(self) -> bool + """ return _idaapi.tinfo_t_is_int32(self, *args) def is_int16(self, *args): - """is_int16(self) -> bool""" + """ + is_int16(self) -> bool + """ return _idaapi.tinfo_t_is_int16(self, *args) def is_char(self, *args): - """is_char(self) -> bool""" + """ + is_char(self) -> bool + """ return _idaapi.tinfo_t_is_char(self, *args) def is_uint(self, *args): - """is_uint(self) -> bool""" + """ + is_uint(self) -> bool + """ return _idaapi.tinfo_t_is_uint(self, *args) def is_uchar(self, *args): - """is_uchar(self) -> bool""" + """ + is_uchar(self) -> bool + """ return _idaapi.tinfo_t_is_uchar(self, *args) def is_uint16(self, *args): - """is_uint16(self) -> bool""" + """ + is_uint16(self) -> bool + """ return _idaapi.tinfo_t_is_uint16(self, *args) def is_uint32(self, *args): - """is_uint32(self) -> bool""" + """ + is_uint32(self) -> bool + """ return _idaapi.tinfo_t_is_uint32(self, *args) def is_uint64(self, *args): - """is_uint64(self) -> bool""" + """ + is_uint64(self) -> bool + """ return _idaapi.tinfo_t_is_uint64(self, *args) def is_uint128(self, *args): - """is_uint128(self) -> bool""" + """ + is_uint128(self) -> bool + """ return _idaapi.tinfo_t_is_uint128(self, *args) def is_ldouble(self, *args): - """is_ldouble(self) -> bool""" + """ + is_ldouble(self) -> bool + """ return _idaapi.tinfo_t_is_ldouble(self, *args) def is_double(self, *args): - """is_double(self) -> bool""" + """ + is_double(self) -> bool + """ return _idaapi.tinfo_t_is_double(self, *args) def is_float(self, *args): - """is_float(self) -> bool""" + """ + is_float(self) -> bool + """ return _idaapi.tinfo_t_is_float(self, *args) def is_bool(self, *args): - """is_bool(self) -> bool""" + """ + is_bool(self) -> bool + """ return _idaapi.tinfo_t_is_bool(self, *args) def is_paf(self, *args): - """is_paf(self) -> bool""" + """ + is_paf(self) -> bool + """ return _idaapi.tinfo_t_is_paf(self, *args) def is_ptr_or_array(self, *args): - """is_ptr_or_array(self) -> bool""" + """ + is_ptr_or_array(self) -> bool + """ return _idaapi.tinfo_t_is_ptr_or_array(self, *args) def is_integral(self, *args): - """is_integral(self) -> bool""" + """ + is_integral(self) -> bool + """ return _idaapi.tinfo_t_is_integral(self, *args) def is_ext_integral(self, *args): - """is_ext_integral(self) -> bool""" + """ + is_ext_integral(self) -> bool + """ return _idaapi.tinfo_t_is_ext_integral(self, *args) def is_floating(self, *args): - """is_floating(self) -> bool""" + """ + is_floating(self) -> bool + """ return _idaapi.tinfo_t_is_floating(self, *args) def is_arithmetic(self, *args): - """is_arithmetic(self) -> bool""" + """ + is_arithmetic(self) -> bool + """ return _idaapi.tinfo_t_is_arithmetic(self, *args) def is_ext_arithmetic(self, *args): - """is_ext_arithmetic(self) -> bool""" + """ + is_ext_arithmetic(self) -> bool + """ return _idaapi.tinfo_t_is_ext_arithmetic(self, *args) def is_scalar(self, *args): - """is_scalar(self) -> bool""" + """ + is_scalar(self) -> bool + """ return _idaapi.tinfo_t_is_scalar(self, *args) def get_ptr_details(self, *args): - """get_ptr_details(self, pi) -> bool""" + """ + get_ptr_details(self, pi) -> bool + """ return _idaapi.tinfo_t_get_ptr_details(self, *args) def get_array_details(self, *args): - """get_array_details(self, ai) -> bool""" + """ + get_array_details(self, ai) -> bool + """ return _idaapi.tinfo_t_get_array_details(self, *args) def get_enum_details(self, *args): - """get_enum_details(self, ei) -> bool""" + """ + get_enum_details(self, ei) -> bool + """ return _idaapi.tinfo_t_get_enum_details(self, *args) def get_bitfield_details(self, *args): - """get_bitfield_details(self, bi) -> bool""" + """ + get_bitfield_details(self, bi) -> bool + """ return _idaapi.tinfo_t_get_bitfield_details(self, *args) def get_udt_details(self, *args): - """get_udt_details(self, udt, gtd=GTD_CALC_LAYOUT) -> bool""" + """ + get_udt_details(self, udt, gtd=GTD_CALC_LAYOUT) -> bool + """ return _idaapi.tinfo_t_get_udt_details(self, *args) def get_func_details(self, *args): - """get_func_details(self, fi, gtd=GTD_CALC_ARGLOCS) -> bool""" + """ + get_func_details(self, fi, gtd=GTD_CALC_ARGLOCS) -> bool + """ return _idaapi.tinfo_t_get_func_details(self, *args) def is_funcptr(self, *args): - """is_funcptr(self) -> bool""" + """ + is_funcptr(self) -> bool + """ return _idaapi.tinfo_t_is_funcptr(self, *args) def get_ptrarr_objsize(self, *args): - """get_ptrarr_objsize(self) -> int""" + """ + get_ptrarr_objsize(self) -> int + """ return _idaapi.tinfo_t_get_ptrarr_objsize(self, *args) def get_ptrarr_object(self, *args): - """get_ptrarr_object(self) -> tinfo_t""" + """ + get_ptrarr_object(self) -> tinfo_t + """ return _idaapi.tinfo_t_get_ptrarr_object(self, *args) def get_pointed_object(self, *args): - """get_pointed_object(self) -> tinfo_t""" + """ + get_pointed_object(self) -> tinfo_t + """ return _idaapi.tinfo_t_get_pointed_object(self, *args) def is_pvoid(self, *args): - """is_pvoid(self) -> bool""" + """ + is_pvoid(self) -> bool + """ return _idaapi.tinfo_t_is_pvoid(self, *args) def get_array_element(self, *args): - """get_array_element(self) -> tinfo_t""" + """ + get_array_element(self) -> tinfo_t + """ return _idaapi.tinfo_t_get_array_element(self, *args) def get_array_nelems(self, *args): - """get_array_nelems(self) -> int""" + """ + get_array_nelems(self) -> int + """ return _idaapi.tinfo_t_get_array_nelems(self, *args) def get_nth_arg(self, *args): - """get_nth_arg(self, n) -> tinfo_t""" + """ + get_nth_arg(self, n) -> tinfo_t + """ return _idaapi.tinfo_t_get_nth_arg(self, *args) def get_rettype(self, *args): - """get_rettype(self) -> tinfo_t""" + """ + get_rettype(self) -> tinfo_t + """ return _idaapi.tinfo_t_get_rettype(self, *args) def get_nargs(self, *args): - """get_nargs(self) -> int""" + """ + get_nargs(self) -> int + """ return _idaapi.tinfo_t_get_nargs(self, *args) def is_user_cc(self, *args): - """is_user_cc(self) -> bool""" + """ + is_user_cc(self) -> bool + """ return _idaapi.tinfo_t_is_user_cc(self, *args) def is_vararg_cc(self, *args): - """is_vararg_cc(self) -> bool""" + """ + is_vararg_cc(self) -> bool + """ return _idaapi.tinfo_t_is_vararg_cc(self, *args) def is_purging_cc(self, *args): - """is_purging_cc(self) -> bool""" + """ + is_purging_cc(self) -> bool + """ return _idaapi.tinfo_t_is_purging_cc(self, *args) def calc_purged_bytes(self, *args): - """calc_purged_bytes(self) -> int""" + """ + calc_purged_bytes(self) -> int + """ return _idaapi.tinfo_t_calc_purged_bytes(self, *args) def is_high_func(self, *args): - """is_high_func(self) -> bool""" + """ + is_high_func(self) -> bool + """ return _idaapi.tinfo_t_is_high_func(self, *args) def find_udt_member(self, *args): - """find_udt_member(self, strmem_flags, udm) -> int""" + """ + find_udt_member(self, strmem_flags, udm) -> int + """ return _idaapi.tinfo_t_find_udt_member(self, *args) def get_udt_nmembers(self, *args): - """get_udt_nmembers(self) -> int""" + """ + get_udt_nmembers(self) -> int + """ return _idaapi.tinfo_t_get_udt_nmembers(self, *args) def is_empty_udt(self, *args): - """is_empty_udt(self) -> bool""" + """ + is_empty_udt(self) -> bool + """ return _idaapi.tinfo_t_is_empty_udt(self, *args) def is_small_udt(self, *args): - """is_small_udt(self) -> bool""" + """ + is_small_udt(self) -> bool + """ return _idaapi.tinfo_t_is_small_udt(self, *args) def is_one_fpval(self, *args): - """is_one_fpval(self) -> bool""" + """ + is_one_fpval(self) -> bool + """ return _idaapi.tinfo_t_is_one_fpval(self, *args) def is_sse_type(self, *args): - """is_sse_type(self) -> bool""" + """ + is_sse_type(self) -> bool + """ return _idaapi.tinfo_t_is_sse_type(self, *args) def get_enum_base_type(self, *args): - """get_enum_base_type(self) -> type_t""" + """ + get_enum_base_type(self) -> type_t + """ return _idaapi.tinfo_t_get_enum_base_type(self, *args) def get_onemember_type(self, *args): - """get_onemember_type(self) -> tinfo_t""" + """ + get_onemember_type(self) -> tinfo_t + """ return _idaapi.tinfo_t_get_onemember_type(self, *args) def calc_score(self, *args): - """calc_score(self) -> uint32""" + """ + calc_score(self) -> uint32 + """ return _idaapi.tinfo_t_calc_score(self, *args) def _print(self, *args): - """_print(self, name=None, prtype_flags=0x0000, indent=0, cmtindent=0, prefix=None, cmt=None) -> bool""" + """ + _print(self, out, name=None, prtype_flags=0x0000, indent=0, cmtindent=0, prefix=None, cmt=None) -> bool + """ return _idaapi.tinfo_t__print(self, *args) def dstr(self, *args): - """dstr(self) -> char const *""" + """ + dstr(self) -> char const * + """ return _idaapi.tinfo_t_dstr(self, *args) def get_attrs(self, *args): - """get_attrs(self, tav, all_attrs=False) -> bool""" + """ + get_attrs(self, tav, all_attrs=False) -> bool + """ return _idaapi.tinfo_t_get_attrs(self, *args) def get_attr(self, *args): - """get_attr(self, key, bv, all_attrs=True) -> bool""" + """ + get_attr(self, key, bv, all_attrs=True) -> bool + """ return _idaapi.tinfo_t_get_attr(self, *args) def set_attrs(self, *args): - """set_attrs(self, tav) -> bool""" + """ + set_attrs(self, tav) -> bool + """ return _idaapi.tinfo_t_set_attrs(self, *args) def set_attr(self, *args): - """set_attr(self, ta, may_overwrite=True) -> bool""" + """ + set_attr(self, ta, may_overwrite=True) -> bool + """ return _idaapi.tinfo_t_set_attr(self, *args) def del_attrs(self, *args): - """del_attrs(self)""" + """ + del_attrs(self) + """ return _idaapi.tinfo_t_del_attrs(self, *args) def del_attr(self, *args): - """del_attr(self, key) -> bool""" + """ + del_attr(self, key) -> bool + """ return _idaapi.tinfo_t_del_attr(self, *args) def create_simple_type(self, *args): - """create_simple_type(self, decl_type) -> bool""" + """ + create_simple_type(self, decl_type) -> bool + """ return _idaapi.tinfo_t_create_simple_type(self, *args) def create_ptr(self, *args): @@ -28447,8 +30893,8 @@ class tinfo_t(object): def create_typedef(self, *args): """ - create_typedef(self, p, decl_type=BTF_TYPEDEF, try_ordinal=True) -> bool - create_typedef(self, til, name, decl_type=BTF_TYPEDEF, try_ordinal=True) + create_typedef(self, p, decl_type=BTF_TYPEDEF) -> bool + create_typedef(self, til, name, decl_type=BTF_TYPEDEF) create_typedef(self, til, ord, decl_type=BTF_TYPEDEF) """ return _idaapi.tinfo_t_create_typedef(self, *args) @@ -28461,124 +30907,166 @@ class tinfo_t(object): return _idaapi.tinfo_t_create_bitfield(self, *args) def create_udt(self, *args): - """create_udt(self, p, decl_type) -> bool""" + """ + create_udt(self, p, decl_type) -> bool + """ return _idaapi.tinfo_t_create_udt(self, *args) def create_enum(self, *args): - """create_enum(self, p, decl_type=BTF_ENUM) -> bool""" + """ + create_enum(self, p, decl_type=BTF_ENUM) -> bool + """ return _idaapi.tinfo_t_create_enum(self, *args) def create_func(self, *args): - """create_func(self, p, decl_type=BT_FUNC) -> bool""" + """ + create_func(self, p, decl_type=BT_FUNC) -> bool + """ return _idaapi.tinfo_t_create_func(self, *args) def set_numbered_type(self, *args): - """set_numbered_type(self, til, ord, ntf_flags=0, name=None) -> tinfo_code_t""" + """ + set_numbered_type(self, til, ord, ntf_flags=0, name=None) -> tinfo_code_t + """ return _idaapi.tinfo_t_set_numbered_type(self, *args) def create_forward_decl(self, *args): - """create_forward_decl(self, til, decl_type, name, ntf_flags=0) -> bool""" + """ + create_forward_decl(self, til, decl_type, name, ntf_flags=0) -> bool + """ return _idaapi.tinfo_t_create_forward_decl(self, *args) def get_stock(*args): - """get_stock(id) -> tinfo_t""" + """ + get_stock(id) -> tinfo_t + """ return _idaapi.tinfo_t_get_stock(*args) get_stock = staticmethod(get_stock) def convert_array_to_ptr(self, *args): - """convert_array_to_ptr(self) -> bool""" + """ + convert_array_to_ptr(self) -> bool + """ return _idaapi.tinfo_t_convert_array_to_ptr(self, *args) def remove_ptr_or_array(self, *args): - """remove_ptr_or_array(self) -> bool""" + """ + remove_ptr_or_array(self) -> bool + """ return _idaapi.tinfo_t_remove_ptr_or_array(self, *args) def change_sign(self, *args): - """change_sign(self, sign) -> bool""" + """ + change_sign(self, sign) -> bool + """ return _idaapi.tinfo_t_change_sign(self, *args) def calc_udt_aligns(self, *args): - """calc_udt_aligns(self, sudt_flags=0x0004) -> bool""" + """ + calc_udt_aligns(self, sudt_flags=0x0004) -> bool + """ return _idaapi.tinfo_t_calc_udt_aligns(self, *args) def read_bitfield_value(self, *args): - """read_bitfield_value(self, v, bitoff) -> uint64""" + """ + read_bitfield_value(self, v, bitoff) -> uint64 + """ return _idaapi.tinfo_t_read_bitfield_value(self, *args) def write_bitfield_value(self, *args): - """write_bitfield_value(self, dst, v, bitoff) -> uint64""" + """ + write_bitfield_value(self, dst, v, bitoff) -> uint64 + """ return _idaapi.tinfo_t_write_bitfield_value(self, *args) def get_modifiers(self, *args): - """get_modifiers(self) -> type_t""" + """ + get_modifiers(self) -> type_t + """ return _idaapi.tinfo_t_get_modifiers(self, *args) def set_modifiers(self, *args): - """set_modifiers(self, mod)""" + """ + set_modifiers(self, mod) + """ return _idaapi.tinfo_t_set_modifiers(self, *args) def set_const(self, *args): - """set_const(self)""" + """ + set_const(self, on=True) + """ return _idaapi.tinfo_t_set_const(self, *args) def set_volatile(self, *args): - """set_volatile(self)""" + """ + set_volatile(self, on=True) + """ return _idaapi.tinfo_t_set_volatile(self, *args) - def clr_const(self, *args): - """clr_const(self)""" - return _idaapi.tinfo_t_clr_const(self, *args) - - def clr_volatile(self, *args): - """clr_volatile(self)""" - return _idaapi.tinfo_t_clr_volatile(self, *args) - - def clr_const_volatile(self, *args): - """clr_const_volatile(self)""" - return _idaapi.tinfo_t_clr_const_volatile(self, *args) - def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.tinfo_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.tinfo_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.tinfo_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.tinfo_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.tinfo_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.tinfo_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.tinfo_t_compare(self, *args) def compare_with(self, *args): - """compare_with(self, r, tcflags=0) -> bool""" + """ + compare_with(self, r, tcflags=0) -> bool + """ return _idaapi.tinfo_t_compare_with(self, *args) def equals_to(self, *args): - """equals_to(self, r) -> bool""" + """ + equals_to(self, r) -> bool + """ return _idaapi.tinfo_t_equals_to(self, *args) def is_castable_to(self, *args): - """is_castable_to(self, target) -> bool""" + """ + is_castable_to(self, target) -> bool + """ return _idaapi.tinfo_t_is_castable_to(self, *args) def is_manually_castable_to(self, *args): - """is_manually_castable_to(self, target) -> bool""" + """ + is_manually_castable_to(self, target) -> bool + """ return _idaapi.tinfo_t_is_manually_castable_to(self, *args) def deserialize(self, *args): @@ -28586,7 +31074,6 @@ class tinfo_t(object): deserialize(self, til, ptype, pfields=None, pfldcmts=None) -> bool deserialize(self, til, ptype, pfields=None, pfldcmts=None) -> bool deserialize(self, til, type, fields, cmts=None) -> bool - deserialize(self, til, _type, _fields, _cmts=None) -> bool """ return _idaapi.tinfo_t_deserialize(self, *args) @@ -28617,7 +31104,9 @@ TYPID_ISREF = cvar.TYPID_ISREF TYPID_SHIFT = cvar.TYPID_SHIFT def remove_pointer(*args): - """remove_pointer(tif) -> tinfo_t""" + """ + remove_pointer(tif) -> tinfo_t + """ return _idaapi.remove_pointer(*args) STRMEM_MASK = _idaapi.STRMEM_MASK STRMEM_OFFSET = _idaapi.STRMEM_OFFSET @@ -28632,7 +31121,9 @@ STRMEM_ANON = _idaapi.STRMEM_ANON STRMEM_CASTABLE_TO = _idaapi.STRMEM_CASTABLE_TO def tinfo_t_get_stock(*args): - """tinfo_t_get_stock(id) -> tinfo_t""" + """ + tinfo_t_get_stock(id) -> tinfo_t + """ return _idaapi.tinfo_t_get_stock(*args) TCMP_EQUAL = _idaapi.TCMP_EQUAL TCMP_IGNMODS = _idaapi.TCMP_IGNMODS @@ -28644,69 +31135,87 @@ TCMP_DECL = _idaapi.TCMP_DECL def guess_func_cc(*args): - """guess_func_cc(fti, npurged, cc_flags) -> cm_t""" + """ + guess_func_cc(fti, npurged, cc_flags) -> cm_t + """ return _idaapi.guess_func_cc(*args) - -def dump_func_type_data(*args): - """dump_func_type_data(fti, praloc_bits) -> bool""" - return _idaapi.dump_func_type_data(*args) class ptr_type_data_t(object): - """Proxy of C++ ptr_type_data_t class""" + """ + Proxy of C++ ptr_type_data_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr obj_type = _swig_property(_idaapi.ptr_type_data_t_obj_type_get, _idaapi.ptr_type_data_t_obj_type_set) closure = _swig_property(_idaapi.ptr_type_data_t_closure_get, _idaapi.ptr_type_data_t_closure_set) based_ptr_size = _swig_property(_idaapi.ptr_type_data_t_based_ptr_size_get, _idaapi.ptr_type_data_t_based_ptr_size_set) taptr_bits = _swig_property(_idaapi.ptr_type_data_t_taptr_bits_get, _idaapi.ptr_type_data_t_taptr_bits_set) - def swap(self, *args): - """swap(self, r)""" - return _idaapi.ptr_type_data_t_swap(self, *args) - - def __eq__(self, *args): - """__eq__(self, r) -> bool""" - return _idaapi.ptr_type_data_t___eq__(self, *args) - - def __ne__(self, *args): - """__ne__(self, r) -> bool""" - return _idaapi.ptr_type_data_t___ne__(self, *args) - - def is_code_ptr(self, *args): - """is_code_ptr(self) -> bool""" - return _idaapi.ptr_type_data_t_is_code_ptr(self, *args) - - def __init__(self, *args): - """__init__(self, c=tinfo_t(), bps=0) -> ptr_type_data_t""" + def __init__(self, *args): + """ + __init__(self, c=tinfo_t(), bps=0) -> ptr_type_data_t + """ this = _idaapi.new_ptr_type_data_t(*args) try: self.this.append(this) except: self.this = this + def swap(self, *args): + """ + swap(self, r) + """ + return _idaapi.ptr_type_data_t_swap(self, *args) + + def __eq__(self, *args): + """ + __eq__(self, r) -> bool + """ + return _idaapi.ptr_type_data_t___eq__(self, *args) + + def __ne__(self, *args): + """ + __ne__(self, r) -> bool + """ + return _idaapi.ptr_type_data_t___ne__(self, *args) + + def is_code_ptr(self, *args): + """ + is_code_ptr(self) -> bool + """ + return _idaapi.ptr_type_data_t_is_code_ptr(self, *args) + __swig_destroy__ = _idaapi.delete_ptr_type_data_t __del__ = lambda self : None; ptr_type_data_t_swigregister = _idaapi.ptr_type_data_t_swigregister ptr_type_data_t_swigregister(ptr_type_data_t) class array_type_data_t(object): - """Proxy of C++ array_type_data_t class""" + """ + Proxy of C++ array_type_data_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr elem_type = _swig_property(_idaapi.array_type_data_t_elem_type_get, _idaapi.array_type_data_t_elem_type_set) base = _swig_property(_idaapi.array_type_data_t_base_get, _idaapi.array_type_data_t_base_set) nelems = _swig_property(_idaapi.array_type_data_t_nelems_get, _idaapi.array_type_data_t_nelems_set) - def swap(self, *args): - """swap(self, r)""" - return _idaapi.array_type_data_t_swap(self, *args) - - def __init__(self, *args): - """__init__(self, b=0, n=0) -> array_type_data_t""" + def __init__(self, *args): + """ + __init__(self, b=0, n=0) -> array_type_data_t + """ this = _idaapi.new_array_type_data_t(*args) try: self.this.append(this) except: self.this = this + def swap(self, *args): + """ + swap(self, r) + """ + return _idaapi.array_type_data_t_swap(self, *args) + __swig_destroy__ = _idaapi.delete_array_type_data_t __del__ = lambda self : None; array_type_data_t_swigregister = _idaapi.array_type_data_t_swigregister array_type_data_t_swigregister(array_type_data_t) class funcarg_t(object): - """Proxy of C++ funcarg_t class""" + """ + Proxy of C++ funcarg_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr argloc = _swig_property(_idaapi.funcarg_t_argloc_get, _idaapi.funcarg_t_argloc_set) @@ -28714,17 +31223,23 @@ class funcarg_t(object): cmt = _swig_property(_idaapi.funcarg_t_cmt_get, _idaapi.funcarg_t_cmt_set) type = _swig_property(_idaapi.funcarg_t_type_get, _idaapi.funcarg_t_type_set) flags = _swig_property(_idaapi.funcarg_t_flags_get, _idaapi.funcarg_t_flags_set) - def __init__(self, *args): - """__init__(self) -> funcarg_t""" + def __init__(self, *args): + """ + __init__(self) -> funcarg_t + """ this = _idaapi.new_funcarg_t(*args) try: self.this.append(this) except: self.this = this def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.funcarg_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.funcarg_t___ne__(self, *args) __swig_destroy__ = _idaapi.delete_funcarg_t @@ -28738,8 +31253,10 @@ FAI_ARRAY = _idaapi.FAI_ARRAY TA_ORG_TYPEDEF = _idaapi.TA_ORG_TYPEDEF TA_ORG_ARRDIM = _idaapi.TA_ORG_ARRDIM -class func_type_data_t(funcargvec_t): - """Proxy of C++ func_type_data_t class""" +class func_type_data_t(object): + """ + Proxy of C++ func_type_data_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr flags = _swig_property(_idaapi.func_type_data_t_flags_get, _idaapi.func_type_data_t_flags_set) @@ -28748,35 +31265,37 @@ class func_type_data_t(funcargvec_t): stkargs = _swig_property(_idaapi.func_type_data_t_stkargs_get, _idaapi.func_type_data_t_stkargs_set) spoiled = _swig_property(_idaapi.func_type_data_t_spoiled_get, _idaapi.func_type_data_t_spoiled_set) cc = _swig_property(_idaapi.func_type_data_t_cc_get, _idaapi.func_type_data_t_cc_set) - def swap(self, *args): - """swap(self, r)""" - return _idaapi.func_type_data_t_swap(self, *args) - - def is_high(self, *args): - """is_high(self) -> bool""" - return _idaapi.func_type_data_t_is_high(self, *args) - - def get_call_method(self, *args): - """get_call_method(self) -> int""" - return _idaapi.func_type_data_t_get_call_method(self, *args) - - def is_vararg_cc(self, *args): - """is_vararg_cc(self) -> bool""" - return _idaapi.func_type_data_t_is_vararg_cc(self, *args) - - def guess_cc(self, *args): - """guess_cc(self, purged, cc_flags) -> cm_t""" - return _idaapi.func_type_data_t_guess_cc(self, *args) - - def dump(self, *args): - """dump(self, praloc_bits=0x02) -> bool""" - return _idaapi.func_type_data_t_dump(self, *args) - - def __init__(self, *args): - """__init__(self) -> func_type_data_t""" + def __init__(self, *args): + """ + __init__(self) -> func_type_data_t + """ this = _idaapi.new_func_type_data_t(*args) try: self.this.append(this) except: self.this = this + def swap(self, *args): + """ + swap(self, r) + """ + return _idaapi.func_type_data_t_swap(self, *args) + + def is_high(self, *args): + """ + is_high(self) -> bool + """ + return _idaapi.func_type_data_t_is_high(self, *args) + + def get_call_method(self, *args): + """ + get_call_method(self) -> int + """ + return _idaapi.func_type_data_t_get_call_method(self, *args) + + def guess_cc(self, *args): + """ + guess_cc(self, purged, cc_flags) -> cm_t + """ + return _idaapi.func_type_data_t_guess_cc(self, *args) + __swig_destroy__ = _idaapi.delete_func_type_data_t __del__ = lambda self : None; func_type_data_t_swigregister = _idaapi.func_type_data_t_swigregister @@ -28800,26 +31319,36 @@ CC_ALLOW_REGHOLES = _idaapi.CC_ALLOW_REGHOLES CC_HAS_ELLIPSIS = _idaapi.CC_HAS_ELLIPSIS class enum_member_t(object): - """Proxy of C++ enum_member_t class""" + """ + Proxy of C++ enum_member_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr name = _swig_property(_idaapi.enum_member_t_name_get, _idaapi.enum_member_t_name_set) cmt = _swig_property(_idaapi.enum_member_t_cmt_get, _idaapi.enum_member_t_cmt_set) value = _swig_property(_idaapi.enum_member_t_value_get, _idaapi.enum_member_t_value_set) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.enum_member_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.enum_member_t___ne__(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.enum_member_t_swap(self, *args) - def __init__(self, *args): - """__init__(self) -> enum_member_t""" + def __init__(self, *args): + """ + __init__(self) -> enum_member_t + """ this = _idaapi.new_enum_member_t(*args) try: self.this.append(this) except: self.this = this @@ -28827,49 +31356,70 @@ class enum_member_t(object): __del__ = lambda self : None; enum_member_t_swigregister = _idaapi.enum_member_t_swigregister enum_member_t_swigregister(enum_member_t) +FTI_CALLSHIFT = cvar.FTI_CALLSHIFT class enum_type_data_t(object): - """Proxy of C++ enum_type_data_t class""" + """ + Proxy of C++ enum_type_data_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr group_sizes = _swig_property(_idaapi.enum_type_data_t_group_sizes_get, _idaapi.enum_type_data_t_group_sizes_set) taenum_bits = _swig_property(_idaapi.enum_type_data_t_taenum_bits_get, _idaapi.enum_type_data_t_taenum_bits_set) bte = _swig_property(_idaapi.enum_type_data_t_bte_get, _idaapi.enum_type_data_t_bte_set) - def __init__(self, *args): - """__init__(self, _bte=BTE_ALWAYS|BTE_HEX) -> enum_type_data_t""" + def __init__(self, *args): + """ + __init__(self, _bte=BTE_ALWAYS|BTE_HEX) -> enum_type_data_t + """ this = _idaapi.new_enum_type_data_t(*args) try: self.this.append(this) except: self.this = this def is_64bit(self, *args): - """is_64bit(self) -> bool""" + """ + is_64bit(self) -> bool + """ return _idaapi.enum_type_data_t_is_64bit(self, *args) def is_hex(self, *args): - """is_hex(self) -> bool""" + """ + is_hex(self) -> bool + """ return _idaapi.enum_type_data_t_is_hex(self, *args) def is_char(self, *args): - """is_char(self) -> bool""" + """ + is_char(self) -> bool + """ return _idaapi.enum_type_data_t_is_char(self, *args) def is_sdec(self, *args): - """is_sdec(self) -> bool""" + """ + is_sdec(self) -> bool + """ return _idaapi.enum_type_data_t_is_sdec(self, *args) def is_udec(self, *args): - """is_udec(self) -> bool""" + """ + is_udec(self) -> bool + """ return _idaapi.enum_type_data_t_is_udec(self, *args) def calc_nbytes(self, *args): - """calc_nbytes(self) -> int""" + """ + calc_nbytes(self) -> int + """ return _idaapi.enum_type_data_t_calc_nbytes(self, *args) def calc_mask(self, *args): - """calc_mask(self) -> uint64""" + """ + calc_mask(self) -> uint64 + """ return _idaapi.enum_type_data_t_calc_mask(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.enum_type_data_t_swap(self, *args) __swig_destroy__ = _idaapi.delete_enum_type_data_t @@ -28878,13 +31428,15 @@ enum_type_data_t_swigregister = _idaapi.enum_type_data_t_swigregister enum_type_data_t_swigregister(enum_type_data_t) class typedef_type_data_t(object): - """Proxy of C++ typedef_type_data_t class""" + """ + Proxy of C++ typedef_type_data_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr til = _swig_property(_idaapi.typedef_type_data_t_til_get, _idaapi.typedef_type_data_t_til_set) is_ordref = _swig_property(_idaapi.typedef_type_data_t_is_ordref_get, _idaapi.typedef_type_data_t_is_ordref_set) resolve = _swig_property(_idaapi.typedef_type_data_t_resolve_get, _idaapi.typedef_type_data_t_resolve_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self, _til, _name, _resolve=False) -> typedef_type_data_t __init__(self, _til, ord, _resolve=False) -> typedef_type_data_t @@ -28893,7 +31445,9 @@ class typedef_type_data_t(object): try: self.this.append(this) except: self.this = this def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.typedef_type_data_t_swap(self, *args) __swig_destroy__ = _idaapi.delete_typedef_type_data_t @@ -28902,7 +31456,9 @@ typedef_type_data_t_swigregister = _idaapi.typedef_type_data_t_swigregister typedef_type_data_t_swigregister(typedef_type_data_t) class udt_member_t(object): - """Proxy of C++ udt_member_t class""" + """ + Proxy of C++ udt_member_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr offset = _swig_property(_idaapi.udt_member_t_offset_get, _idaapi.udt_member_t_offset_set) @@ -28913,77 +31469,113 @@ class udt_member_t(object): effalign = _swig_property(_idaapi.udt_member_t_effalign_get, _idaapi.udt_member_t_effalign_set) tafld_bits = _swig_property(_idaapi.udt_member_t_tafld_bits_get, _idaapi.udt_member_t_tafld_bits_set) fda = _swig_property(_idaapi.udt_member_t_fda_get, _idaapi.udt_member_t_fda_set) - def __init__(self, *args): - """__init__(self) -> udt_member_t""" + def __init__(self, *args): + """ + __init__(self) -> udt_member_t + """ this = _idaapi.new_udt_member_t(*args) try: self.this.append(this) except: self.this = this def is_bitfield(self, *args): - """is_bitfield(self) -> bool""" + """ + is_bitfield(self) -> bool + """ return _idaapi.udt_member_t_is_bitfield(self, *args) def is_zero_bitfield(self, *args): - """is_zero_bitfield(self) -> bool""" + """ + is_zero_bitfield(self) -> bool + """ return _idaapi.udt_member_t_is_zero_bitfield(self, *args) def is_unaligned(self, *args): - """is_unaligned(self) -> bool""" + """ + is_unaligned(self) -> bool + """ return _idaapi.udt_member_t_is_unaligned(self, *args) def is_baseclass(self, *args): - """is_baseclass(self) -> bool""" + """ + is_baseclass(self) -> bool + """ return _idaapi.udt_member_t_is_baseclass(self, *args) def is_virtbase(self, *args): - """is_virtbase(self) -> bool""" + """ + is_virtbase(self) -> bool + """ return _idaapi.udt_member_t_is_virtbase(self, *args) def set_unaligned(self, *args): - """set_unaligned(self)""" + """ + set_unaligned(self) + """ return _idaapi.udt_member_t_set_unaligned(self, *args) def set_baseclass(self, *args): - """set_baseclass(self)""" + """ + set_baseclass(self) + """ return _idaapi.udt_member_t_set_baseclass(self, *args) def set_virtbase(self, *args): - """set_virtbase(self)""" + """ + set_virtbase(self) + """ return _idaapi.udt_member_t_set_virtbase(self, *args) def clr_unaligned(self, *args): - """clr_unaligned(self)""" + """ + clr_unaligned(self) + """ return _idaapi.udt_member_t_clr_unaligned(self, *args) def clr_baseclass(self, *args): - """clr_baseclass(self)""" + """ + clr_baseclass(self) + """ return _idaapi.udt_member_t_clr_baseclass(self, *args) def clr_virtbase(self, *args): - """clr_virtbase(self)""" + """ + clr_virtbase(self) + """ return _idaapi.udt_member_t_clr_virtbase(self, *args) def begin(self, *args): - """begin(self) -> uint64""" + """ + begin(self) -> uint64 + """ return _idaapi.udt_member_t_begin(self, *args) def end(self, *args): - """end(self) -> uint64""" + """ + end(self) -> uint64 + """ return _idaapi.udt_member_t_end(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.udt_member_t___lt__(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.udt_member_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.udt_member_t___ne__(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.udt_member_t_swap(self, *args) __swig_destroy__ = _idaapi.delete_udt_member_t @@ -28991,8 +31583,10 @@ class udt_member_t(object): udt_member_t_swigregister = _idaapi.udt_member_t_swigregister udt_member_t_swigregister(udt_member_t) -class udt_type_data_t(udtmembervec_t): - """Proxy of C++ udt_type_data_t class""" +class udt_type_data_t(object): + """ + Proxy of C++ udt_type_data_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr total_size = _swig_property(_idaapi.udt_type_data_t_total_size_get, _idaapi.udt_type_data_t_total_size_set) @@ -29002,74 +31596,104 @@ class udt_type_data_t(udtmembervec_t): sda = _swig_property(_idaapi.udt_type_data_t_sda_get, _idaapi.udt_type_data_t_sda_set) pack = _swig_property(_idaapi.udt_type_data_t_pack_get, _idaapi.udt_type_data_t_pack_set) is_union = _swig_property(_idaapi.udt_type_data_t_is_union_get, _idaapi.udt_type_data_t_is_union_set) - def swap(self, *args): - """swap(self, r)""" - return _idaapi.udt_type_data_t_swap(self, *args) - - def is_unaligned(self, *args): - """is_unaligned(self) -> bool""" - return _idaapi.udt_type_data_t_is_unaligned(self, *args) - - def is_msstruct(self, *args): - """is_msstruct(self) -> bool""" - return _idaapi.udt_type_data_t_is_msstruct(self, *args) - - def is_cppobj(self, *args): - """is_cppobj(self) -> bool""" - return _idaapi.udt_type_data_t_is_cppobj(self, *args) - - def __init__(self, *args): - """__init__(self) -> udt_type_data_t""" + def __init__(self, *args): + """ + __init__(self) -> udt_type_data_t + """ this = _idaapi.new_udt_type_data_t(*args) try: self.this.append(this) except: self.this = this + def swap(self, *args): + """ + swap(self, r) + """ + return _idaapi.udt_type_data_t_swap(self, *args) + + def is_unaligned(self, *args): + """ + is_unaligned(self) -> bool + """ + return _idaapi.udt_type_data_t_is_unaligned(self, *args) + + def is_msstruct(self, *args): + """ + is_msstruct(self) -> bool + """ + return _idaapi.udt_type_data_t_is_msstruct(self, *args) + + def is_cppobj(self, *args): + """ + is_cppobj(self) -> bool + """ + return _idaapi.udt_type_data_t_is_cppobj(self, *args) + __swig_destroy__ = _idaapi.delete_udt_type_data_t __del__ = lambda self : None; udt_type_data_t_swigregister = _idaapi.udt_type_data_t_swigregister udt_type_data_t_swigregister(udt_type_data_t) class bitfield_type_data_t(object): - """Proxy of C++ bitfield_type_data_t class""" + """ + Proxy of C++ bitfield_type_data_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr nbytes = _swig_property(_idaapi.bitfield_type_data_t_nbytes_get, _idaapi.bitfield_type_data_t_nbytes_set) width = _swig_property(_idaapi.bitfield_type_data_t_width_get, _idaapi.bitfield_type_data_t_width_set) is_unsigned = _swig_property(_idaapi.bitfield_type_data_t_is_unsigned_get, _idaapi.bitfield_type_data_t_is_unsigned_set) - def __init__(self, *args): - """__init__(self, _nbytes=0, _width=0, _is_unsigned=False) -> bitfield_type_data_t""" + def __init__(self, *args): + """ + __init__(self, _nbytes=0, _width=0, _is_unsigned=False) -> bitfield_type_data_t + """ this = _idaapi.new_bitfield_type_data_t(*args) try: self.this.append(this) except: self.this = this def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.bitfield_type_data_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.bitfield_type_data_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.bitfield_type_data_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.bitfield_type_data_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.bitfield_type_data_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.bitfield_type_data_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.bitfield_type_data_t_compare(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.bitfield_type_data_t_swap(self, *args) __swig_destroy__ = _idaapi.delete_bitfield_type_data_t @@ -29078,48 +31702,68 @@ bitfield_type_data_t_swigregister = _idaapi.bitfield_type_data_t_swigregister bitfield_type_data_t_swigregister(bitfield_type_data_t) class type_mods_t(object): - """Proxy of C++ type_mods_t class""" + """ + Proxy of C++ type_mods_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr type = _swig_property(_idaapi.type_mods_t_type_get, _idaapi.type_mods_t_type_set) name = _swig_property(_idaapi.type_mods_t_name_get, _idaapi.type_mods_t_name_set) cmt = _swig_property(_idaapi.type_mods_t_cmt_get, _idaapi.type_mods_t_cmt_set) flags = _swig_property(_idaapi.type_mods_t_flags_get, _idaapi.type_mods_t_flags_set) - def __init__(self, *args): - """__init__(self) -> type_mods_t""" + def __init__(self, *args): + """ + __init__(self) -> type_mods_t + """ this = _idaapi.new_type_mods_t(*args) try: self.this.append(this) except: self.this = this def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.type_mods_t_clear(self, *args) def set_new_type(self, *args): - """set_new_type(self, t)""" + """ + set_new_type(self, t) + """ return _idaapi.type_mods_t_set_new_type(self, *args) def set_new_name(self, *args): - """set_new_name(self, n)""" + """ + set_new_name(self, n) + """ return _idaapi.type_mods_t_set_new_name(self, *args) def set_new_cmt(self, *args): - """set_new_cmt(self, c)""" + """ + set_new_cmt(self, c) + """ return _idaapi.type_mods_t_set_new_cmt(self, *args) def has_type(self, *args): - """has_type(self) -> bool""" + """ + has_type(self) -> bool + """ return _idaapi.type_mods_t_has_type(self, *args) def has_name(self, *args): - """has_name(self) -> bool""" + """ + has_name(self) -> bool + """ return _idaapi.type_mods_t_has_name(self, *args) def has_cmt(self, *args): - """has_cmt(self) -> bool""" + """ + has_cmt(self) -> bool + """ return _idaapi.type_mods_t_has_cmt(self, *args) def has_info(self, *args): - """has_info(self) -> bool""" + """ + has_info(self) -> bool + """ return _idaapi.type_mods_t_has_info(self, *args) __swig_destroy__ = _idaapi.delete_type_mods_t @@ -29131,21 +31775,29 @@ TVIS_NAME = _idaapi.TVIS_NAME TVIS_CMT = _idaapi.TVIS_CMT class tinfo_visitor_t(object): - """Proxy of C++ tinfo_visitor_t class""" + """ + Proxy of C++ tinfo_visitor_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr state = _swig_property(_idaapi.tinfo_visitor_t_state_get, _idaapi.tinfo_visitor_t_state_set) def visit_type(self, *args): - """visit_type(self, out, tif, name, cmt) -> int""" + """ + visit_type(self, out, tif, name, cmt) -> int + """ return _idaapi.tinfo_visitor_t_visit_type(self, *args) def prune_now(self, *args): - """prune_now(self)""" + """ + prune_now(self) + """ return _idaapi.tinfo_visitor_t_prune_now(self, *args) def apply_to(self, *args): - """apply_to(self, tif, out=None, name=None, cmt=None) -> int""" + """ + apply_to(self, tif, out=None, name=None, cmt=None) -> int + """ return _idaapi.tinfo_visitor_t_apply_to(self, *args) __swig_destroy__ = _idaapi.delete_tinfo_visitor_t @@ -29156,18 +31808,24 @@ TVST_PRUNE = _idaapi.TVST_PRUNE TVST_DEF = _idaapi.TVST_DEF class regobj_t(object): - """Proxy of C++ regobj_t class""" + """ + Proxy of C++ regobj_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr regidx = _swig_property(_idaapi.regobj_t_regidx_get, _idaapi.regobj_t_regidx_set) relocate = _swig_property(_idaapi.regobj_t_relocate_get, _idaapi.regobj_t_relocate_set) value = _swig_property(_idaapi.regobj_t_value_get, _idaapi.regobj_t_value_set) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.regobj_t_size(self, *args) - def __init__(self, *args): - """__init__(self) -> regobj_t""" + def __init__(self, *args): + """ + __init__(self) -> regobj_t + """ this = _idaapi.new_regobj_t(*args) try: self.this.append(this) except: self.this = this @@ -29177,11 +31835,15 @@ regobj_t_swigregister = _idaapi.regobj_t_swigregister regobj_t_swigregister(regobj_t) class regobjs_t(object): - """Proxy of C++ regobjs_t class""" + """ + Proxy of C++ regobjs_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> regobjs_t""" + def __init__(self, *args): + """ + __init__(self) -> regobjs_t + """ this = _idaapi.new_regobjs_t(*args) try: self.this.append(this) except: self.this = this @@ -29192,24 +31854,34 @@ regobjs_t_swigregister(regobjs_t) def unpack_idcobj_from_idb(*args): - """unpack_idcobj_from_idb(obj, tif, ea, off0, pio_flags=0) -> error_t""" + """ + unpack_idcobj_from_idb(obj, tif, ea, off0, pio_flags=0) -> error_t + """ return _idaapi.unpack_idcobj_from_idb(*args) PIO_NOATTR_FAIL = _idaapi.PIO_NOATTR_FAIL PIO_IGNORE_PTRS = _idaapi.PIO_IGNORE_PTRS def unpack_idcobj_from_bv(*args): - """unpack_idcobj_from_bv(obj, tif, bytes, pio_flags=0) -> error_t""" + """ + unpack_idcobj_from_bv(obj, tif, bytes, pio_flags=0) -> error_t + """ return _idaapi.unpack_idcobj_from_bv(*args) def pack_idcobj_to_idb(*args): - """pack_idcobj_to_idb(obj, tif, ea, pio_flags=0) -> error_t""" + """ + pack_idcobj_to_idb(obj, tif, ea, pio_flags=0) -> error_t + """ return _idaapi.pack_idcobj_to_idb(*args) def pack_idcobj_to_bv(*args): - """pack_idcobj_to_bv(obj, tif, bytes, objoff, pio_flags=0) -> error_t""" + """ + pack_idcobj_to_bv(obj, tif, bytes, objoff, pio_flags=0) -> error_t + """ return _idaapi.pack_idcobj_to_bv(*args) class get_strmem_t(object): - """Proxy of C++ get_strmem_t class""" + """ + Proxy of C++ get_strmem_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr flags = _swig_property(_idaapi.get_strmem_t_flags_get, _idaapi.get_strmem_t_flags_set) @@ -29220,8 +31892,10 @@ class get_strmem_t(object): ftype = _swig_property(_idaapi.get_strmem_t_ftype_get, _idaapi.get_strmem_t_ftype_set) fnames = _swig_property(_idaapi.get_strmem_t_fnames_get, _idaapi.get_strmem_t_fnames_set) sname = _swig_property(_idaapi.get_strmem_t_sname_get, _idaapi.get_strmem_t_sname_set) - def __init__(self, *args): - """__init__(self) -> get_strmem_t""" + def __init__(self, *args): + """ + __init__(self) -> get_strmem_t + """ this = _idaapi.new_get_strmem_t(*args) try: self.this.append(this) except: self.this = this @@ -29232,76 +31906,40 @@ get_strmem_t_swigregister(get_strmem_t) def get_strmem2(*args): - """get_strmem2(til, type, fields, info) -> bool""" + """ + get_strmem2(til, type, fields, info) -> bool + """ return _idaapi.get_strmem2(*args) def apply_tinfo_to_stkarg(*args): - """apply_tinfo_to_stkarg(x, v, tif, name) -> bool""" + """ + apply_tinfo_to_stkarg(x, v, tif, name) -> bool + """ return _idaapi.apply_tinfo_to_stkarg(*args) def gen_use_arg_tinfos(*args): - """gen_use_arg_tinfos(caller, fti, rargs, set_optype, is_stkarg_load, has_delay_slot)""" + """ + gen_use_arg_tinfos(caller, fti, rargs, set_optype, is_stkarg_load, has_delay_slot) + """ return _idaapi.gen_use_arg_tinfos(*args) UTP_ENUM = _idaapi.UTP_ENUM UTP_STRUCT = _idaapi.UTP_STRUCT -def func_has_stkframe_hole(*args): - """func_has_stkframe_hole(ea, fti) -> bool""" - return _idaapi.func_has_stkframe_hole(*args) -class lowertype_helper_t(object): - """Proxy of C++ lowertype_helper_t class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") - __repr__ = _swig_repr - def func_has_stkframe_hole(self, *args): - """func_has_stkframe_hole(self, candidate, candidate_data) -> bool""" - return _idaapi.lowertype_helper_t_func_has_stkframe_hole(self, *args) - - def get_func_purged_bytes(self, *args): - """get_func_purged_bytes(self, candidate, candidate_data) -> int""" - return _idaapi.lowertype_helper_t_get_func_purged_bytes(self, *args) - - __swig_destroy__ = _idaapi.delete_lowertype_helper_t - __del__ = lambda self : None; -lowertype_helper_t_swigregister = _idaapi.lowertype_helper_t_swigregister -lowertype_helper_t_swigregister(lowertype_helper_t) - -class ida_lowertype_helper_t(lowertype_helper_t): - """Proxy of C++ ida_lowertype_helper_t class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, _tif, _ea, _pb) -> ida_lowertype_helper_t""" - this = _idaapi.new_ida_lowertype_helper_t(*args) - try: self.this.append(this) - except: self.this = this - def func_has_stkframe_hole(self, *args): - """func_has_stkframe_hole(self, candidate, candidate_data) -> bool""" - return _idaapi.ida_lowertype_helper_t_func_has_stkframe_hole(self, *args) - - def get_func_purged_bytes(self, *args): - """get_func_purged_bytes(self, candidate, arg3) -> int""" - return _idaapi.ida_lowertype_helper_t_get_func_purged_bytes(self, *args) - - __swig_destroy__ = _idaapi.delete_ida_lowertype_helper_t - __del__ = lambda self : None; -ida_lowertype_helper_t_swigregister = _idaapi.ida_lowertype_helper_t_swigregister -ida_lowertype_helper_t_swigregister(ida_lowertype_helper_t) - - -def lower_type2(*args): - """lower_type2(til, tif, name=None, helper=None) -> int""" - return _idaapi.lower_type2(*args) - def begin_type_updating(*args): - """begin_type_updating(utp)""" + """ + begin_type_updating(utp) + """ return _idaapi.begin_type_updating(*args) def end_type_updating(*args): - """end_type_updating(utp)""" + """ + end_type_updating(utp) + """ return _idaapi.end_type_updating(*args) class valstr_t(object): - """Proxy of C++ valstr_t class""" + """ + Proxy of C++ valstr_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr oneline = _swig_property(_idaapi.valstr_t_oneline_get, _idaapi.valstr_t_oneline_set) @@ -29309,8 +31947,10 @@ class valstr_t(object): members = _swig_property(_idaapi.valstr_t_members_get, _idaapi.valstr_t_members_set) info = _swig_property(_idaapi.valstr_t_info_get, _idaapi.valstr_t_info_set) props = _swig_property(_idaapi.valstr_t_props_get, _idaapi.valstr_t_props_set) - def __init__(self, *args): - """__init__(self) -> valstr_t""" + def __init__(self, *args): + """ + __init__(self) -> valstr_t + """ this = _idaapi.new_valstr_t(*args) try: self.this.append(this) except: self.this = this @@ -29321,11 +31961,15 @@ valstr_t_swigregister(valstr_t) VALSTR_OPEN = _idaapi.VALSTR_OPEN class valstrs_t(object): - """Proxy of C++ valstrs_t class""" + """ + Proxy of C++ valstrs_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> valstrs_t""" + def __init__(self, *args): + """ + __init__(self) -> valstrs_t + """ this = _idaapi.new_valstrs_t(*args) try: self.this.append(this) except: self.this = this @@ -29335,37 +31979,28 @@ valstrs_t_swigregister = _idaapi.valstrs_t_swigregister valstrs_t_swigregister(valstrs_t) class text_sink_t(object): - """Proxy of C++ text_sink_t class""" + """ + Proxy of C++ text_sink_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr def _print(self, *args): - """_print(self, str) -> int""" + """ + _print(self, str) -> int + """ return _idaapi.text_sink_t__print(self, *args) - def __init__(self, *args): - """__init__(self) -> text_sink_t""" - if self.__class__ == text_sink_t: - _self = None - else: - _self = self - this = _idaapi.new_text_sink_t(_self, *args) - try: self.this.append(this) - except: self.this = this __swig_destroy__ = _idaapi.delete_text_sink_t __del__ = lambda self : None; - def __disown__(self): - self.this.disown() - _idaapi.disown_text_sink_t(self) - return weakref_proxy(self) text_sink_t_swigregister = _idaapi.text_sink_t_swigregister text_sink_t_swigregister(text_sink_t) -PDF_INCL_DEPS = _idaapi.PDF_INCL_DEPS -PDF_DEF_FWD = _idaapi.PDF_DEF_FWD -PDF_DEF_BASE = _idaapi.PDF_DEF_BASE def calc_number_of_children(*args): - """calc_number_of_children(loc, tif, dont_deref_ptr=False) -> int""" + """ + calc_number_of_children(loc, tif, dont_deref_ptr=False) -> int + """ return _idaapi.calc_number_of_children(*args) PCN_RADIX = _idaapi.PCN_RADIX PCN_DEC = _idaapi.PCN_DEC @@ -29377,16 +32012,22 @@ PCN_LZHEX = _idaapi.PCN_LZHEX PCN_NEGSIGN = _idaapi.PCN_NEGSIGN def get_enum_member_expr2(*args): - """get_enum_member_expr2(tif, serial, value) -> bool""" + """ + get_enum_member_expr2(tif, serial, value) -> bool + """ return _idaapi.get_enum_member_expr2(*args) class til_symbol_t(object): - """Proxy of C++ til_symbol_t class""" + """ + Proxy of C++ til_symbol_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr name = _swig_property(_idaapi.til_symbol_t_name_get, _idaapi.til_symbol_t_name_set) til = _swig_property(_idaapi.til_symbol_t_til_get, _idaapi.til_symbol_t_til_set) - def __init__(self, *args): - """__init__(self, n=None, t=None) -> til_symbol_t""" + def __init__(self, *args): + """ + __init__(self, n=None, t=None) -> til_symbol_t + """ this = _idaapi.new_til_symbol_t(*args) try: self.this.append(this) except: self.this = this @@ -29397,22 +32038,32 @@ til_symbol_t_swigregister(til_symbol_t) def choose_named_type2(*args): - """choose_named_type2(root_til, title, ntf_flags, func, sym) -> bool""" + """ + choose_named_type2(root_til, title, ntf_flags, func, sym) -> bool + """ return _idaapi.choose_named_type2(*args) def choose_local_tinfo(*args): - """choose_local_tinfo(ti, title, func, ud) -> uint32""" + """ + choose_local_tinfo(ti, title, func, ud) -> uint32 + """ return _idaapi.choose_local_tinfo(*args) def choose_local_type(*args): - """choose_local_type(ti, title, func, ud) -> uint32""" + """ + choose_local_type(ti, title, func, ud) -> uint32 + """ return _idaapi.choose_local_type(*args) class valstrs_deprecated2_t(object): - """Proxy of C++ valstrs_deprecated2_t class""" + """ + Proxy of C++ valstrs_deprecated2_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> valstrs_deprecated2_t""" + def __init__(self, *args): + """ + __init__(self) -> valstrs_deprecated2_t + """ this = _idaapi.new_valstrs_deprecated2_t(*args) try: self.this.append(this) except: self.this = this @@ -29422,11 +32073,15 @@ valstrs_deprecated2_t_swigregister = _idaapi.valstrs_deprecated2_t_swigregister valstrs_deprecated2_t_swigregister(valstrs_deprecated2_t) class valstrs_deprecated_t(object): - """Proxy of C++ valstrs_deprecated_t class""" + """ + Proxy of C++ valstrs_deprecated_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> valstrs_deprecated_t""" + def __init__(self, *args): + """ + __init__(self) -> valstrs_deprecated_t + """ this = _idaapi.new_valstrs_deprecated_t(*args) try: self.this.append(this) except: self.this = this @@ -29437,26 +32092,36 @@ valstrs_deprecated_t_swigregister(valstrs_deprecated_t) def get_scattered_varloc(*args): - """get_scattered_varloc(idx) -> scattered_vloc_t""" + """ + get_scattered_varloc(idx) -> scattered_vloc_t + """ return _idaapi.get_scattered_varloc(*args) def set_scattered_varloc(*args): - """set_scattered_varloc(ptr) -> int""" + """ + set_scattered_varloc(ptr) -> int + """ return _idaapi.set_scattered_varloc(*args) def copy_varloc(*args): - """copy_varloc(dst, src)""" + """ + copy_varloc(dst, src) + """ return _idaapi.copy_varloc(*args) def cleanup_varloc(*args): - """cleanup_varloc(vloc)""" + """ + cleanup_varloc(vloc) + """ return _idaapi.cleanup_varloc(*args) BAD_VARLOC = _idaapi.BAD_VARLOC class varloc_t(object): - """Proxy of C++ varloc_t class""" + """ + Proxy of C++ varloc_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> varloc_t __init__(self, r) -> varloc_t @@ -29467,59 +32132,87 @@ class varloc_t(object): __swig_destroy__ = _idaapi.delete_varloc_t __del__ = lambda self : None; def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.varloc_t_swap(self, *args) def get_value(self, *args): - """get_value(self) -> int32""" + """ + get_value(self) -> int32 + """ return _idaapi.varloc_t_get_value(self, *args) def type(self, *args): - """type(self) -> uint32""" + """ + type(self) -> uint32 + """ return _idaapi.varloc_t_type(self, *args) def is_reg1(self, *args): - """is_reg1(self) -> bool""" + """ + is_reg1(self) -> bool + """ return _idaapi.varloc_t_is_reg1(self, *args) def is_reg2(self, *args): - """is_reg2(self) -> bool""" + """ + is_reg2(self) -> bool + """ return _idaapi.varloc_t_is_reg2(self, *args) def is_reg(self, *args): - """is_reg(self) -> bool""" + """ + is_reg(self) -> bool + """ return _idaapi.varloc_t_is_reg(self, *args) def is_stkoff(self, *args): - """is_stkoff(self) -> bool""" + """ + is_stkoff(self) -> bool + """ return _idaapi.varloc_t_is_stkoff(self, *args) def is_scattered(self, *args): - """is_scattered(self) -> bool""" + """ + is_scattered(self) -> bool + """ return _idaapi.varloc_t_is_scattered(self, *args) def is_fragmented(self, *args): - """is_fragmented(self) -> bool""" + """ + is_fragmented(self) -> bool + """ return _idaapi.varloc_t_is_fragmented(self, *args) def is_badloc(self, *args): - """is_badloc(self) -> bool""" + """ + is_badloc(self) -> bool + """ return _idaapi.varloc_t_is_badloc(self, *args) def reg1(self, *args): - """reg1(self) -> int""" + """ + reg1(self) -> int + """ return _idaapi.varloc_t_reg1(self, *args) def regoff(self, *args): - """regoff(self) -> int""" + """ + regoff(self) -> int + """ return _idaapi.varloc_t_regoff(self, *args) def reg2(self, *args): - """reg2(self) -> int""" + """ + reg2(self) -> int + """ return _idaapi.varloc_t_reg2(self, *args) def stkoff(self, *args): - """stkoff(self) -> int""" + """ + stkoff(self) -> int + """ return _idaapi.varloc_t_stkoff(self, *args) def scattered(self, *args): @@ -29530,73 +32223,105 @@ class varloc_t(object): return _idaapi.varloc_t_scattered(self, *args) def _set_badloc(self, *args): - """_set_badloc(self)""" + """ + _set_badloc(self) + """ return _idaapi.varloc_t__set_badloc(self, *args) def _set_reg1(self, *args): - """_set_reg1(self, reg, off=0)""" + """ + _set_reg1(self, reg, off=0) + """ return _idaapi.varloc_t__set_reg1(self, *args) def _set_reg2(self, *args): - """_set_reg2(self, _reg1, _reg2)""" + """ + _set_reg2(self, _reg1, _reg2) + """ return _idaapi.varloc_t__set_reg2(self, *args) def _set_stkoff(self, *args): - """_set_stkoff(self, off)""" + """ + _set_stkoff(self, off) + """ return _idaapi.varloc_t__set_stkoff(self, *args) def _consume_scattered(self, *args): - """_consume_scattered(self, p) -> bool""" + """ + _consume_scattered(self, p) -> bool + """ return _idaapi.varloc_t__consume_scattered(self, *args) def set_reg1(self, *args): - """set_reg1(self, reg, off=0)""" + """ + set_reg1(self, reg, off=0) + """ return _idaapi.varloc_t_set_reg1(self, *args) def set_reg2(self, *args): - """set_reg2(self, _reg1, _reg2)""" + """ + set_reg2(self, _reg1, _reg2) + """ return _idaapi.varloc_t_set_reg2(self, *args) def set_stkoff(self, *args): - """set_stkoff(self, off)""" + """ + set_stkoff(self, off) + """ return _idaapi.varloc_t_set_stkoff(self, *args) def consume_scattered(self, *args): - """consume_scattered(self, p)""" + """ + consume_scattered(self, p) + """ return _idaapi.varloc_t_consume_scattered(self, *args) def set_badloc(self, *args): - """set_badloc(self)""" + """ + set_badloc(self) + """ return _idaapi.varloc_t_set_badloc(self, *args) def calc_offset(self, *args): - """calc_offset(self) -> int""" + """ + calc_offset(self) -> int + """ return _idaapi.varloc_t_calc_offset(self, *args) def advance(self, *args): - """advance(self, delta) -> bool""" + """ + advance(self, delta) -> bool + """ return _idaapi.varloc_t_advance(self, *args) varloc_t_swigregister = _idaapi.varloc_t_swigregister varloc_t_swigregister(varloc_t) class varpart_t(varloc_t): - """Proxy of C++ varpart_t class""" + """ + Proxy of C++ varpart_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr off = _swig_property(_idaapi.varpart_t_off_get, _idaapi.varpart_t_off_set) size = _swig_property(_idaapi.varpart_t_size_get, _idaapi.varpart_t_size_set) - def __init__(self, *args): - """__init__(self) -> varpart_t""" + def __init__(self, *args): + """ + __init__(self) -> varpart_t + """ this = _idaapi.new_varpart_t(*args) try: self.this.append(this) except: self.this = this def bad_offset(self, *args): - """bad_offset(self) -> bool""" + """ + bad_offset(self) -> bool + """ return _idaapi.varpart_t_bad_offset(self, *args) def bad_size(self, *args): - """bad_size(self) -> bool""" + """ + bad_size(self) -> bool + """ return _idaapi.varpart_t_bad_size(self, *args) __swig_destroy__ = _idaapi.delete_varpart_t @@ -29605,11 +32330,15 @@ varpart_t_swigregister = _idaapi.varpart_t_swigregister varpart_t_swigregister(varpart_t) class scattered_vloc_t(object): - """Proxy of C++ scattered_vloc_t class""" + """ + Proxy of C++ scattered_vloc_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> scattered_vloc_t""" + def __init__(self, *args): + """ + __init__(self) -> scattered_vloc_t + """ this = _idaapi.new_scattered_vloc_t(*args) try: self.this.append(this) except: self.this = this @@ -29620,97 +32349,143 @@ scattered_vloc_t_swigregister(scattered_vloc_t) def add_til(*args): - """add_til(name) -> int""" + """ + add_til(name) -> int + """ return _idaapi.add_til(*args) def is_type_voiddef(*args): - """is_type_voiddef(t) -> bool""" + """ + is_type_voiddef(t) -> bool + """ return _idaapi.is_type_voiddef(*args) def is_type_void_obsolete(*args): - """is_type_void_obsolete(t) -> bool""" + """ + is_type_void_obsolete(t) -> bool + """ return _idaapi.is_type_void_obsolete(*args) def is_type_unk(*args): - """is_type_unk(t) -> bool""" + """ + is_type_unk(t) -> bool + """ return _idaapi.is_type_unk(*args) def is_type_only_size(*args): - """is_type_only_size(t) -> bool""" + """ + is_type_only_size(t) -> bool + """ return _idaapi.is_type_only_size(*args) def apply_type2(*args): - """apply_type2(ea, rtype, fields, userti) -> bool""" + """ + apply_type2(ea, rtype, fields, userti) -> bool + """ return _idaapi.apply_type2(*args) def parse_types2(*args): - """parse_types2(input, printer, hti_flags) -> int""" + """ + parse_types2(input, printer, hti_flags) -> int + """ return _idaapi.parse_types2(*args) def apply_cdecl(*args): - """apply_cdecl(ea, decl) -> bool""" + """ + apply_cdecl(ea, decl) -> bool + """ return _idaapi.apply_cdecl(*args) def til2idb(*args): - """til2idb(idx, name) -> tid_t""" + """ + til2idb(idx, name) -> tid_t + """ return _idaapi.til2idb(*args) def get_idainfo_by_type(*args): - """get_idainfo_by_type(rtype, fields, psize, pflags, mt, alsize=None) -> bool""" + """ + get_idainfo_by_type(rtype, fields, psize, pflags, mt, alsize=None) -> bool + """ return _idaapi.get_idainfo_by_type(*args) def is_resolved_type_struni(*args): - """is_resolved_type_struni(type) -> bool""" + """ + is_resolved_type_struni(type) -> bool + """ return _idaapi.is_resolved_type_struni(*args) def make_array_type(*args): - """make_array_type(buf, bufsize, type, size) -> bool""" + """ + make_array_type(buf, bufsize, type, size) -> bool + """ return _idaapi.make_array_type(*args) def get_func_nargs(*args): - """get_func_nargs(type) -> int""" + """ + get_func_nargs(type) -> int + """ return _idaapi.get_func_nargs(*args) def get_strmem(*args): - """get_strmem(til, type, fields, offset, delta, name, ftype=None, fnames=None, sname=None) -> bool""" + """ + get_strmem(til, type, fields, offset, delta, name, ftype=None, fnames=None, sname=None) -> bool + """ return _idaapi.get_strmem(*args) def get_strmem_by_name(*args): - """get_strmem_by_name(til, type, fields, name, offset, ftype=None, fnames=None, sname=None) -> bool""" + """ + get_strmem_by_name(til, type, fields, name, offset, ftype=None, fnames=None, sname=None) -> bool + """ return _idaapi.get_strmem_by_name(*args) def calc_argloc_info(*args): - """calc_argloc_info(til, type, arglocs, maxn) -> int""" + """ + calc_argloc_info(til, type, arglocs, maxn) -> int + """ return _idaapi.calc_argloc_info(*args) ARGLOC_REG = _idaapi.ARGLOC_REG ARGLOC_REG2 = _idaapi.ARGLOC_REG2 def is_reg_argloc(*args): - """is_reg_argloc(argloc) -> bool""" + """ + is_reg_argloc(argloc) -> bool + """ return _idaapi.is_reg_argloc(*args) def is_stack_argloc(*args): - """is_stack_argloc(argloc) -> bool""" + """ + is_stack_argloc(argloc) -> bool + """ return _idaapi.is_stack_argloc(*args) def is_reg2_argloc(*args): - """is_reg2_argloc(reg_argloc) -> bool""" + """ + is_reg2_argloc(reg_argloc) -> bool + """ return _idaapi.is_reg2_argloc(*args) def get_argloc_r1(*args): - """get_argloc_r1(reg_argloc) -> int""" + """ + get_argloc_r1(reg_argloc) -> int + """ return _idaapi.get_argloc_r1(*args) def get_argloc_r2(*args): - """get_argloc_r2(reg_argloc) -> int""" + """ + get_argloc_r2(reg_argloc) -> int + """ return _idaapi.get_argloc_r2(*args) def make_old_argloc(*args): - """make_old_argloc(r1, r2) -> argloc_old_t""" + """ + make_old_argloc(r1, r2) -> argloc_old_t + """ return _idaapi.make_old_argloc(*args) def split_old_argloc(*args): - """split_old_argloc(al, r1, r2)""" + """ + split_old_argloc(al, r1, r2) + """ return _idaapi.split_old_argloc(*args) def extract_old_argloc(*args): @@ -29721,20 +32496,28 @@ def extract_old_argloc(*args): return _idaapi.extract_old_argloc(*args) def extract_and_convert_old_argloc(*args): - """extract_and_convert_old_argloc(tp) -> uint32""" + """ + extract_and_convert_old_argloc(tp) -> uint32 + """ return _idaapi.extract_and_convert_old_argloc(*args) NTF_NOIDB = _idaapi.NTF_NOIDB def build_func_type(*args): - """build_func_type(p_type, p_fields, fi) -> bool""" + """ + build_func_type(p_type, p_fields, fi) -> bool + """ return _idaapi.build_func_type(*args) class type_visitor_t(object): - """Proxy of C++ type_visitor_t class""" + """ + Proxy of C++ type_visitor_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr def visit_type(self, *args): - """visit_type(self, type) -> int""" + """ + visit_type(self, type) -> int + """ return _idaapi.type_visitor_t_visit_type(self, *args) __swig_destroy__ = _idaapi.delete_type_visitor_t @@ -29744,15 +32527,19 @@ type_visitor_t_swigregister(type_visitor_t) def for_all_types(*args): - """for_all_types(ptype, tv) -> int""" + """ + for_all_types(ptype, tv) -> int + """ return _idaapi.for_all_types(*args) class type_pair_t(object): - """Proxy of C++ type_pair_t class""" + """ + Proxy of C++ type_pair_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr type1 = _swig_property(_idaapi.type_pair_t_type1_get, _idaapi.type_pair_t_type1_set) type2 = _swig_property(_idaapi.type_pair_t_type2_get, _idaapi.type_pair_t_type2_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> type_pair_t __init__(self, l) -> type_pair_t @@ -29767,11 +32554,15 @@ type_pair_t_swigregister = _idaapi.type_pair_t_swigregister type_pair_t_swigregister(type_pair_t) class type_pair_vec_t(object): - """Proxy of C++ type_pair_vec_t class""" + """ + Proxy of C++ type_pair_vec_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> type_pair_vec_t""" + def __init__(self, *args): + """ + __init__(self) -> type_pair_vec_t + """ this = _idaapi.new_type_pair_vec_t(*args) try: self.this.append(this) except: self.this = this @@ -29782,15 +32573,21 @@ type_pair_vec_t_swigregister(type_pair_vec_t) def replace_subtypes(*args): - """replace_subtypes(type, type_pairs) -> int""" + """ + replace_subtypes(type, type_pairs) -> int + """ return _idaapi.replace_subtypes(*args) class type_mapper_t(object): - """Proxy of C++ type_mapper_t class""" + """ + Proxy of C++ type_mapper_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr def map_type(self, *args): - """map_type(self, out, type) -> bool""" + """ + map_type(self, out, type) -> bool + """ return _idaapi.type_mapper_t_map_type(self, *args) __swig_destroy__ = _idaapi.delete_type_mapper_t @@ -29800,161 +32597,235 @@ type_mapper_t_swigregister(type_mapper_t) def replace_subtypes2(*args): - """replace_subtypes2(ti, type, mapper) -> int""" + """ + replace_subtypes2(ti, type, mapper) -> int + """ return _idaapi.replace_subtypes2(*args) def calc_max_number_of_children(*args): - """calc_max_number_of_children(ea, til, type, fields=None, dont_deref_ptr=False) -> int""" + """ + calc_max_number_of_children(ea, til, type, fields=None, dont_deref_ptr=False) -> int + """ return _idaapi.calc_max_number_of_children(*args) def deref_ptr(*args): - """deref_ptr(ti, type, ptr_ea, closure_obj=None) -> bool""" + """ + deref_ptr(ti, type, ptr_ea, closure_obj=None) -> bool + """ return _idaapi.deref_ptr(*args) def guess_tinfo(*args): - """guess_tinfo(id, type, fields) -> int""" + """ + guess_tinfo(id, type, fields) -> int + """ return _idaapi.guess_tinfo(*args) def guess_func_tinfo(*args): - """guess_func_tinfo(pfn, type, fields) -> int""" + """ + guess_func_tinfo(pfn, type, fields) -> int + """ return _idaapi.guess_func_tinfo(*args) def get_enum_base_type(*args): - """get_enum_base_type(type) -> type_t const *""" + """ + get_enum_base_type(type) -> type_t const * + """ return _idaapi.get_enum_base_type(*args) def set_complex_n(*args): - """set_complex_n(pt, val, is_empty_udt) -> type_t *""" + """ + set_complex_n(pt, val, is_empty_udt) -> type_t * + """ return _idaapi.set_complex_n(*args) def get_complex_n(*args): - """get_complex_n(ptype, is_empty_udt) -> int""" + """ + get_complex_n(ptype, is_empty_udt) -> int + """ return _idaapi.get_complex_n(*args) def append_dt(*args): - """append_dt(type, n) -> bool""" + """ + append_dt(type, n) -> bool + """ return _idaapi.append_dt(*args) def append_de(*args): - """append_de(type, n) -> bool""" + """ + append_de(type, n) -> bool + """ return _idaapi.append_de(*args) def append_da(*args): - """append_da(type, n1, n2) -> bool""" + """ + append_da(type, n1, n2) -> bool + """ return _idaapi.append_da(*args) def append_name(*args): - """append_name(fields, name) -> bool""" + """ + append_name(fields, name) -> bool + """ return _idaapi.append_name(*args) def append_complex_n(*args): - """append_complex_n(type, n, is_empty) -> bool""" + """ + append_complex_n(type, n, is_empty) -> bool + """ return _idaapi.append_complex_n(*args) def is_castable2(*args): - """is_castable2(til, frm, to) -> bool""" + """ + is_castable2(til, frm, to) -> bool + """ return _idaapi.is_castable2(*args) def build_array_type(*args): - """build_array_type(outtype, type, size) -> bool""" + """ + build_array_type(outtype, type, size) -> bool + """ return _idaapi.build_array_type(*args) def get_ptr_object_size(*args): - """get_ptr_object_size(til, type) -> ssize_t""" + """ + get_ptr_object_size(til, type) -> ssize_t + """ return _idaapi.get_ptr_object_size(*args) def get_name_of_named_type(*args): - """get_name_of_named_type(ptr) -> bool""" + """ + get_name_of_named_type(ptr) -> bool + """ return _idaapi.get_name_of_named_type(*args) def is_type_scalar2(*args): - """is_type_scalar2(til, type) -> bool""" + """ + is_type_scalar2(til, type) -> bool + """ return _idaapi.is_type_scalar2(*args) def get_type_sign(*args): - """get_type_sign(til, type) -> type_sign_t""" + """ + get_type_sign(til, type) -> type_sign_t + """ return _idaapi.get_type_sign(*args) def get_idainfo_by_type2(*args): - """get_idainfo_by_type2(til, ptype, fields, psize, pflags, mt, alsize=None) -> bool""" + """ + get_idainfo_by_type2(til, ptype, fields, psize, pflags, mt, alsize=None) -> bool + """ return _idaapi.get_idainfo_by_type2(*args) def apply_tinfo(*args): - """apply_tinfo(til, ea, type, fields, flags) -> bool""" + """ + apply_tinfo(til, ea, type, fields, flags) -> bool + """ return _idaapi.apply_tinfo(*args) def parse_decl(*args): - """parse_decl(til, decl, name, type, fields, flags) -> bool""" + """ + parse_decl(til, decl, name, type, fields, flags) -> bool + """ return _idaapi.parse_decl(*args) def remove_type_pointer(*args): - """remove_type_pointer(til, ptype, pname) -> bool""" + """ + remove_type_pointer(til, ptype, pname) -> bool + """ return _idaapi.remove_type_pointer(*args) def apply_once_type_and_name(*args): - """apply_once_type_and_name(ea, type, name) -> bool""" + """ + apply_once_type_and_name(ea, type, name) -> bool + """ return _idaapi.apply_once_type_and_name(*args) def get_func_rettype(*args): - """get_func_rettype(til, type, fields, rettype, retfields=None, p_retloc=None, p_cc=None) -> int""" + """ + get_func_rettype(til, type, fields, rettype, retfields=None, p_retloc=None, p_cc=None) -> int + """ return _idaapi.get_func_rettype(*args) def calc_func_nargs(*args): - """calc_func_nargs(til, type) -> int""" + """ + calc_func_nargs(til, type) -> int + """ return _idaapi.calc_func_nargs(*args) def get_func_cc(*args): - """get_func_cc(til, p_type, p_fields=None) -> cm_t""" + """ + get_func_cc(til, p_type, p_fields=None) -> cm_t + """ return _idaapi.get_func_cc(*args) def skip_spoiled_info(*args): - """skip_spoiled_info(ptr) -> type_t const *""" + """ + skip_spoiled_info(ptr) -> type_t const * + """ return _idaapi.skip_spoiled_info(*args) def set_spoils(*args): - """set_spoils(pt, reg, size) -> type_t *""" + """ + set_spoils(pt, reg, size) -> type_t * + """ return _idaapi.set_spoils(*args) def get_spoil_cnt(*args): - """get_spoil_cnt(t) -> unsigned int""" + """ + get_spoil_cnt(t) -> unsigned int + """ return _idaapi.get_spoil_cnt(*args) def is_type_resolvable(*args): - """is_type_resolvable(p, namebuf=None) -> bool""" + """ + is_type_resolvable(p, namebuf=None) -> bool + """ return _idaapi.is_type_resolvable(*args) def resolve_typedef2(*args): - """resolve_typedef2(ti, p, fields=None, namebuf=None) -> type_t const *""" + """ + resolve_typedef2(ti, p, fields=None, namebuf=None) -> type_t const * + """ return _idaapi.resolve_typedef2(*args) def get_funcarg_size(*args): - """get_funcarg_size(til, pptr, lp=None) -> size_t""" + """ + get_funcarg_size(til, pptr, lp=None) -> size_t + """ return _idaapi.get_funcarg_size(*args) def check_skip_type(*args): - """check_skip_type(ti, ptr) -> bool""" + """ + check_skip_type(ti, ptr) -> bool + """ return _idaapi.check_skip_type(*args) def is_valid_full_type(*args): - """is_valid_full_type(ti, ptr) -> bool""" + """ + is_valid_full_type(ti, ptr) -> bool + """ return _idaapi.is_valid_full_type(*args) def print_type_to_qstring(*args): """ - print_type_to_qstring(prefix, indent, cmtindent, flags, ti, pt, name=None, cmt=None, field_names=None, + print_type_to_qstring(prefix, indent, cmtindent, flags, ti, pt, name=None, cmt=None, field_names=None, field_cmts=None) -> ssize_t """ return _idaapi.print_type_to_qstring(*args) class funcarg_info_t(object): - """Proxy of C++ funcarg_info_t class""" + """ + Proxy of C++ funcarg_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr argloc = _swig_property(_idaapi.funcarg_info_t_argloc_get, _idaapi.funcarg_info_t_argloc_set) name = _swig_property(_idaapi.funcarg_info_t_name_get, _idaapi.funcarg_info_t_name_set) type = _swig_property(_idaapi.funcarg_info_t_type_get, _idaapi.funcarg_info_t_type_set) fields = _swig_property(_idaapi.funcarg_info_t_fields_get, _idaapi.funcarg_info_t_fields_set) - def __init__(self, *args): - """__init__(self) -> funcarg_info_t""" + def __init__(self, *args): + """ + __init__(self) -> funcarg_info_t + """ this = _idaapi.new_funcarg_info_t(*args) try: self.this.append(this) except: self.this = this @@ -29964,7 +32835,9 @@ funcarg_info_t_swigregister = _idaapi.funcarg_info_t_swigregister funcarg_info_t_swigregister(funcarg_info_t) class func_type_info_t(object): - """Proxy of C++ func_type_info_t class""" + """ + Proxy of C++ func_type_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr flags = _swig_property(_idaapi.func_type_info_t_flags_get, _idaapi.func_type_info_t_flags_set) @@ -29975,8 +32848,10 @@ class func_type_info_t(object): spoiled = _swig_property(_idaapi.func_type_info_t_spoiled_get, _idaapi.func_type_info_t_spoiled_set) cc = _swig_property(_idaapi.func_type_info_t_cc_get, _idaapi.func_type_info_t_cc_set) basetype = _swig_property(_idaapi.func_type_info_t_basetype_get, _idaapi.func_type_info_t_basetype_set) - def __init__(self, *args): - """__init__(self) -> func_type_info_t""" + def __init__(self, *args): + """ + __init__(self) -> func_type_info_t + """ this = _idaapi.new_func_type_info_t(*args) try: self.this.append(this) except: self.this = this @@ -29987,63 +32862,91 @@ func_type_info_t_swigregister(func_type_info_t) def build_func_type2(*args): - """build_func_type2(ti, p_type, p_fields, fi) -> bool""" + """ + build_func_type2(ti, p_type, p_fields, fi) -> bool + """ return _idaapi.build_func_type2(*args) def build_funcarg_info(*args): - """build_funcarg_info(til, type, fields, info, bfi_flags) -> int""" + """ + build_funcarg_info(til, type, fields, info, bfi_flags) -> int + """ return _idaapi.build_funcarg_info(*args) BFI_NOCONST = _idaapi.BFI_NOCONST BFI_NOLOCS = _idaapi.BFI_NOLOCS def resolve_complex_type2(*args): - """resolve_complex_type2(til, ptype, fields, type_name, bt, N) -> bool""" + """ + resolve_complex_type2(til, ptype, fields, type_name, bt, N) -> bool + """ return _idaapi.resolve_complex_type2(*args) def calc_varloc_info(*args): - """calc_varloc_info(til, type, varlocs) -> int""" + """ + calc_varloc_info(til, type, varlocs) -> int + """ return _idaapi.calc_varloc_info(*args) def append_varloc(*args): - """append_varloc(out, vloc) -> bool""" + """ + append_varloc(out, vloc) -> bool + """ return _idaapi.append_varloc(*args) def extract_varloc(*args): - """extract_varloc(ptype, vloc, is_retval) -> bool""" + """ + extract_varloc(ptype, vloc, is_retval) -> bool + """ return _idaapi.extract_varloc(*args) def skip_varloc(*args): - """skip_varloc(ptype, is_retval=False) -> bool""" + """ + skip_varloc(ptype, is_retval=False) -> bool + """ return _idaapi.skip_varloc(*args) def verify_varloc(*args): - """verify_varloc(vloc, size, gaps) -> int""" + """ + verify_varloc(vloc, size, gaps) -> int + """ return _idaapi.verify_varloc(*args) def optimize_varloc(*args): - """optimize_varloc(vloc, size, gaps) -> bool""" + """ + optimize_varloc(vloc, size, gaps) -> bool + """ return _idaapi.optimize_varloc(*args) def print_varloc(*args): - """print_varloc(vloc, size=0, vflags=0) -> size_t""" + """ + print_varloc(vloc, size=0, vflags=0) -> size_t + """ return _idaapi.print_varloc(*args) PRVLOC_VERIFY = _idaapi.PRVLOC_VERIFY PRVLOC_STKOFF = _idaapi.PRVLOC_STKOFF def convert_varloc_to_argloc(*args): - """convert_varloc_to_argloc(dst, src)""" + """ + convert_varloc_to_argloc(dst, src) + """ return _idaapi.convert_varloc_to_argloc(*args) def convert_argloc_to_varloc(*args): - """convert_argloc_to_varloc(dst, src) -> bool""" + """ + convert_argloc_to_varloc(dst, src) -> bool + """ return _idaapi.convert_argloc_to_varloc(*args) class vloc_visitor_t(object): - """Proxy of C++ vloc_visitor_t class""" + """ + Proxy of C++ vloc_visitor_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr def visit_location(self, *args): - """visit_location(self, v, off, size) -> int""" + """ + visit_location(self, v, off, size) -> int + """ return _idaapi.vloc_visitor_t_visit_location(self, *args) __swig_destroy__ = _idaapi.delete_vloc_visitor_t @@ -30053,15 +32956,21 @@ vloc_visitor_t_swigregister(vloc_visitor_t) def for_all_varlocs(*args): - """for_all_varlocs(vv, vloc, size, off=0) -> int""" + """ + for_all_varlocs(vv, vloc, size, off=0) -> int + """ return _idaapi.for_all_varlocs(*args) class const_vloc_visitor_t(object): - """Proxy of C++ const_vloc_visitor_t class""" + """ + Proxy of C++ const_vloc_visitor_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr def visit_location(self, *args): - """visit_location(self, v, off, size) -> int""" + """ + visit_location(self, v, off, size) -> int + """ return _idaapi.const_vloc_visitor_t_visit_location(self, *args) __swig_destroy__ = _idaapi.delete_const_vloc_visitor_t @@ -30071,105 +32980,175 @@ const_vloc_visitor_t_swigregister(const_vloc_visitor_t) def for_all_const_varlocs(*args): - """for_all_const_varlocs(vv, vloc, size, off=0) -> int""" + """ + for_all_const_varlocs(vv, vloc, size, off=0) -> int + """ return _idaapi.for_all_const_varlocs(*args) def calc_max_children_qty(*args): - """calc_max_children_qty(ea, tif, dont_deref_ptr=False) -> int""" + """ + calc_max_children_qty(ea, tif, dont_deref_ptr=False) -> int + """ return _idaapi.calc_max_children_qty(*args) -def guess_func_tinfo2(*args): - """guess_func_tinfo2(pfn, tif) -> int""" - return _idaapi.guess_func_tinfo2(*args) - -def lower_type(*args): - """lower_type(til, tif, name=None) -> int""" - return _idaapi.lower_type(*args) - -def print_type2(*args): - """print_type2(ea, prtype_flags) -> bool""" - return _idaapi.print_type2(*args) - def idc_parse_decl(*args): - """idc_parse_decl(ti, decl, flags) -> PyObject *""" + """ + idc_parse_decl(ti, decl, flags) -> PyObject * + """ return _idaapi.idc_parse_decl(*args) def calc_type_size(*args): - """calc_type_size(ti, tp) -> PyObject *""" + """ + calc_type_size(ti, tp) -> PyObject * + + + Returns the size of a type + @param ti: Type info. 'idaapi.cvar.idati' can be passed. + @param tp: type string + @return: + - None on failure + - The size of the type + """ return _idaapi.calc_type_size(*args) def apply_type(*args): - """apply_type(ti, py_type, py_fields, ea, flags) -> bool""" + """ + apply_type(ti, py_type, py_fields, ea, flags) -> bool + + + Apply the specified type to the address + @param ti: Type info. 'idaapi.cvar.idati' can be passed. + @param py_type: type string + @param py_fields: type fields + @param ea: the address of the object + @param flags: combination of TINFO_... constants or 0 + @return: Boolean + """ return _idaapi.apply_type(*args) def print_type(*args): - """print_type(ea, one_line) -> PyObject *""" + """ + print_type(ea, one_line) -> PyObject * + + + Returns the type of an item + @return: + - None on failure + - The type string with a semicolon. Can be used directly with idc.SetType() + """ return _idaapi.print_type(*args) def unpack_object_from_idb(*args): - """unpack_object_from_idb(ti, py_type, py_fields, ea, pio_flags=0) -> PyObject *""" + """ + unpack_object_from_idb(ti, py_type, py_fields, ea, pio_flags=0) -> PyObject * + """ return _idaapi.unpack_object_from_idb(*args) def unpack_object_from_bv(*args): - """unpack_object_from_bv(ti, py_type, py_fields, py_bytes, pio_flags=0) -> PyObject *""" + """ + unpack_object_from_bv(ti, py_type, py_fields, py_bytes, pio_flags=0) -> PyObject * + + + Unpacks a buffer into an object. + Returns the error_t returned by idaapi.pack_object_to_idb + @param ti: Type info. 'idaapi.cvar.idati' can be passed. + @param tp: type string + @param fields: type fields + @param bytes: the bytes to unpack + @param pio_flags: flags used while unpacking + @return: + - tuple(0, err) on failure + - tuple(1, obj) on success + """ return _idaapi.unpack_object_from_bv(*args) def pack_object_to_idb(*args): - """pack_object_to_idb(py_obj, ti, py_type, py_fields, ea, pio_flags=0) -> PyObject *""" + """ + pack_object_to_idb(py_obj, ti, py_type, py_fields, ea, pio_flags=0) -> PyObject * + + + Write a typed object to the database. + Raises an exception if wrong parameters were passed or conversion fails + Returns the error_t returned by idaapi.pack_object_to_idb + @param ti: Type info. 'idaapi.cvar.idati' can be passed. + @param tp: type string + @param fields: type fields + @param ea: ea to be used while packing + @param pio_flags: flags used while unpacking + """ return _idaapi.pack_object_to_idb(*args) def pack_object_to_bv(*args): - """pack_object_to_bv(py_obj, ti, py_type, py_fields, base_ea, pio_flags=0) -> PyObject *""" + """ + pack_object_to_bv(py_obj, ti, py_type, py_fields, base_ea, pio_flags=0) -> PyObject * + + + Packs a typed object to a string + @param ti: Type info. 'idaapi.cvar.idati' can be passed. + @param tp: type string + @param fields: type fields + @param base_ea: base ea used to relocate the pointers in the packed object + @param pio_flags: flags used while unpacking + @return: + tuple(0, err_code) on failure + tuple(1, packed_buf) on success + """ return _idaapi.pack_object_to_bv(*args) def idc_parse_types(*args): - """idc_parse_types(input, flags) -> int""" + """ + idc_parse_types(input, flags) -> int + """ return _idaapi.idc_parse_types(*args) def idc_get_type_raw(*args): - """idc_get_type_raw(ea) -> PyObject *""" + """ + idc_get_type_raw(ea) -> PyObject * + """ return _idaapi.idc_get_type_raw(*args) def idc_get_local_type_raw(*args): - """idc_get_local_type_raw(ordinal) -> PyObject *""" + """ + idc_get_local_type_raw(ordinal) -> PyObject * + """ return _idaapi.idc_get_local_type_raw(*args) def idc_guess_type(*args): - """idc_guess_type(ea) -> char *""" + """ + idc_guess_type(ea) -> char * + """ return _idaapi.idc_guess_type(*args) def idc_get_type(*args): - """idc_get_type(ea) -> char *""" + """ + idc_get_type(ea) -> char * + """ return _idaapi.idc_get_type(*args) def idc_set_local_type(*args): - """idc_set_local_type(ordinal, dcl, flags) -> int""" + """ + idc_set_local_type(ordinal, dcl, flags) -> int + """ return _idaapi.idc_set_local_type(*args) def idc_get_local_type(*args): - """idc_get_local_type(ordinal, flags, buf, maxsize) -> int""" + """ + idc_get_local_type(ordinal, flags, buf, maxsize) -> int + """ return _idaapi.idc_get_local_type(*args) def idc_print_type(*args): - """idc_print_type(py_type, py_fields, name, flags) -> PyObject *""" + """ + idc_print_type(py_type, py_fields, name, flags) -> PyObject * + """ return _idaapi.idc_print_type(*args) def idc_get_local_type_name(*args): - """idc_get_local_type_name(ordinal) -> char""" + """ + idc_get_local_type_name(ordinal) -> char + """ return _idaapi.idc_get_local_type_name(*args) -def get_named_type(*args): - """get_named_type(til, name, ntf_flags) -> PyObject *""" - return _idaapi.get_named_type(*args) - -def get_named_type64(*args): - """get_named_type64(til, name, ntf_flags) -> PyObject *""" - return _idaapi.get_named_type64(*args) - -def print_decls(*args): - """print_decls(printer, til, py_ordinals, flags) -> int""" - return _idaapi.print_decls(*args) - def load_til(*args): """ load_til(tildir, name, errbuf, bufsize) -> til_t @@ -30201,19 +33180,27 @@ def get_type_size0(ti, tp): class user_numforms_t(object): - """Proxy of C++ std::map<(operand_locator_t,number_format_t)> class""" + """ + Proxy of C++ std::map<(operand_locator_t,number_format_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def at(self, *args): - """at(self, _Keyval) -> number_format_t""" + """ + at(self, _Keyval) -> number_format_t + """ return _idaapi.user_numforms_t_at(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.user_numforms_t_size(self, *args) - def __init__(self, *args): - """__init__(self) -> user_numforms_t""" + def __init__(self, *args): + """ + __init__(self) -> user_numforms_t + """ this = _idaapi.new_user_numforms_t(*args) try: self.this.append(this) except: self.this = this @@ -30223,19 +33210,27 @@ user_numforms_t_swigregister = _idaapi.user_numforms_t_swigregister user_numforms_t_swigregister(user_numforms_t) class lvar_mapping_t(object): - """Proxy of C++ std::map<(lvar_locator_t,lvar_locator_t)> class""" + """ + Proxy of C++ std::map<(lvar_locator_t,lvar_locator_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def at(self, *args): - """at(self, _Keyval) -> lvar_locator_t""" + """ + at(self, _Keyval) -> lvar_locator_t + """ return _idaapi.lvar_mapping_t_at(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.lvar_mapping_t_size(self, *args) - def __init__(self, *args): - """__init__(self) -> lvar_mapping_t""" + def __init__(self, *args): + """ + __init__(self) -> lvar_mapping_t + """ this = _idaapi.new_lvar_mapping_t(*args) try: self.this.append(this) except: self.this = this @@ -30245,10 +33240,12 @@ lvar_mapping_t_swigregister = _idaapi.lvar_mapping_t_swigregister lvar_mapping_t_swigregister(lvar_mapping_t) class hexwarns_t(object): - """Proxy of C++ qvector<(hexwarn_t)> class""" + """ + Proxy of C++ qvector<(hexwarn_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> hexwarns_t __init__(self, x) -> hexwarns_t @@ -30266,19 +33263,27 @@ class hexwarns_t(object): return _idaapi.hexwarns_t_push_back(self, *args) def pop_back(self, *args): - """pop_back(self)""" + """ + pop_back(self) + """ return _idaapi.hexwarns_t_pop_back(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.hexwarns_t_size(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.hexwarns_t_empty(self, *args) def at(self, *args): - """at(self, _idx) -> hexwarn_t""" + """ + at(self, _idx) -> hexwarn_t + """ return _idaapi.hexwarns_t_at(self, *args) def front(self, *args): @@ -30296,11 +33301,15 @@ class hexwarns_t(object): return _idaapi.hexwarns_t_back(self, *args) def qclear(self, *args): - """qclear(self)""" + """ + qclear(self) + """ return _idaapi.hexwarns_t_qclear(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.hexwarns_t_clear(self, *args) def resize(self, *args): @@ -30311,39 +33320,57 @@ class hexwarns_t(object): return _idaapi.hexwarns_t_resize(self, *args) def grow(self, *args): - """grow(self, x=hexwarn_t())""" + """ + grow(self, x=hexwarn_t()) + """ return _idaapi.hexwarns_t_grow(self, *args) def capacity(self, *args): - """capacity(self) -> size_t""" + """ + capacity(self) -> size_t + """ return _idaapi.hexwarns_t_capacity(self, *args) def reserve(self, *args): - """reserve(self, cnt)""" + """ + reserve(self, cnt) + """ return _idaapi.hexwarns_t_reserve(self, *args) def truncate(self, *args): - """truncate(self)""" + """ + truncate(self) + """ return _idaapi.hexwarns_t_truncate(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.hexwarns_t_swap(self, *args) def extract(self, *args): - """extract(self) -> hexwarn_t""" + """ + extract(self) -> hexwarn_t + """ return _idaapi.hexwarns_t_extract(self, *args) def inject(self, *args): - """inject(self, s, len)""" + """ + inject(self, s, len) + """ return _idaapi.hexwarns_t_inject(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.hexwarns_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.hexwarns_t___ne__(self, *args) def begin(self, *args): @@ -30361,7 +33388,9 @@ class hexwarns_t(object): return _idaapi.hexwarns_t_end(self, *args) def insert(self, *args): - """insert(self, it, x) -> hexwarn_t""" + """ + insert(self, it, x) -> hexwarn_t + """ return _idaapi.hexwarns_t_insert(self, *args) def erase(self, *args): @@ -30379,27 +33408,39 @@ class hexwarns_t(object): return _idaapi.hexwarns_t_find(self, *args) def has(self, *args): - """has(self, x) -> bool""" + """ + has(self, x) -> bool + """ return _idaapi.hexwarns_t_has(self, *args) def add_unique(self, *args): - """add_unique(self, x) -> bool""" + """ + add_unique(self, x) -> bool + """ return _idaapi.hexwarns_t_add_unique(self, *args) def _del(self, *args): - """_del(self, x) -> bool""" + """ + _del(self, x) -> bool + """ return _idaapi.hexwarns_t__del(self, *args) def __len__(self, *args): - """__len__(self) -> size_t""" + """ + __len__(self) -> size_t + """ return _idaapi.hexwarns_t___len__(self, *args) def __getitem__(self, *args): - """__getitem__(self, i) -> hexwarn_t""" + """ + __getitem__(self, i) -> hexwarn_t + """ return _idaapi.hexwarns_t___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, i, v)""" + """ + __setitem__(self, i, v) + """ return _idaapi.hexwarns_t___setitem__(self, *args) __iter__ = _bounded_getitem_iterator @@ -30408,10 +33449,12 @@ hexwarns_t_swigregister = _idaapi.hexwarns_t_swigregister hexwarns_t_swigregister(hexwarns_t) class ctree_items_t(object): - """Proxy of C++ qvector<(p.citem_t)> class""" + """ + Proxy of C++ qvector<(p.citem_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> ctree_items_t __init__(self, x) -> ctree_items_t @@ -30429,15 +33472,21 @@ class ctree_items_t(object): return _idaapi.ctree_items_t_push_back(self, *args) def pop_back(self, *args): - """pop_back(self)""" + """ + pop_back(self) + """ return _idaapi.ctree_items_t_pop_back(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.ctree_items_t_size(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.ctree_items_t_empty(self, *args) def front(self, *args): @@ -30455,11 +33504,15 @@ class ctree_items_t(object): return _idaapi.ctree_items_t_back(self, *args) def qclear(self, *args): - """qclear(self)""" + """ + qclear(self) + """ return _idaapi.ctree_items_t_qclear(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.ctree_items_t_clear(self, *args) def resize(self, *args): @@ -30470,35 +33523,51 @@ class ctree_items_t(object): return _idaapi.ctree_items_t_resize(self, *args) def capacity(self, *args): - """capacity(self) -> size_t""" + """ + capacity(self) -> size_t + """ return _idaapi.ctree_items_t_capacity(self, *args) def reserve(self, *args): - """reserve(self, cnt)""" + """ + reserve(self, cnt) + """ return _idaapi.ctree_items_t_reserve(self, *args) def truncate(self, *args): - """truncate(self)""" + """ + truncate(self) + """ return _idaapi.ctree_items_t_truncate(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.ctree_items_t_swap(self, *args) def extract(self, *args): - """extract(self) -> citem_t **""" + """ + extract(self) -> citem_t ** + """ return _idaapi.ctree_items_t_extract(self, *args) def inject(self, *args): - """inject(self, s, len)""" + """ + inject(self, s, len) + """ return _idaapi.ctree_items_t_inject(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.ctree_items_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.ctree_items_t___ne__(self, *args) def begin(self, *args): @@ -30516,7 +33585,9 @@ class ctree_items_t(object): return _idaapi.ctree_items_t_end(self, *args) def insert(self, *args): - """insert(self, it, x) -> qvector< citem_t * >::iterator""" + """ + insert(self, it, x) -> qvector< citem_t * >::iterator + """ return _idaapi.ctree_items_t_insert(self, *args) def erase(self, *args): @@ -30534,52 +33605,74 @@ class ctree_items_t(object): return _idaapi.ctree_items_t_find(self, *args) def has(self, *args): - """has(self, x) -> bool""" + """ + has(self, x) -> bool + """ return _idaapi.ctree_items_t_has(self, *args) def add_unique(self, *args): - """add_unique(self, x) -> bool""" + """ + add_unique(self, x) -> bool + """ return _idaapi.ctree_items_t_add_unique(self, *args) def _del(self, *args): - """_del(self, x) -> bool""" + """ + _del(self, x) -> bool + """ return _idaapi.ctree_items_t__del(self, *args) def __len__(self, *args): - """__len__(self) -> size_t""" + """ + __len__(self) -> size_t + """ return _idaapi.ctree_items_t___len__(self, *args) def __getitem__(self, *args): - """__getitem__(self, i) -> citem_t""" + """ + __getitem__(self, i) -> citem_t + """ return _idaapi.ctree_items_t___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, i, v)""" + """ + __setitem__(self, i, v) + """ return _idaapi.ctree_items_t___setitem__(self, *args) __iter__ = _bounded_getitem_iterator def at(self, *args): - """at(self, n) -> citem_t""" + """ + at(self, n) -> citem_t + """ return _idaapi.ctree_items_t_at(self, *args) ctree_items_t_swigregister = _idaapi.ctree_items_t_swigregister ctree_items_t_swigregister(ctree_items_t) class user_labels_t(object): - """Proxy of C++ std::map<(int,qstring)> class""" + """ + Proxy of C++ std::map<(int,qstring)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def at(self, *args): - """at(self, _Keyval) -> _qstring< char > &""" + """ + at(self, _Keyval) -> _qstring< char > & + """ return _idaapi.user_labels_t_at(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.user_labels_t_size(self, *args) - def __init__(self, *args): - """__init__(self) -> user_labels_t""" + def __init__(self, *args): + """ + __init__(self) -> user_labels_t + """ this = _idaapi.new_user_labels_t(*args) try: self.this.append(this) except: self.this = this @@ -30589,19 +33682,27 @@ user_labels_t_swigregister = _idaapi.user_labels_t_swigregister user_labels_t_swigregister(user_labels_t) class user_cmts_t(object): - """Proxy of C++ std::map<(treeloc_t,citem_cmt_t)> class""" + """ + Proxy of C++ std::map<(treeloc_t,citem_cmt_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def at(self, *args): - """at(self, _Keyval) -> citem_cmt_t""" + """ + at(self, _Keyval) -> citem_cmt_t + """ return _idaapi.user_cmts_t_at(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.user_cmts_t_size(self, *args) - def __init__(self, *args): - """__init__(self) -> user_cmts_t""" + def __init__(self, *args): + """ + __init__(self) -> user_cmts_t + """ this = _idaapi.new_user_cmts_t(*args) try: self.this.append(this) except: self.this = this @@ -30611,19 +33712,27 @@ user_cmts_t_swigregister = _idaapi.user_cmts_t_swigregister user_cmts_t_swigregister(user_cmts_t) class user_iflags_t(object): - """Proxy of C++ std::map<(citem_locator_t,int32)> class""" + """ + Proxy of C++ std::map<(citem_locator_t,int32)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def at(self, *args): - """at(self, _Keyval) -> int &""" + """ + at(self, _Keyval) -> int & + """ return _idaapi.user_iflags_t_at(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.user_iflags_t_size(self, *args) - def __init__(self, *args): - """__init__(self) -> user_iflags_t""" + def __init__(self, *args): + """ + __init__(self) -> user_iflags_t + """ this = _idaapi.new_user_iflags_t(*args) try: self.this.append(this) except: self.this = this @@ -30633,19 +33742,27 @@ user_iflags_t_swigregister = _idaapi.user_iflags_t_swigregister user_iflags_t_swigregister(user_iflags_t) class user_unions_t(object): - """Proxy of C++ std::map<(ea_t,intvec_t)> class""" + """ + Proxy of C++ std::map<(ea_t,intvec_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def at(self, *args): - """at(self, _Keyval) -> intvec_t""" + """ + at(self, _Keyval) -> intvec_t + """ return _idaapi.user_unions_t_at(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.user_unions_t_size(self, *args) - def __init__(self, *args): - """__init__(self) -> user_unions_t""" + def __init__(self, *args): + """ + __init__(self) -> user_unions_t + """ this = _idaapi.new_user_unions_t(*args) try: self.this.append(this) except: self.this = this @@ -30655,10 +33772,12 @@ user_unions_t_swigregister = _idaapi.user_unions_t_swigregister user_unions_t_swigregister(user_unions_t) class cinsnptrvec_t(object): - """Proxy of C++ qvector<(p.cinsn_t)> class""" + """ + Proxy of C++ qvector<(p.cinsn_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> cinsnptrvec_t __init__(self, x) -> cinsnptrvec_t @@ -30676,15 +33795,21 @@ class cinsnptrvec_t(object): return _idaapi.cinsnptrvec_t_push_back(self, *args) def pop_back(self, *args): - """pop_back(self)""" + """ + pop_back(self) + """ return _idaapi.cinsnptrvec_t_pop_back(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.cinsnptrvec_t_size(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.cinsnptrvec_t_empty(self, *args) def front(self, *args): @@ -30702,11 +33827,15 @@ class cinsnptrvec_t(object): return _idaapi.cinsnptrvec_t_back(self, *args) def qclear(self, *args): - """qclear(self)""" + """ + qclear(self) + """ return _idaapi.cinsnptrvec_t_qclear(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.cinsnptrvec_t_clear(self, *args) def resize(self, *args): @@ -30717,35 +33846,51 @@ class cinsnptrvec_t(object): return _idaapi.cinsnptrvec_t_resize(self, *args) def capacity(self, *args): - """capacity(self) -> size_t""" + """ + capacity(self) -> size_t + """ return _idaapi.cinsnptrvec_t_capacity(self, *args) def reserve(self, *args): - """reserve(self, cnt)""" + """ + reserve(self, cnt) + """ return _idaapi.cinsnptrvec_t_reserve(self, *args) def truncate(self, *args): - """truncate(self)""" + """ + truncate(self) + """ return _idaapi.cinsnptrvec_t_truncate(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.cinsnptrvec_t_swap(self, *args) def extract(self, *args): - """extract(self) -> cinsn_t **""" + """ + extract(self) -> cinsn_t ** + """ return _idaapi.cinsnptrvec_t_extract(self, *args) def inject(self, *args): - """inject(self, s, len)""" + """ + inject(self, s, len) + """ return _idaapi.cinsnptrvec_t_inject(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.cinsnptrvec_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.cinsnptrvec_t___ne__(self, *args) def begin(self, *args): @@ -30763,7 +33908,9 @@ class cinsnptrvec_t(object): return _idaapi.cinsnptrvec_t_end(self, *args) def insert(self, *args): - """insert(self, it, x) -> qvector< cinsn_t * >::iterator""" + """ + insert(self, it, x) -> qvector< cinsn_t * >::iterator + """ return _idaapi.cinsnptrvec_t_insert(self, *args) def erase(self, *args): @@ -30781,52 +33928,74 @@ class cinsnptrvec_t(object): return _idaapi.cinsnptrvec_t_find(self, *args) def has(self, *args): - """has(self, x) -> bool""" + """ + has(self, x) -> bool + """ return _idaapi.cinsnptrvec_t_has(self, *args) def add_unique(self, *args): - """add_unique(self, x) -> bool""" + """ + add_unique(self, x) -> bool + """ return _idaapi.cinsnptrvec_t_add_unique(self, *args) def _del(self, *args): - """_del(self, x) -> bool""" + """ + _del(self, x) -> bool + """ return _idaapi.cinsnptrvec_t__del(self, *args) def __len__(self, *args): - """__len__(self) -> size_t""" + """ + __len__(self) -> size_t + """ return _idaapi.cinsnptrvec_t___len__(self, *args) def __getitem__(self, *args): - """__getitem__(self, i) -> cinsn_t""" + """ + __getitem__(self, i) -> cinsn_t + """ return _idaapi.cinsnptrvec_t___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, i, v)""" + """ + __setitem__(self, i, v) + """ return _idaapi.cinsnptrvec_t___setitem__(self, *args) __iter__ = _bounded_getitem_iterator def at(self, *args): - """at(self, n) -> cinsn_t""" + """ + at(self, n) -> cinsn_t + """ return _idaapi.cinsnptrvec_t_at(self, *args) cinsnptrvec_t_swigregister = _idaapi.cinsnptrvec_t_swigregister cinsnptrvec_t_swigregister(cinsnptrvec_t) class eamap_t(object): - """Proxy of C++ std::map<(ea_t,cinsnptrvec_t)> class""" + """ + Proxy of C++ std::map<(ea_t,cinsnptrvec_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def at(self, *args): - """at(self, _Keyval) -> cinsnptrvec_t""" + """ + at(self, _Keyval) -> cinsnptrvec_t + """ return _idaapi.eamap_t_at(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.eamap_t_size(self, *args) - def __init__(self, *args): - """__init__(self) -> eamap_t""" + def __init__(self, *args): + """ + __init__(self) -> eamap_t + """ this = _idaapi.new_eamap_t(*args) try: self.this.append(this) except: self.this = this @@ -30836,19 +34005,27 @@ eamap_t_swigregister = _idaapi.eamap_t_swigregister eamap_t_swigregister(eamap_t) class boundaries_t(object): - """Proxy of C++ std::map<(p.cinsn_t,areaset_t)> class""" + """ + Proxy of C++ std::map<(p.cinsn_t,areaset_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def at(self, *args): - """at(self, _Keyval) -> areaset_t""" + """ + at(self, _Keyval) -> areaset_t + """ return _idaapi.boundaries_t_at(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.boundaries_t_size(self, *args) - def __init__(self, *args): - """__init__(self) -> boundaries_t""" + def __init__(self, *args): + """ + __init__(self) -> boundaries_t + """ this = _idaapi.new_boundaries_t(*args) try: self.this.append(this) except: self.this = this @@ -30858,10 +34035,12 @@ boundaries_t_swigregister = _idaapi.boundaries_t_swigregister boundaries_t_swigregister(boundaries_t) class cfuncptr_t(object): - """Proxy of C++ qrefcnt_t<(cfunc_t)> class""" + """ + Proxy of C++ qrefcnt_t<(cfunc_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self, p) -> cfuncptr_t __init__(self, r) -> cfuncptr_t @@ -30870,15 +34049,21 @@ class cfuncptr_t(object): try: self.this.append(this) except: self.this = this def reset(self, *args): - """reset(self)""" + """ + reset(self) + """ return _idaapi.cfuncptr_t_reset(self, *args) def __deref__(self, *args): - """__deref__(self) -> cfunc_t""" + """ + __deref__(self) -> cfunc_t + """ return _idaapi.cfuncptr_t___deref__(self, *args) def __ref__(self, *args): - """__ref__(self) -> cfunc_t""" + """ + __ref__(self) -> cfunc_t + """ return _idaapi.cfuncptr_t___ref__(self, *args) __swig_destroy__ = _idaapi.delete_cfuncptr_t @@ -30898,133 +34083,189 @@ class cfuncptr_t(object): hdrlines = _swig_property(_idaapi.cfuncptr_t_hdrlines_get, _idaapi.cfuncptr_t_hdrlines_set) treeitems = _swig_property(_idaapi.cfuncptr_t_treeitems_get, _idaapi.cfuncptr_t_treeitems_set) def release(self, *args): - """release(self)""" + """ + release(self) + """ return _idaapi.cfuncptr_t_release(self, *args) def build_c_tree(self, *args): - """build_c_tree(self)""" + """ + build_c_tree(self) + """ return _idaapi.cfuncptr_t_build_c_tree(self, *args) def verify(self, *args): - """verify(self, aul, even_without_debugger)""" + """ + verify(self, aul, even_without_debugger) + """ return _idaapi.cfuncptr_t_verify(self, *args) def print_dcl(self, *args): - """print_dcl(self, buf, bufsize) -> size_t""" + """ + print_dcl(self, buf, bufsize) -> size_t + """ return _idaapi.cfuncptr_t_print_dcl(self, *args) - def print_dcl2(self, *args): - """print_dcl2(self) -> size_t""" - return _idaapi.cfuncptr_t_print_dcl2(self, *args) - def print_func(self, *args): - """print_func(self, vp)""" + """ + print_func(self, vp) + """ return _idaapi.cfuncptr_t_print_func(self, *args) def get_func_type(self, *args): - """get_func_type(self, type) -> bool""" + """ + get_func_type(self, type) -> bool + """ return _idaapi.cfuncptr_t_get_func_type(self, *args) def get_lvars(self, *args): - """get_lvars(self) -> lvars_t""" + """ + get_lvars(self) -> lvars_t + """ return _idaapi.cfuncptr_t_get_lvars(self, *args) def find_label(self, *args): - """find_label(self, label) -> citem_t""" + """ + find_label(self, label) -> citem_t + """ return _idaapi.cfuncptr_t_find_label(self, *args) def remove_unused_labels(self, *args): - """remove_unused_labels(self)""" + """ + remove_unused_labels(self) + """ return _idaapi.cfuncptr_t_remove_unused_labels(self, *args) def get_user_cmt(self, *args): - """get_user_cmt(self, loc, rt) -> char const *""" + """ + get_user_cmt(self, loc, rt) -> char const * + """ return _idaapi.cfuncptr_t_get_user_cmt(self, *args) def set_user_cmt(self, *args): - """set_user_cmt(self, loc, cmt)""" + """ + set_user_cmt(self, loc, cmt) + """ return _idaapi.cfuncptr_t_set_user_cmt(self, *args) def get_user_iflags(self, *args): - """get_user_iflags(self, loc) -> int32""" + """ + get_user_iflags(self, loc) -> int32 + """ return _idaapi.cfuncptr_t_get_user_iflags(self, *args) def set_user_iflags(self, *args): - """set_user_iflags(self, loc, iflags)""" + """ + set_user_iflags(self, loc, iflags) + """ return _idaapi.cfuncptr_t_set_user_iflags(self, *args) def has_orphan_cmts(self, *args): - """has_orphan_cmts(self) -> bool""" + """ + has_orphan_cmts(self) -> bool + """ return _idaapi.cfuncptr_t_has_orphan_cmts(self, *args) def del_orphan_cmts(self, *args): - """del_orphan_cmts(self) -> int""" + """ + del_orphan_cmts(self) -> int + """ return _idaapi.cfuncptr_t_del_orphan_cmts(self, *args) def get_user_union_selection(self, *args): - """get_user_union_selection(self, ea, path) -> bool""" + """ + get_user_union_selection(self, ea, path) -> bool + """ return _idaapi.cfuncptr_t_get_user_union_selection(self, *args) def set_user_union_selection(self, *args): - """set_user_union_selection(self, ea, path)""" + """ + set_user_union_selection(self, ea, path) + """ return _idaapi.cfuncptr_t_set_user_union_selection(self, *args) def save_user_labels(self, *args): - """save_user_labels(self)""" + """ + save_user_labels(self) + """ return _idaapi.cfuncptr_t_save_user_labels(self, *args) def save_user_cmts(self, *args): - """save_user_cmts(self)""" + """ + save_user_cmts(self) + """ return _idaapi.cfuncptr_t_save_user_cmts(self, *args) def save_user_numforms(self, *args): - """save_user_numforms(self)""" + """ + save_user_numforms(self) + """ return _idaapi.cfuncptr_t_save_user_numforms(self, *args) def save_user_iflags(self, *args): - """save_user_iflags(self)""" + """ + save_user_iflags(self) + """ return _idaapi.cfuncptr_t_save_user_iflags(self, *args) def save_user_unions(self, *args): - """save_user_unions(self)""" + """ + save_user_unions(self) + """ return _idaapi.cfuncptr_t_save_user_unions(self, *args) def get_line_item(self, *args): - """get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool""" + """ + get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool + """ return _idaapi.cfuncptr_t_get_line_item(self, *args) def get_warnings(self, *args): - """get_warnings(self) -> hexwarns_t""" + """ + get_warnings(self) -> hexwarns_t + """ return _idaapi.cfuncptr_t_get_warnings(self, *args) def get_eamap(self, *args): - """get_eamap(self) -> eamap_t""" + """ + get_eamap(self) -> eamap_t + """ return _idaapi.cfuncptr_t_get_eamap(self, *args) def get_boundaries(self, *args): - """get_boundaries(self) -> boundaries_t""" + """ + get_boundaries(self) -> boundaries_t + """ return _idaapi.cfuncptr_t_get_boundaries(self, *args) def get_pseudocode(self, *args): - """get_pseudocode(self) -> strvec_t""" + """ + get_pseudocode(self) -> strvec_t + """ return _idaapi.cfuncptr_t_get_pseudocode(self, *args) def gather_derefs(self, *args): - """gather_derefs(self, ci, udm=None) -> bool""" + """ + gather_derefs(self, ci, udm=None) -> bool + """ return _idaapi.cfuncptr_t_gather_derefs(self, *args) def __str__(self, *args): - """__str__(self) -> qstring""" + """ + __str__(self) -> qstring + """ return _idaapi.cfuncptr_t___str__(self, *args) cfuncptr_t_swigregister = _idaapi.cfuncptr_t_swigregister cfuncptr_t_swigregister(cfuncptr_t) class qvector_history_t(object): - """Proxy of C++ qvector<(history_item_t)> class""" + """ + Proxy of C++ qvector<(history_item_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> qvector_history_t __init__(self, x) -> qvector_history_t @@ -31042,19 +34283,27 @@ class qvector_history_t(object): return _idaapi.qvector_history_t_push_back(self, *args) def pop_back(self, *args): - """pop_back(self)""" + """ + pop_back(self) + """ return _idaapi.qvector_history_t_pop_back(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.qvector_history_t_size(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.qvector_history_t_empty(self, *args) def at(self, *args): - """at(self, _idx) -> history_item_t""" + """ + at(self, _idx) -> history_item_t + """ return _idaapi.qvector_history_t_at(self, *args) def front(self, *args): @@ -31072,11 +34321,15 @@ class qvector_history_t(object): return _idaapi.qvector_history_t_back(self, *args) def qclear(self, *args): - """qclear(self)""" + """ + qclear(self) + """ return _idaapi.qvector_history_t_qclear(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.qvector_history_t_clear(self, *args) def resize(self, *args): @@ -31087,39 +34340,57 @@ class qvector_history_t(object): return _idaapi.qvector_history_t_resize(self, *args) def grow(self, *args): - """grow(self, x=history_item_t())""" + """ + grow(self, x=history_item_t()) + """ return _idaapi.qvector_history_t_grow(self, *args) def capacity(self, *args): - """capacity(self) -> size_t""" + """ + capacity(self) -> size_t + """ return _idaapi.qvector_history_t_capacity(self, *args) def reserve(self, *args): - """reserve(self, cnt)""" + """ + reserve(self, cnt) + """ return _idaapi.qvector_history_t_reserve(self, *args) def truncate(self, *args): - """truncate(self)""" + """ + truncate(self) + """ return _idaapi.qvector_history_t_truncate(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.qvector_history_t_swap(self, *args) def extract(self, *args): - """extract(self) -> history_item_t""" + """ + extract(self) -> history_item_t + """ return _idaapi.qvector_history_t_extract(self, *args) def inject(self, *args): - """inject(self, s, len)""" + """ + inject(self, s, len) + """ return _idaapi.qvector_history_t_inject(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.qvector_history_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.qvector_history_t___ne__(self, *args) def begin(self, *args): @@ -31137,7 +34408,9 @@ class qvector_history_t(object): return _idaapi.qvector_history_t_end(self, *args) def insert(self, *args): - """insert(self, it, x) -> history_item_t""" + """ + insert(self, it, x) -> history_item_t + """ return _idaapi.qvector_history_t_insert(self, *args) def erase(self, *args): @@ -31155,27 +34428,39 @@ class qvector_history_t(object): return _idaapi.qvector_history_t_find(self, *args) def has(self, *args): - """has(self, x) -> bool""" + """ + has(self, x) -> bool + """ return _idaapi.qvector_history_t_has(self, *args) def add_unique(self, *args): - """add_unique(self, x) -> bool""" + """ + add_unique(self, x) -> bool + """ return _idaapi.qvector_history_t_add_unique(self, *args) def _del(self, *args): - """_del(self, x) -> bool""" + """ + _del(self, x) -> bool + """ return _idaapi.qvector_history_t__del(self, *args) def __len__(self, *args): - """__len__(self) -> size_t""" + """ + __len__(self) -> size_t + """ return _idaapi.qvector_history_t___len__(self, *args) def __getitem__(self, *args): - """__getitem__(self, i) -> history_item_t""" + """ + __getitem__(self, i) -> history_item_t + """ return _idaapi.qvector_history_t___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, i, v)""" + """ + __setitem__(self, i, v) + """ return _idaapi.qvector_history_t___setitem__(self, *args) __iter__ = _bounded_getitem_iterator @@ -31184,11 +34469,15 @@ qvector_history_t_swigregister = _idaapi.qvector_history_t_swigregister qvector_history_t_swigregister(qvector_history_t) class history_t(qvector_history_t): - """Proxy of C++ qstack<(history_item_t)> class""" + """ + Proxy of C++ qstack<(history_item_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def pop(self, *args): - """pop(self) -> history_item_t""" + """ + pop(self) -> history_item_t + """ return _idaapi.history_t_pop(self, *args) def top(self, *args): @@ -31199,11 +34488,15 @@ class history_t(qvector_history_t): return _idaapi.history_t_top(self, *args) def push(self, *args): - """push(self, v)""" + """ + push(self, v) + """ return _idaapi.history_t_push(self, *args) - def __init__(self, *args): - """__init__(self) -> history_t""" + def __init__(self, *args): + """ + __init__(self) -> history_t + """ this = _idaapi.new_history_t(*args) try: self.this.append(this) except: self.this = this @@ -31213,16 +34506,22 @@ history_t_swigregister = _idaapi.history_t_swigregister history_t_swigregister(history_t) class qlist_cinsn_t_iterator(object): - """Proxy of C++ qlist_cinsn_t_iterator class""" + """ + Proxy of C++ qlist_cinsn_t_iterator class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr cur = _swig_property(_idaapi.qlist_cinsn_t_iterator_cur_get) def next(self, *args): - """next(self) -> qlist_cinsn_t_iterator""" + """ + next(self) -> qlist_cinsn_t_iterator + """ return _idaapi.qlist_cinsn_t_iterator_next(self, *args) - def __init__(self, *args): - """__init__(self) -> qlist_cinsn_t_iterator""" + def __init__(self, *args): + """ + __init__(self) -> qlist_cinsn_t_iterator + """ this = _idaapi.new_qlist_cinsn_t_iterator(*args) try: self.this.append(this) except: self.this = this @@ -31232,10 +34531,12 @@ qlist_cinsn_t_iterator_swigregister = _idaapi.qlist_cinsn_t_iterator_swigregiste qlist_cinsn_t_iterator_swigregister(qlist_cinsn_t_iterator) class qvector_lvar_t(object): - """Proxy of C++ qvector<(lvar_t)> class""" + """ + Proxy of C++ qvector<(lvar_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> qvector_lvar_t __init__(self, x) -> qvector_lvar_t @@ -31253,19 +34554,27 @@ class qvector_lvar_t(object): return _idaapi.qvector_lvar_t_push_back(self, *args) def pop_back(self, *args): - """pop_back(self)""" + """ + pop_back(self) + """ return _idaapi.qvector_lvar_t_pop_back(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.qvector_lvar_t_size(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.qvector_lvar_t_empty(self, *args) def at(self, *args): - """at(self, _idx) -> lvar_t""" + """ + at(self, _idx) -> lvar_t + """ return _idaapi.qvector_lvar_t_at(self, *args) def front(self, *args): @@ -31283,11 +34592,15 @@ class qvector_lvar_t(object): return _idaapi.qvector_lvar_t_back(self, *args) def qclear(self, *args): - """qclear(self)""" + """ + qclear(self) + """ return _idaapi.qvector_lvar_t_qclear(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.qvector_lvar_t_clear(self, *args) def resize(self, *args): @@ -31298,39 +34611,57 @@ class qvector_lvar_t(object): return _idaapi.qvector_lvar_t_resize(self, *args) def grow(self, *args): - """grow(self, x=lvar_t())""" + """ + grow(self, x=lvar_t()) + """ return _idaapi.qvector_lvar_t_grow(self, *args) def capacity(self, *args): - """capacity(self) -> size_t""" + """ + capacity(self) -> size_t + """ return _idaapi.qvector_lvar_t_capacity(self, *args) def reserve(self, *args): - """reserve(self, cnt)""" + """ + reserve(self, cnt) + """ return _idaapi.qvector_lvar_t_reserve(self, *args) def truncate(self, *args): - """truncate(self)""" + """ + truncate(self) + """ return _idaapi.qvector_lvar_t_truncate(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.qvector_lvar_t_swap(self, *args) def extract(self, *args): - """extract(self) -> lvar_t""" + """ + extract(self) -> lvar_t + """ return _idaapi.qvector_lvar_t_extract(self, *args) def inject(self, *args): - """inject(self, s, len)""" + """ + inject(self, s, len) + """ return _idaapi.qvector_lvar_t_inject(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.qvector_lvar_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.qvector_lvar_t___ne__(self, *args) def begin(self, *args): @@ -31348,7 +34679,9 @@ class qvector_lvar_t(object): return _idaapi.qvector_lvar_t_end(self, *args) def insert(self, *args): - """insert(self, it, x) -> lvar_t""" + """ + insert(self, it, x) -> lvar_t + """ return _idaapi.qvector_lvar_t_insert(self, *args) def erase(self, *args): @@ -31366,27 +34699,39 @@ class qvector_lvar_t(object): return _idaapi.qvector_lvar_t_find(self, *args) def has(self, *args): - """has(self, x) -> bool""" + """ + has(self, x) -> bool + """ return _idaapi.qvector_lvar_t_has(self, *args) def add_unique(self, *args): - """add_unique(self, x) -> bool""" + """ + add_unique(self, x) -> bool + """ return _idaapi.qvector_lvar_t_add_unique(self, *args) def _del(self, *args): - """_del(self, x) -> bool""" + """ + _del(self, x) -> bool + """ return _idaapi.qvector_lvar_t__del(self, *args) def __len__(self, *args): - """__len__(self) -> size_t""" + """ + __len__(self) -> size_t + """ return _idaapi.qvector_lvar_t___len__(self, *args) def __getitem__(self, *args): - """__getitem__(self, i) -> lvar_t""" + """ + __getitem__(self, i) -> lvar_t + """ return _idaapi.qvector_lvar_t___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, i, v)""" + """ + __setitem__(self, i, v) + """ return _idaapi.qvector_lvar_t___setitem__(self, *args) __iter__ = _bounded_getitem_iterator @@ -31395,10 +34740,12 @@ qvector_lvar_t_swigregister = _idaapi.qvector_lvar_t_swigregister qvector_lvar_t_swigregister(qvector_lvar_t) class qlist_cinsn_t(object): - """Proxy of C++ qlist<(cinsn_t)> class""" + """ + Proxy of C++ qlist<(cinsn_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> qlist_cinsn_t __init__(self, x) -> qlist_cinsn_t @@ -31409,15 +34756,21 @@ class qlist_cinsn_t(object): __swig_destroy__ = _idaapi.delete_qlist_cinsn_t __del__ = lambda self : None; def swap(self, *args): - """swap(self, x)""" + """ + swap(self, x) + """ return _idaapi.qlist_cinsn_t_swap(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.qlist_cinsn_t_empty(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.qlist_cinsn_t_size(self, *args) def front(self, *args): @@ -31449,7 +34802,9 @@ class qlist_cinsn_t(object): return _idaapi.qlist_cinsn_t_rend(self, *args) def push_front(self, *args): - """push_front(self, x)""" + """ + push_front(self, x) + """ return _idaapi.qlist_cinsn_t_push_front(self, *args) def push_back(self, *args): @@ -31460,31 +34815,45 @@ class qlist_cinsn_t(object): return _idaapi.qlist_cinsn_t_push_back(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.qlist_cinsn_t_clear(self, *args) def pop_front(self, *args): - """pop_front(self)""" + """ + pop_front(self) + """ return _idaapi.qlist_cinsn_t_pop_front(self, *args) def pop_back(self, *args): - """pop_back(self)""" + """ + pop_back(self) + """ return _idaapi.qlist_cinsn_t_pop_back(self, *args) def __eq__(self, *args): - """__eq__(self, x) -> bool""" + """ + __eq__(self, x) -> bool + """ return _idaapi.qlist_cinsn_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, x) -> bool""" + """ + __ne__(self, x) -> bool + """ return _idaapi.qlist_cinsn_t___ne__(self, *args) def begin(self, *args): - """begin(self) -> qlist_cinsn_t_iterator""" + """ + begin(self) -> qlist_cinsn_t_iterator + """ return _idaapi.qlist_cinsn_t_begin(self, *args) def end(self, *args): - """end(self) -> qlist_cinsn_t_iterator""" + """ + end(self) -> qlist_cinsn_t_iterator + """ return _idaapi.qlist_cinsn_t_end(self, *args) def insert(self, *args): @@ -31507,10 +34876,12 @@ qlist_cinsn_t_swigregister = _idaapi.qlist_cinsn_t_swigregister qlist_cinsn_t_swigregister(qlist_cinsn_t) class qvector_carg_t(object): - """Proxy of C++ qvector<(carg_t)> class""" + """ + Proxy of C++ qvector<(carg_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> qvector_carg_t __init__(self, x) -> qvector_carg_t @@ -31528,19 +34899,27 @@ class qvector_carg_t(object): return _idaapi.qvector_carg_t_push_back(self, *args) def pop_back(self, *args): - """pop_back(self)""" + """ + pop_back(self) + """ return _idaapi.qvector_carg_t_pop_back(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.qvector_carg_t_size(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.qvector_carg_t_empty(self, *args) def at(self, *args): - """at(self, _idx) -> carg_t""" + """ + at(self, _idx) -> carg_t + """ return _idaapi.qvector_carg_t_at(self, *args) def front(self, *args): @@ -31558,11 +34937,15 @@ class qvector_carg_t(object): return _idaapi.qvector_carg_t_back(self, *args) def qclear(self, *args): - """qclear(self)""" + """ + qclear(self) + """ return _idaapi.qvector_carg_t_qclear(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.qvector_carg_t_clear(self, *args) def resize(self, *args): @@ -31573,39 +34956,57 @@ class qvector_carg_t(object): return _idaapi.qvector_carg_t_resize(self, *args) def grow(self, *args): - """grow(self, x=carg_t())""" + """ + grow(self, x=carg_t()) + """ return _idaapi.qvector_carg_t_grow(self, *args) def capacity(self, *args): - """capacity(self) -> size_t""" + """ + capacity(self) -> size_t + """ return _idaapi.qvector_carg_t_capacity(self, *args) def reserve(self, *args): - """reserve(self, cnt)""" + """ + reserve(self, cnt) + """ return _idaapi.qvector_carg_t_reserve(self, *args) def truncate(self, *args): - """truncate(self)""" + """ + truncate(self) + """ return _idaapi.qvector_carg_t_truncate(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.qvector_carg_t_swap(self, *args) def extract(self, *args): - """extract(self) -> carg_t""" + """ + extract(self) -> carg_t + """ return _idaapi.qvector_carg_t_extract(self, *args) def inject(self, *args): - """inject(self, s, len)""" + """ + inject(self, s, len) + """ return _idaapi.qvector_carg_t_inject(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.qvector_carg_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.qvector_carg_t___ne__(self, *args) def begin(self, *args): @@ -31623,7 +35024,9 @@ class qvector_carg_t(object): return _idaapi.qvector_carg_t_end(self, *args) def insert(self, *args): - """insert(self, it, x) -> carg_t""" + """ + insert(self, it, x) -> carg_t + """ return _idaapi.qvector_carg_t_insert(self, *args) def erase(self, *args): @@ -31641,27 +35044,39 @@ class qvector_carg_t(object): return _idaapi.qvector_carg_t_find(self, *args) def has(self, *args): - """has(self, x) -> bool""" + """ + has(self, x) -> bool + """ return _idaapi.qvector_carg_t_has(self, *args) def add_unique(self, *args): - """add_unique(self, x) -> bool""" + """ + add_unique(self, x) -> bool + """ return _idaapi.qvector_carg_t_add_unique(self, *args) def _del(self, *args): - """_del(self, x) -> bool""" + """ + _del(self, x) -> bool + """ return _idaapi.qvector_carg_t__del(self, *args) def __len__(self, *args): - """__len__(self) -> size_t""" + """ + __len__(self) -> size_t + """ return _idaapi.qvector_carg_t___len__(self, *args) def __getitem__(self, *args): - """__getitem__(self, i) -> carg_t""" + """ + __getitem__(self, i) -> carg_t + """ return _idaapi.qvector_carg_t___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, i, v)""" + """ + __setitem__(self, i, v) + """ return _idaapi.qvector_carg_t___setitem__(self, *args) __iter__ = _bounded_getitem_iterator @@ -31670,10 +35085,12 @@ qvector_carg_t_swigregister = _idaapi.qvector_carg_t_swigregister qvector_carg_t_swigregister(qvector_carg_t) class qvector_ccase_t(object): - """Proxy of C++ qvector<(ccase_t)> class""" + """ + Proxy of C++ qvector<(ccase_t)> class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> qvector_ccase_t __init__(self, x) -> qvector_ccase_t @@ -31691,19 +35108,27 @@ class qvector_ccase_t(object): return _idaapi.qvector_ccase_t_push_back(self, *args) def pop_back(self, *args): - """pop_back(self)""" + """ + pop_back(self) + """ return _idaapi.qvector_ccase_t_pop_back(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.qvector_ccase_t_size(self, *args) def empty(self, *args): - """empty(self) -> bool""" + """ + empty(self) -> bool + """ return _idaapi.qvector_ccase_t_empty(self, *args) def at(self, *args): - """at(self, _idx) -> ccase_t""" + """ + at(self, _idx) -> ccase_t + """ return _idaapi.qvector_ccase_t_at(self, *args) def front(self, *args): @@ -31721,11 +35146,15 @@ class qvector_ccase_t(object): return _idaapi.qvector_ccase_t_back(self, *args) def qclear(self, *args): - """qclear(self)""" + """ + qclear(self) + """ return _idaapi.qvector_ccase_t_qclear(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.qvector_ccase_t_clear(self, *args) def resize(self, *args): @@ -31736,39 +35165,57 @@ class qvector_ccase_t(object): return _idaapi.qvector_ccase_t_resize(self, *args) def grow(self, *args): - """grow(self, x=ccase_t())""" + """ + grow(self, x=ccase_t()) + """ return _idaapi.qvector_ccase_t_grow(self, *args) def capacity(self, *args): - """capacity(self) -> size_t""" + """ + capacity(self) -> size_t + """ return _idaapi.qvector_ccase_t_capacity(self, *args) def reserve(self, *args): - """reserve(self, cnt)""" + """ + reserve(self, cnt) + """ return _idaapi.qvector_ccase_t_reserve(self, *args) def truncate(self, *args): - """truncate(self)""" + """ + truncate(self) + """ return _idaapi.qvector_ccase_t_truncate(self, *args) def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.qvector_ccase_t_swap(self, *args) def extract(self, *args): - """extract(self) -> ccase_t""" + """ + extract(self) -> ccase_t + """ return _idaapi.qvector_ccase_t_extract(self, *args) def inject(self, *args): - """inject(self, s, len)""" + """ + inject(self, s, len) + """ return _idaapi.qvector_ccase_t_inject(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.qvector_ccase_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.qvector_ccase_t___ne__(self, *args) def begin(self, *args): @@ -31786,7 +35233,9 @@ class qvector_ccase_t(object): return _idaapi.qvector_ccase_t_end(self, *args) def insert(self, *args): - """insert(self, it, x) -> ccase_t""" + """ + insert(self, it, x) -> ccase_t + """ return _idaapi.qvector_ccase_t_insert(self, *args) def erase(self, *args): @@ -31804,27 +35253,39 @@ class qvector_ccase_t(object): return _idaapi.qvector_ccase_t_find(self, *args) def has(self, *args): - """has(self, x) -> bool""" + """ + has(self, x) -> bool + """ return _idaapi.qvector_ccase_t_has(self, *args) def add_unique(self, *args): - """add_unique(self, x) -> bool""" + """ + add_unique(self, x) -> bool + """ return _idaapi.qvector_ccase_t_add_unique(self, *args) def _del(self, *args): - """_del(self, x) -> bool""" + """ + _del(self, x) -> bool + """ return _idaapi.qvector_ccase_t__del(self, *args) def __len__(self, *args): - """__len__(self) -> size_t""" + """ + __len__(self) -> size_t + """ return _idaapi.qvector_ccase_t___len__(self, *args) def __getitem__(self, *args): - """__getitem__(self, i) -> ccase_t""" + """ + __getitem__(self, i) -> ccase_t + """ return _idaapi.qvector_ccase_t___getitem__(self, *args) def __setitem__(self, *args): - """__setitem__(self, i, v)""" + """ + __setitem__(self, i, v) + """ return _idaapi.qvector_ccase_t___setitem__(self, *args) __iter__ = _bounded_getitem_iterator @@ -31834,35 +35295,49 @@ qvector_ccase_t_swigregister(qvector_ccase_t) def qswap(*args): - """qswap(a, b)""" + """ + qswap(a, b) + """ return _idaapi.qswap(*args) def init_hexrays_plugin(*args): - """init_hexrays_plugin(flags=0) -> bool""" + """ + init_hexrays_plugin(flags=0) -> bool + """ return _idaapi.init_hexrays_plugin(*args) def add_custom_viewer_popup_item(*args): - """add_custom_viewer_popup_item(custom_viewer, title, hotkey, custom_viewer_popup_item_callback)""" + """ + add_custom_viewer_popup_item(custom_viewer, title, hotkey, custom_viewer_popup_item_callback) + """ return _idaapi.add_custom_viewer_popup_item(*args) def install_hexrays_callback(*args): - """install_hexrays_callback(hx_cblist_callback) -> bool""" + """ + install_hexrays_callback(hx_cblist_callback) -> bool + """ return _idaapi.install_hexrays_callback(*args) def remove_hexrays_callback(*args): - """remove_hexrays_callback(hx_cblist_callback) -> int""" + """ + remove_hexrays_callback(hx_cblist_callback) -> int + """ return _idaapi.remove_hexrays_callback(*args) def _decompile(*args): - """_decompile(pfn, hf) -> cfuncptr_t""" + """ + _decompile(pfn, hf) -> cfuncptr_t + """ return _idaapi._decompile(*args) class operand_locator_t(object): - """Proxy of C++ operand_locator_t class""" + """ + Proxy of C++ operand_locator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr ea = _swig_property(_idaapi.operand_locator_t_ea_get, _idaapi.operand_locator_t_ea_set) opnum = _swig_property(_idaapi.operand_locator_t_opnum_get, _idaapi.operand_locator_t_opnum_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> operand_locator_t __init__(self, _ea, _opnum) -> operand_locator_t @@ -31871,31 +35346,45 @@ class operand_locator_t(object): try: self.this.append(this) except: self.this = this def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.operand_locator_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.operand_locator_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.operand_locator_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.operand_locator_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.operand_locator_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.operand_locator_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.operand_locator_t_compare(self, *args) __swig_destroy__ = _idaapi.delete_operand_locator_t @@ -31904,7 +35393,9 @@ operand_locator_t_swigregister = _idaapi.operand_locator_t_swigregister operand_locator_t_swigregister(operand_locator_t) class number_format_t(object): - """Proxy of C++ number_format_t class""" + """ + Proxy of C++ number_format_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr flags = _swig_property(_idaapi.number_format_t_flags_get, _idaapi.number_format_t_flags_set) @@ -31913,49 +35404,71 @@ class number_format_t(object): serial = _swig_property(_idaapi.number_format_t_serial_get, _idaapi.number_format_t_serial_set) org_nbytes = _swig_property(_idaapi.number_format_t_org_nbytes_get, _idaapi.number_format_t_org_nbytes_set) type_name = _swig_property(_idaapi.number_format_t_type_name_get, _idaapi.number_format_t_type_name_set) - def __init__(self, *args): - """__init__(self, _opnum=0) -> number_format_t""" + def __init__(self, *args): + """ + __init__(self, _opnum=0) -> number_format_t + """ this = _idaapi.new_number_format_t(*args) try: self.this.append(this) except: self.this = this def getRadix(self, *args): - """getRadix(self) -> int""" + """ + getRadix(self) -> int + """ return _idaapi.number_format_t_getRadix(self, *args) def is_fixed(self, *args): - """is_fixed(self) -> bool""" + """ + is_fixed(self) -> bool + """ return _idaapi.number_format_t_is_fixed(self, *args) def isHex(self, *args): - """isHex(self) -> bool""" + """ + isHex(self) -> bool + """ return _idaapi.number_format_t_isHex(self, *args) def isDec(self, *args): - """isDec(self) -> bool""" + """ + isDec(self) -> bool + """ return _idaapi.number_format_t_isDec(self, *args) def isOct(self, *args): - """isOct(self) -> bool""" + """ + isOct(self) -> bool + """ return _idaapi.number_format_t_isOct(self, *args) def isEnum(self, *args): - """isEnum(self) -> bool""" + """ + isEnum(self) -> bool + """ return _idaapi.number_format_t_isEnum(self, *args) def isChar(self, *args): - """isChar(self) -> bool""" + """ + isChar(self) -> bool + """ return _idaapi.number_format_t_isChar(self, *args) def isStroff(self, *args): - """isStroff(self) -> bool""" + """ + isStroff(self) -> bool + """ return _idaapi.number_format_t_isStroff(self, *args) def isNum(self, *args): - """isNum(self) -> bool""" + """ + isNum(self) -> bool + """ return _idaapi.number_format_t_isNum(self, *args) def needs_to_be_inverted(self, *args): - """needs_to_be_inverted(self) -> bool""" + """ + needs_to_be_inverted(self) -> bool + """ return _idaapi.number_format_t_needs_to_be_inverted(self, *args) __swig_destroy__ = _idaapi.delete_number_format_t @@ -31969,16 +35482,22 @@ NF_NEGATE = _idaapi.NF_NEGATE NF_BITNOT = _idaapi.NF_BITNOT class vd_printer_t(object): - """Proxy of C++ vd_printer_t class""" + """ + Proxy of C++ vd_printer_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr hdrlines = _swig_property(_idaapi.vd_printer_t_hdrlines_get, _idaapi.vd_printer_t_hdrlines_set) def _print(self, *args): - """_print(self, indent, format) -> int""" + """ + _print(self, indent, format) -> int + """ return _idaapi.vd_printer_t__print(self, *args) - def __init__(self, *args): - """__init__(self) -> vd_printer_t""" + def __init__(self, *args): + """ + __init__(self) -> vd_printer_t + """ this = _idaapi.new_vd_printer_t(*args) try: self.this.append(this) except: self.this = this @@ -31988,18 +35507,24 @@ vd_printer_t_swigregister = _idaapi.vd_printer_t_swigregister vd_printer_t_swigregister(vd_printer_t) class vc_printer_t(vd_printer_t): - """Proxy of C++ vc_printer_t class""" + """ + Proxy of C++ vc_printer_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr func = _swig_property(_idaapi.vc_printer_t_func_get, _idaapi.vc_printer_t_func_set) lastchar = _swig_property(_idaapi.vc_printer_t_lastchar_get, _idaapi.vc_printer_t_lastchar_set) - def __init__(self, *args): - """__init__(self, f) -> vc_printer_t""" + def __init__(self, *args): + """ + __init__(self, f) -> vc_printer_t + """ this = _idaapi.new_vc_printer_t(*args) try: self.this.append(this) except: self.this = this def oneliner(self, *args): - """oneliner(self) -> bool""" + """ + oneliner(self) -> bool + """ return _idaapi.vc_printer_t_oneliner(self, *args) __swig_destroy__ = _idaapi.delete_vc_printer_t @@ -32008,22 +35533,30 @@ vc_printer_t_swigregister = _idaapi.vc_printer_t_swigregister vc_printer_t_swigregister(vc_printer_t) class qstring_printer_t(vc_printer_t): - """Proxy of C++ qstring_printer_t class""" + """ + Proxy of C++ qstring_printer_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr with_tags = _swig_property(_idaapi.qstring_printer_t_with_tags_get, _idaapi.qstring_printer_t_with_tags_set) s = _swig_property(_idaapi.qstring_printer_t_s_get, _idaapi.qstring_printer_t_s_set) def _print(self, *args): - """_print(self, indent, format) -> int""" + """ + _print(self, indent, format) -> int + """ return _idaapi.qstring_printer_t__print(self, *args) - def __init__(self, *args): - """__init__(self, f, tags) -> qstring_printer_t""" + def __init__(self, *args): + """ + __init__(self, f, tags) -> qstring_printer_t + """ this = _idaapi.new_qstring_printer_t(*args) try: self.this.append(this) except: self.this = this def get_s(self, *args): - """get_s(self) -> qstring""" + """ + get_s(self) -> qstring + """ return _idaapi.qstring_printer_t_get_s(self, *args) s = property(lambda self: self.get_s()) @@ -32033,55 +35566,81 @@ qstring_printer_t_swigregister(qstring_printer_t) def is_type_correct(*args): - """is_type_correct(ptr) -> bool""" + """ + is_type_correct(ptr) -> bool + """ return _idaapi.is_type_correct(*args) def is_small_struni(*args): - """is_small_struni(tif) -> bool""" + """ + is_small_struni(tif) -> bool + """ return _idaapi.is_small_struni(*args) def is_nonbool_type(*args): - """is_nonbool_type(type) -> bool""" + """ + is_nonbool_type(type) -> bool + """ return _idaapi.is_nonbool_type(*args) def is_bool_type(*args): - """is_bool_type(type) -> bool""" + """ + is_bool_type(type) -> bool + """ return _idaapi.is_bool_type(*args) def is_ptr_or_array(*args): - """is_ptr_or_array(t) -> bool""" + """ + is_ptr_or_array(t) -> bool + """ return _idaapi.is_ptr_or_array(*args) def is_paf(*args): - """is_paf(t) -> bool""" + """ + is_paf(t) -> bool + """ return _idaapi.is_paf(*args) def partial_type_num(*args): - """partial_type_num(type) -> int""" + """ + partial_type_num(type) -> int + """ return _idaapi.partial_type_num(*args) def get_float_type(*args): - """get_float_type(width) -> tinfo_t""" + """ + get_float_type(width) -> tinfo_t + """ return _idaapi.get_float_type(*args) def get_int_type_by_width_and_sign(*args): - """get_int_type_by_width_and_sign(srcwidth, sign) -> tinfo_t""" + """ + get_int_type_by_width_and_sign(srcwidth, sign) -> tinfo_t + """ return _idaapi.get_int_type_by_width_and_sign(*args) def get_unk_type(*args): - """get_unk_type(size) -> tinfo_t""" + """ + get_unk_type(size) -> tinfo_t + """ return _idaapi.get_unk_type(*args) def dummy_ptrtype(*args): - """dummy_ptrtype(ptrsize, isfp) -> tinfo_t""" + """ + dummy_ptrtype(ptrsize, isfp) -> tinfo_t + """ return _idaapi.dummy_ptrtype(*args) def get_member_type(*args): - """get_member_type(mptr, type) -> bool""" + """ + get_member_type(mptr, type) -> bool + """ return _idaapi.get_member_type(*args) def make_pointer(*args): - """make_pointer(type) -> tinfo_t""" + """ + make_pointer(type) -> tinfo_t + """ return _idaapi.make_pointer(*args) def create_typedef(*args): @@ -32099,34 +35658,50 @@ TS_SHRINK = _idaapi.TS_SHRINK TS_MASK = _idaapi.TS_MASK def compare_typsrc(*args): - """compare_typsrc(s1, s2) -> int""" + """ + compare_typsrc(s1, s2) -> int + """ return _idaapi.compare_typsrc(*args) def get_type(*args): - """get_type(id, tif, guess) -> bool""" + """ + get_type(id, tif, guess) -> bool + """ return _idaapi.get_type(*args) def set_type(*args): - """set_type(id, tif, source, force=False) -> bool""" + """ + set_type(id, tif, source, force=False) -> bool + """ return _idaapi.set_type(*args) class vdloc_t(argloc_t): - """Proxy of C++ vdloc_t class""" + """ + Proxy of C++ vdloc_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def reg1(self, *args): - """reg1(self) -> int""" + """ + reg1(self) -> int + """ return _idaapi.vdloc_t_reg1(self, *args) def _set_reg1(self, *args): - """_set_reg1(self, r1)""" + """ + _set_reg1(self, r1) + """ return _idaapi.vdloc_t__set_reg1(self, *args) def set_reg1(self, *args): - """set_reg1(self, r1)""" + """ + set_reg1(self, r1) + """ return _idaapi.vdloc_t_set_reg1(self, *args) - def __init__(self, *args): - """__init__(self) -> vdloc_t""" + def __init__(self, *args): + """ + __init__(self) -> vdloc_t + """ this = _idaapi.new_vdloc_t(*args) try: self.this.append(this) except: self.this = this @@ -32137,19 +35712,25 @@ vdloc_t_swigregister(vdloc_t) def print_vdloc(*args): - """print_vdloc(loc, w) -> size_t""" + """ + print_vdloc(loc, w) -> size_t + """ return _idaapi.print_vdloc(*args) def arglocs_overlap(*args): - """arglocs_overlap(loc1, w1, loc2, w2) -> bool""" + """ + arglocs_overlap(loc1, w1, loc2, w2) -> bool + """ return _idaapi.arglocs_overlap(*args) class lvar_locator_t(object): - """Proxy of C++ lvar_locator_t class""" + """ + Proxy of C++ lvar_locator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr location = _swig_property(_idaapi.lvar_locator_t_location_get, _idaapi.lvar_locator_t_location_set) defea = _swig_property(_idaapi.lvar_locator_t_defea_get, _idaapi.lvar_locator_t_defea_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> lvar_locator_t __init__(self, loc, ea) -> lvar_locator_t @@ -32158,35 +35739,51 @@ class lvar_locator_t(object): try: self.this.append(this) except: self.this = this def get_regnum(self, *args): - """get_regnum(self) -> sval_t""" + """ + get_regnum(self) -> sval_t + """ return _idaapi.lvar_locator_t_get_regnum(self, *args) def is_reg1(self, *args): - """is_reg1(self) -> bool""" + """ + is_reg1(self) -> bool + """ return _idaapi.lvar_locator_t_is_reg1(self, *args) def is_reg2(self, *args): - """is_reg2(self) -> bool""" + """ + is_reg2(self) -> bool + """ return _idaapi.lvar_locator_t_is_reg2(self, *args) def is_reg_var(self, *args): - """is_reg_var(self) -> bool""" + """ + is_reg_var(self) -> bool + """ return _idaapi.lvar_locator_t_is_reg_var(self, *args) def is_stk_var(self, *args): - """is_stk_var(self) -> bool""" + """ + is_stk_var(self) -> bool + """ return _idaapi.lvar_locator_t_is_stk_var(self, *args) def is_scattered(self, *args): - """is_scattered(self) -> bool""" + """ + is_scattered(self) -> bool + """ return _idaapi.lvar_locator_t_is_scattered(self, *args) def get_reg1(self, *args): - """get_reg1(self) -> mreg_t""" + """ + get_reg1(self) -> mreg_t + """ return _idaapi.lvar_locator_t_get_reg1(self, *args) def get_reg2(self, *args): - """get_reg2(self) -> mreg_t""" + """ + get_reg2(self) -> mreg_t + """ return _idaapi.lvar_locator_t_get_reg2(self, *args) def get_scattered(self, *args): @@ -32197,31 +35794,45 @@ class lvar_locator_t(object): return _idaapi.lvar_locator_t_get_scattered(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.lvar_locator_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.lvar_locator_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.lvar_locator_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.lvar_locator_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.lvar_locator_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.lvar_locator_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.lvar_locator_t_compare(self, *args) __swig_destroy__ = _idaapi.delete_lvar_locator_t @@ -32230,7 +35841,9 @@ lvar_locator_t_swigregister = _idaapi.lvar_locator_t_swigregister lvar_locator_t_swigregister(lvar_locator_t) class lvar_t(lvar_locator_t): - """Proxy of C++ lvar_t class""" + """ + Proxy of C++ lvar_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr @@ -32241,175 +35854,261 @@ class lvar_t(lvar_locator_t): defblk = _swig_property(_idaapi.lvar_t_defblk_get, _idaapi.lvar_t_defblk_set) divisor = _swig_property(_idaapi.lvar_t_divisor_get, _idaapi.lvar_t_divisor_set) def used(self, *args): - """used(self) -> bool""" + """ + used(self) -> bool + """ return _idaapi.lvar_t_used(self, *args) def typed(self, *args): - """typed(self) -> bool""" + """ + typed(self) -> bool + """ return _idaapi.lvar_t_typed(self, *args) def mreg_done(self, *args): - """mreg_done(self) -> bool""" + """ + mreg_done(self) -> bool + """ return _idaapi.lvar_t_mreg_done(self, *args) def has_nice_name(self, *args): - """has_nice_name(self) -> bool""" + """ + has_nice_name(self) -> bool + """ return _idaapi.lvar_t_has_nice_name(self, *args) def is_unknown_width(self, *args): - """is_unknown_width(self) -> bool""" + """ + is_unknown_width(self) -> bool + """ return _idaapi.lvar_t_is_unknown_width(self, *args) def has_user_info(self, *args): - """has_user_info(self) -> bool""" + """ + has_user_info(self) -> bool + """ return _idaapi.lvar_t_has_user_info(self, *args) def has_user_name(self, *args): - """has_user_name(self) -> bool""" + """ + has_user_name(self) -> bool + """ return _idaapi.lvar_t_has_user_name(self, *args) def has_user_type(self, *args): - """has_user_type(self) -> bool""" + """ + has_user_type(self) -> bool + """ return _idaapi.lvar_t_has_user_type(self, *args) def is_result_var(self, *args): - """is_result_var(self) -> bool""" + """ + is_result_var(self) -> bool + """ return _idaapi.lvar_t_is_result_var(self, *args) def is_arg_var(self, *args): - """is_arg_var(self) -> bool""" + """ + is_arg_var(self) -> bool + """ return _idaapi.lvar_t_is_arg_var(self, *args) def is_fake_var(self, *args): - """is_fake_var(self) -> bool""" + """ + is_fake_var(self) -> bool + """ return _idaapi.lvar_t_is_fake_var(self, *args) def is_overlapped_var(self, *args): - """is_overlapped_var(self) -> bool""" + """ + is_overlapped_var(self) -> bool + """ return _idaapi.lvar_t_is_overlapped_var(self, *args) def is_floating_var(self, *args): - """is_floating_var(self) -> bool""" + """ + is_floating_var(self) -> bool + """ return _idaapi.lvar_t_is_floating_var(self, *args) def is_spoiled_var(self, *args): - """is_spoiled_var(self) -> bool""" + """ + is_spoiled_var(self) -> bool + """ return _idaapi.lvar_t_is_spoiled_var(self, *args) def is_mapdst_var(self, *args): - """is_mapdst_var(self) -> bool""" + """ + is_mapdst_var(self) -> bool + """ return _idaapi.lvar_t_is_mapdst_var(self, *args) def set_used(self, *args): - """set_used(self)""" + """ + set_used(self) + """ return _idaapi.lvar_t_set_used(self, *args) def clear_used(self, *args): - """clear_used(self)""" + """ + clear_used(self) + """ return _idaapi.lvar_t_clear_used(self, *args) def set_typed(self, *args): - """set_typed(self)""" + """ + set_typed(self) + """ return _idaapi.lvar_t_set_typed(self, *args) def set_non_typed(self, *args): - """set_non_typed(self)""" + """ + set_non_typed(self) + """ return _idaapi.lvar_t_set_non_typed(self, *args) def clr_user_info(self, *args): - """clr_user_info(self)""" + """ + clr_user_info(self) + """ return _idaapi.lvar_t_clr_user_info(self, *args) def set_user_name(self, *args): - """set_user_name(self)""" + """ + set_user_name(self) + """ return _idaapi.lvar_t_set_user_name(self, *args) def set_user_type(self, *args): - """set_user_type(self)""" + """ + set_user_type(self) + """ return _idaapi.lvar_t_set_user_type(self, *args) def clr_user_type(self, *args): - """clr_user_type(self)""" + """ + clr_user_type(self) + """ return _idaapi.lvar_t_clr_user_type(self, *args) def clr_user_name(self, *args): - """clr_user_name(self)""" + """ + clr_user_name(self) + """ return _idaapi.lvar_t_clr_user_name(self, *args) def set_mreg_done(self, *args): - """set_mreg_done(self)""" + """ + set_mreg_done(self) + """ return _idaapi.lvar_t_set_mreg_done(self, *args) def clr_mreg_done(self, *args): - """clr_mreg_done(self)""" + """ + clr_mreg_done(self) + """ return _idaapi.lvar_t_clr_mreg_done(self, *args) def set_unknown_width(self, *args): - """set_unknown_width(self)""" + """ + set_unknown_width(self) + """ return _idaapi.lvar_t_set_unknown_width(self, *args) def clr_unknown_width(self, *args): - """clr_unknown_width(self)""" + """ + clr_unknown_width(self) + """ return _idaapi.lvar_t_clr_unknown_width(self, *args) def set_arg_var(self, *args): - """set_arg_var(self)""" + """ + set_arg_var(self) + """ return _idaapi.lvar_t_set_arg_var(self, *args) def clr_arg_var(self, *args): - """clr_arg_var(self)""" + """ + clr_arg_var(self) + """ return _idaapi.lvar_t_clr_arg_var(self, *args) def set_fake_var(self, *args): - """set_fake_var(self)""" + """ + set_fake_var(self) + """ return _idaapi.lvar_t_set_fake_var(self, *args) def clr_fake_var(self, *args): - """clr_fake_var(self)""" + """ + clr_fake_var(self) + """ return _idaapi.lvar_t_clr_fake_var(self, *args) def set_overlapped_var(self, *args): - """set_overlapped_var(self)""" + """ + set_overlapped_var(self) + """ return _idaapi.lvar_t_set_overlapped_var(self, *args) def clr_overlapped_var(self, *args): - """clr_overlapped_var(self)""" + """ + clr_overlapped_var(self) + """ return _idaapi.lvar_t_clr_overlapped_var(self, *args) def set_floating_var(self, *args): - """set_floating_var(self)""" + """ + set_floating_var(self) + """ return _idaapi.lvar_t_set_floating_var(self, *args) def clr_floating_var(self, *args): - """clr_floating_var(self)""" + """ + clr_floating_var(self) + """ return _idaapi.lvar_t_clr_floating_var(self, *args) def set_spoiled_var(self, *args): - """set_spoiled_var(self)""" + """ + set_spoiled_var(self) + """ return _idaapi.lvar_t_set_spoiled_var(self, *args) def clr_spoiled_var(self, *args): - """clr_spoiled_var(self)""" + """ + clr_spoiled_var(self) + """ return _idaapi.lvar_t_clr_spoiled_var(self, *args) def set_mapdst_var(self, *args): - """set_mapdst_var(self)""" + """ + set_mapdst_var(self) + """ return _idaapi.lvar_t_set_mapdst_var(self, *args) def clr_mapdst_var(self, *args): - """clr_mapdst_var(self)""" + """ + clr_mapdst_var(self) + """ return _idaapi.lvar_t_clr_mapdst_var(self, *args) def set_reg_name(self, *args): - """set_reg_name(self, n)""" + """ + set_reg_name(self, n) + """ return _idaapi.lvar_t_set_reg_name(self, *args) def has_common(self, *args): - """has_common(self, v) -> bool""" + """ + has_common(self, v) -> bool + """ return _idaapi.lvar_t_has_common(self, *args) def has_common_bit(self, *args): - """has_common_bit(self, loc, width2) -> bool""" + """ + has_common_bit(self, loc, width2) -> bool + """ return _idaapi.lvar_t_has_common_bit(self, *args) def type(self, *args): @@ -32420,23 +36119,33 @@ class lvar_t(lvar_locator_t): return _idaapi.lvar_t_type(self, *args) def accepts_type(self, *args): - """accepts_type(self, t) -> bool""" + """ + accepts_type(self, t) -> bool + """ return _idaapi.lvar_t_accepts_type(self, *args) def force_lvar_type(self, *args): - """force_lvar_type(self, t)""" + """ + force_lvar_type(self, t) + """ return _idaapi.lvar_t_force_lvar_type(self, *args) def set_lvar_type(self, *args): - """set_lvar_type(self, t)""" + """ + set_lvar_type(self, t) + """ return _idaapi.lvar_t_set_lvar_type(self, *args) def set_final_lvar_type(self, *args): - """set_final_lvar_type(self, t)""" + """ + set_final_lvar_type(self, t) + """ return _idaapi.lvar_t_set_final_lvar_type(self, *args) def set_width(self, *args): - """set_width(self, w, is_float=False)""" + """ + set_width(self, w, is_float=False) + """ return _idaapi.lvar_t_set_width(self, *args) __swig_destroy__ = _idaapi.delete_lvar_t @@ -32445,27 +36154,39 @@ lvar_t_swigregister = _idaapi.lvar_t_swigregister lvar_t_swigregister(lvar_t) class lvars_t(qvector_lvar_t): - """Proxy of C++ lvars_t class""" + """ + Proxy of C++ lvars_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def find_input_lvar(self, *args): - """find_input_lvar(self, argloc, _size) -> int""" + """ + find_input_lvar(self, argloc, _size) -> int + """ return _idaapi.lvars_t_find_input_lvar(self, *args) def find_stkvar(self, *args): - """find_stkvar(self, spoff, width) -> int""" + """ + find_stkvar(self, spoff, width) -> int + """ return _idaapi.lvars_t_find_stkvar(self, *args) def find(self, *args): - """find(self, ll) -> lvar_t""" + """ + find(self, ll) -> lvar_t + """ return _idaapi.lvars_t_find(self, *args) def find_lvar(self, *args): - """find_lvar(self, location, width, defblk=-1) -> int""" + """ + find_lvar(self, location, width, defblk=-1) -> int + """ return _idaapi.lvars_t_find_lvar(self, *args) - def __init__(self, *args): - """__init__(self) -> lvars_t""" + def __init__(self, *args): + """ + __init__(self) -> lvars_t + """ this = _idaapi.new_lvars_t(*args) try: self.this.append(this) except: self.this = this @@ -32475,7 +36196,9 @@ lvars_t_swigregister = _idaapi.lvars_t_swigregister lvars_t_swigregister(lvars_t) class lvar_saved_info_t(object): - """Proxy of C++ lvar_saved_info_t class""" + """ + Proxy of C++ lvar_saved_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr ll = _swig_property(_idaapi.lvar_saved_info_t_ll_get, _idaapi.lvar_saved_info_t_ll_set) @@ -32483,11 +36206,15 @@ class lvar_saved_info_t(object): type = _swig_property(_idaapi.lvar_saved_info_t_type_get, _idaapi.lvar_saved_info_t_type_set) cmt = _swig_property(_idaapi.lvar_saved_info_t_cmt_get, _idaapi.lvar_saved_info_t_cmt_set) def has_info(self, *args): - """has_info(self) -> bool""" + """ + has_info(self) -> bool + """ return _idaapi.lvar_saved_info_t_has_info(self, *args) - def __init__(self, *args): - """__init__(self) -> lvar_saved_info_t""" + def __init__(self, *args): + """ + __init__(self) -> lvar_saved_info_t + """ this = _idaapi.new_lvar_saved_info_t(*args) try: self.this.append(this) except: self.this = this @@ -32497,13 +36224,17 @@ lvar_saved_info_t_swigregister = _idaapi.lvar_saved_info_t_swigregister lvar_saved_info_t_swigregister(lvar_saved_info_t) class user_lvar_visitor_t(object): - """Proxy of C++ user_lvar_visitor_t class""" + """ + Proxy of C++ user_lvar_visitor_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr stkoff_delta = _swig_property(_idaapi.user_lvar_visitor_t_stkoff_delta_get, _idaapi.user_lvar_visitor_t_stkoff_delta_set) flags = _swig_property(_idaapi.user_lvar_visitor_t_flags_get, _idaapi.user_lvar_visitor_t_flags_set) - def __init__(self, *args): - """__init__(self) -> user_lvar_visitor_t""" + def __init__(self, *args): + """ + __init__(self) -> user_lvar_visitor_t + """ if self.__class__ == user_lvar_visitor_t: _self = None else: @@ -32512,23 +36243,33 @@ class user_lvar_visitor_t(object): try: self.this.append(this) except: self.this = this def handle_retrieved_info(self, *args): - """handle_retrieved_info(self, lv) -> int""" + """ + handle_retrieved_info(self, lv) -> int + """ return _idaapi.user_lvar_visitor_t_handle_retrieved_info(self, *args) def handle_retrieved_mapping(self, *args): - """handle_retrieved_mapping(self, lm) -> int""" + """ + handle_retrieved_mapping(self, lm) -> int + """ return _idaapi.user_lvar_visitor_t_handle_retrieved_mapping(self, *args) def get_info_qty_for_saving(self, *args): - """get_info_qty_for_saving(self) -> int""" + """ + get_info_qty_for_saving(self) -> int + """ return _idaapi.user_lvar_visitor_t_get_info_qty_for_saving(self, *args) def get_info_for_saving(self, *args): - """get_info_for_saving(self, lv) -> bool""" + """ + get_info_for_saving(self, lv) -> bool + """ return _idaapi.user_lvar_visitor_t_get_info_for_saving(self, *args) def get_info_mapping_for_saving(self, *args): - """get_info_mapping_for_saving(self) -> lvar_mapping_t""" + """ + get_info_mapping_for_saving(self) -> lvar_mapping_t + """ return _idaapi.user_lvar_visitor_t_get_info_mapping_for_saving(self, *args) __swig_destroy__ = _idaapi.delete_user_lvar_visitor_t @@ -32543,60 +36284,88 @@ ULV_PRECISE_DEFEA = _idaapi.ULV_PRECISE_DEFEA def restore_user_lvar_settings(*args): - """restore_user_lvar_settings(func_ea, ulv) -> int""" + """ + restore_user_lvar_settings(func_ea, ulv) -> int + """ return _idaapi.restore_user_lvar_settings(*args) def save_user_lvar_settings(*args): - """save_user_lvar_settings(func_ea, ulv)""" + """ + save_user_lvar_settings(func_ea, ulv) + """ return _idaapi.save_user_lvar_settings(*args) class fnumber_t(object): - """Proxy of C++ fnumber_t class""" + """ + Proxy of C++ fnumber_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr fnum = _swig_property(_idaapi.fnumber_t_fnum_get, _idaapi.fnumber_t_fnum_set) nbytes = _swig_property(_idaapi.fnumber_t_nbytes_get, _idaapi.fnumber_t_nbytes_set) def dereference_uint16(self, *args): - """dereference_uint16(self) -> uint16 *""" + """ + dereference_uint16(self) -> uint16 * + """ return _idaapi.fnumber_t_dereference_uint16(self, *args) def dereference_const_uint16(self, *args): - """dereference_const_uint16(self) -> uint16 const *""" + """ + dereference_const_uint16(self) -> uint16 const * + """ return _idaapi.fnumber_t_dereference_const_uint16(self, *args) def _print(self, *args): - """_print(self) -> size_t""" + """ + _print(self) -> size_t + """ return _idaapi.fnumber_t__print(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.fnumber_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.fnumber_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.fnumber_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.fnumber_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.fnumber_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.fnumber_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.fnumber_t_compare(self, *args) - def __init__(self, *args): - """__init__(self) -> fnumber_t""" + def __init__(self, *args): + """ + __init__(self) -> fnumber_t + """ this = _idaapi.new_fnumber_t(*args) try: self.this.append(this) except: self.this = this @@ -32637,42 +36406,60 @@ WARN_UNINITED_REG = _idaapi.WARN_UNINITED_REG WARN_SPLIT_MACRO = _idaapi.WARN_SPLIT_MACRO WARN_MAX = _idaapi.WARN_MAX class hexwarn_t(object): - """Proxy of C++ hexwarn_t class""" + """ + Proxy of C++ hexwarn_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr ea = _swig_property(_idaapi.hexwarn_t_ea_get, _idaapi.hexwarn_t_ea_set) id = _swig_property(_idaapi.hexwarn_t_id_get, _idaapi.hexwarn_t_id_set) text = _swig_property(_idaapi.hexwarn_t_text_get, _idaapi.hexwarn_t_text_set) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.hexwarn_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.hexwarn_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.hexwarn_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.hexwarn_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.hexwarn_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.hexwarn_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.hexwarn_t_compare(self, *args) - def __init__(self, *args): - """__init__(self) -> hexwarn_t""" + def __init__(self, *args): + """ + __init__(self) -> hexwarn_t + """ this = _idaapi.new_hexwarn_t(*args) try: self.this.append(this) except: self.this = this @@ -32683,20 +36470,22 @@ hexwarn_t_swigregister(hexwarn_t) def get_hexrays_version(*args): - """get_hexrays_version() -> char const *""" + """ + get_hexrays_version() -> char const * + """ return _idaapi.get_hexrays_version(*args) def open_pseudocode(*args): - """open_pseudocode(ea, new_window) -> vdui_t""" + """ + open_pseudocode(ea, new_window) -> vdui_t + """ return _idaapi.open_pseudocode(*args) def close_pseudocode(*args): - """close_pseudocode(f) -> bool""" + """ + close_pseudocode(f) -> bool + """ return _idaapi.close_pseudocode(*args) - -def get_tform_vdui(*args): - """get_tform_vdui(f) -> vdui_t""" - return _idaapi.get_tform_vdui(*args) VDRUN_NEWFILE = _idaapi.VDRUN_NEWFILE VDRUN_APPEND = _idaapi.VDRUN_APPEND VDRUN_ONLYNEW = _idaapi.VDRUN_ONLYNEW @@ -32707,11 +36496,15 @@ VDRUN_CMDLINE = _idaapi.VDRUN_CMDLINE VDRUN_STATS = _idaapi.VDRUN_STATS def decompile_many(*args): - """decompile_many(outfile, funcaddrs, flags) -> bool""" + """ + decompile_many(outfile, funcaddrs, flags) -> bool + """ return _idaapi.decompile_many(*args) def micro_err_format(*args): - """micro_err_format(code) -> char const *""" + """ + micro_err_format(code) -> char const * + """ return _idaapi.micro_err_format(*args) MERR_OK = _idaapi.MERR_OK MERR_BLOCK = _idaapi.MERR_BLOCK @@ -32740,18 +36533,18 @@ MERR_COMPLEX = _idaapi.MERR_COMPLEX MERR_LICENSE = _idaapi.MERR_LICENSE MERR_ONLY32 = _idaapi.MERR_ONLY32 MERR_ONLY64 = _idaapi.MERR_ONLY64 -MERR_BUSY = _idaapi.MERR_BUSY -MERR_FARPTR = _idaapi.MERR_FARPTR MERR_MAX_ERR = _idaapi.MERR_MAX_ERR MERR_LOOP = _idaapi.MERR_LOOP class hexrays_failure_t(object): - """Proxy of C++ hexrays_failure_t class""" + """ + Proxy of C++ hexrays_failure_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr code = _swig_property(_idaapi.hexrays_failure_t_code_get, _idaapi.hexrays_failure_t_code_set) errea = _swig_property(_idaapi.hexrays_failure_t_errea_get, _idaapi.hexrays_failure_t_errea_set) str = _swig_property(_idaapi.hexrays_failure_t_str_get, _idaapi.hexrays_failure_t_str_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> hexrays_failure_t __init__(self, c, ea, buf=None) -> hexrays_failure_t @@ -32761,7 +36554,9 @@ class hexrays_failure_t(object): try: self.this.append(this) except: self.this = this def desc(self, *args): - """desc(self) -> qstring""" + """ + desc(self) -> qstring + """ return _idaapi.hexrays_failure_t_desc(self, *args) __swig_destroy__ = _idaapi.delete_hexrays_failure_t @@ -32770,11 +36565,13 @@ hexrays_failure_t_swigregister = _idaapi.hexrays_failure_t_swigregister hexrays_failure_t_swigregister(hexrays_failure_t) class vd_failure_t(object): - """Proxy of C++ vd_failure_t class""" + """ + Proxy of C++ vd_failure_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr hf = _swig_property(_idaapi.vd_failure_t_hf_get, _idaapi.vd_failure_t_hf_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> vd_failure_t __init__(self, code, ea, buf=None) -> vd_failure_t @@ -32785,7 +36582,9 @@ class vd_failure_t(object): try: self.this.append(this) except: self.this = this def desc(self, *args): - """desc(self) -> qstring""" + """ + desc(self) -> qstring + """ return _idaapi.vd_failure_t_desc(self, *args) __swig_destroy__ = _idaapi.delete_vd_failure_t @@ -32794,10 +36593,12 @@ vd_failure_t_swigregister = _idaapi.vd_failure_t_swigregister vd_failure_t_swigregister(vd_failure_t) class vd_interr_t(vd_failure_t): - """Proxy of C++ vd_interr_t class""" + """ + Proxy of C++ vd_interr_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self, ea, buf) -> vd_interr_t __init__(self, ea, buf) -> vd_interr_t @@ -32812,7 +36613,9 @@ vd_interr_t_swigregister(vd_interr_t) def send_database(*args): - """send_database(err, silent)""" + """ + send_database(err, silent) + """ return _idaapi.send_database(*args) cot_empty = _idaapi.cot_empty cot_comma = _idaapi.cot_comma @@ -32883,7 +36686,6 @@ cot_var = _idaapi.cot_var cot_insn = _idaapi.cot_insn cot_sizeof = _idaapi.cot_sizeof cot_helper = _idaapi.cot_helper -cot_type = _idaapi.cot_type cot_last = _idaapi.cot_last cit_empty = _idaapi.cit_empty cit_block = _idaapi.cit_block @@ -32900,7 +36702,9 @@ cit_goto = _idaapi.cit_goto cit_asm = _idaapi.cit_asm cit_end = _idaapi.cit_end class operator_info_t(object): - """Proxy of C++ operator_info_t class""" + """ + Proxy of C++ operator_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr text = _swig_property(_idaapi.operator_info_t_text_get, _idaapi.operator_info_t_text_set) @@ -32908,8 +36712,10 @@ class operator_info_t(object): valency = _swig_property(_idaapi.operator_info_t_valency_get, _idaapi.operator_info_t_valency_set) fixtype = _swig_property(_idaapi.operator_info_t_fixtype_get, _idaapi.operator_info_t_fixtype_set) flags = _swig_property(_idaapi.operator_info_t_flags_get, _idaapi.operator_info_t_flags_set) - def __init__(self, *args): - """__init__(self) -> operator_info_t""" + def __init__(self, *args): + """ + __init__(self) -> operator_info_t + """ this = _idaapi.new_operator_info_t(*args) try: self.this.append(this) except: self.this = this @@ -32932,141 +36738,209 @@ COI_SBN = cvar.COI_SBN def negated_relation(*args): - """negated_relation(op) -> ctype_t""" + """ + negated_relation(op) -> ctype_t + """ return _idaapi.negated_relation(*args) def get_op_signness(*args): - """get_op_signness(op) -> type_sign_t""" + """ + get_op_signness(op) -> type_sign_t + """ return _idaapi.get_op_signness(*args) def asgop(*args): - """asgop(cop) -> ctype_t""" + """ + asgop(cop) -> ctype_t + """ return _idaapi.asgop(*args) def asgop_revert(*args): - """asgop_revert(cop) -> ctype_t""" + """ + asgop_revert(cop) -> ctype_t + """ return _idaapi.asgop_revert(*args) def op_uses_x(*args): - """op_uses_x(op) -> bool""" + """ + op_uses_x(op) -> bool + """ return _idaapi.op_uses_x(*args) def op_uses_y(*args): - """op_uses_y(op) -> bool""" + """ + op_uses_y(op) -> bool + """ return _idaapi.op_uses_y(*args) def op_uses_z(*args): - """op_uses_z(op) -> bool""" + """ + op_uses_z(op) -> bool + """ return _idaapi.op_uses_z(*args) def is_binary(*args): - """is_binary(op) -> bool""" + """ + is_binary(op) -> bool + """ return _idaapi.is_binary(*args) def is_unary(*args): - """is_unary(op) -> bool""" + """ + is_unary(op) -> bool + """ return _idaapi.is_unary(*args) def is_relational(*args): - """is_relational(op) -> bool""" + """ + is_relational(op) -> bool + """ return _idaapi.is_relational(*args) def is_assignment(*args): - """is_assignment(op) -> bool""" + """ + is_assignment(op) -> bool + """ return _idaapi.is_assignment(*args) def accepts_udts(*args): - """accepts_udts(op) -> bool""" + """ + accepts_udts(op) -> bool + """ return _idaapi.accepts_udts(*args) def is_prepost(*args): - """is_prepost(op) -> bool""" + """ + is_prepost(op) -> bool + """ return _idaapi.is_prepost(*args) def is_commutative(*args): - """is_commutative(op) -> bool""" + """ + is_commutative(op) -> bool + """ return _idaapi.is_commutative(*args) def is_additive(*args): - """is_additive(op) -> bool""" + """ + is_additive(op) -> bool + """ return _idaapi.is_additive(*args) def is_multiplicative(*args): - """is_multiplicative(op) -> bool""" + """ + is_multiplicative(op) -> bool + """ return _idaapi.is_multiplicative(*args) def is_bitop(*args): - """is_bitop(op) -> bool""" + """ + is_bitop(op) -> bool + """ return _idaapi.is_bitop(*args) def is_logical(*args): - """is_logical(op) -> bool""" + """ + is_logical(op) -> bool + """ return _idaapi.is_logical(*args) def is_loop(*args): - """is_loop(op) -> bool""" + """ + is_loop(op) -> bool + """ return _idaapi.is_loop(*args) def is_break_consumer(*args): - """is_break_consumer(op) -> bool""" + """ + is_break_consumer(op) -> bool + """ return _idaapi.is_break_consumer(*args) def is_lvalue(*args): - """is_lvalue(op) -> bool""" + """ + is_lvalue(op) -> bool + """ return _idaapi.is_lvalue(*args) def is_allowed_on_small_struni(*args): - """is_allowed_on_small_struni(op) -> bool""" + """ + is_allowed_on_small_struni(op) -> bool + """ return _idaapi.is_allowed_on_small_struni(*args) class cnumber_t(object): - """Proxy of C++ cnumber_t class""" + """ + Proxy of C++ cnumber_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr _value = _swig_property(_idaapi.cnumber_t__value_get, _idaapi.cnumber_t__value_set) nf = _swig_property(_idaapi.cnumber_t_nf_get, _idaapi.cnumber_t_nf_set) - def __init__(self, *args): - """__init__(self, _opnum=0) -> cnumber_t""" + def __init__(self, *args): + """ + __init__(self, _opnum=0) -> cnumber_t + """ this = _idaapi.new_cnumber_t(*args) try: self.this.append(this) except: self.this = this def _print(self, *args): - """_print(self, type) -> size_t""" + """ + _print(self, type) -> size_t + """ return _idaapi.cnumber_t__print(self, *args) def value(self, *args): - """value(self, type) -> uint64""" + """ + value(self, type) -> uint64 + """ return _idaapi.cnumber_t_value(self, *args) def assign(self, *args): - """assign(self, v, nbytes, sign)""" + """ + assign(self, v, nbytes, sign) + """ return _idaapi.cnumber_t_assign(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.cnumber_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.cnumber_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.cnumber_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.cnumber_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.cnumber_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.cnumber_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.cnumber_t_compare(self, *args) __swig_destroy__ = _idaapi.delete_cnumber_t @@ -33075,41 +36949,59 @@ cnumber_t_swigregister = _idaapi.cnumber_t_swigregister cnumber_t_swigregister(cnumber_t) class var_ref_t(object): - """Proxy of C++ var_ref_t class""" + """ + Proxy of C++ var_ref_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr mba = _swig_property(_idaapi.var_ref_t_mba_get, _idaapi.var_ref_t_mba_set) idx = _swig_property(_idaapi.var_ref_t_idx_get, _idaapi.var_ref_t_idx_set) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.var_ref_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.var_ref_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.var_ref_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.var_ref_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.var_ref_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.var_ref_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.var_ref_t_compare(self, *args) - def __init__(self, *args): - """__init__(self) -> var_ref_t""" + def __init__(self, *args): + """ + __init__(self) -> var_ref_t + """ this = _idaapi.new_var_ref_t(*args) try: self.this.append(this) except: self.this = this @@ -33119,49 +37011,71 @@ var_ref_t_swigregister = _idaapi.var_ref_t_swigregister var_ref_t_swigregister(var_ref_t) class ctree_visitor_t(object): - """Proxy of C++ ctree_visitor_t class""" + """ + Proxy of C++ ctree_visitor_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr cv_flags = _swig_property(_idaapi.ctree_visitor_t_cv_flags_get, _idaapi.ctree_visitor_t_cv_flags_set) def maintain_parents(self, *args): - """maintain_parents(self) -> bool""" + """ + maintain_parents(self) -> bool + """ return _idaapi.ctree_visitor_t_maintain_parents(self, *args) def must_prune(self, *args): - """must_prune(self) -> bool""" + """ + must_prune(self) -> bool + """ return _idaapi.ctree_visitor_t_must_prune(self, *args) def must_restart(self, *args): - """must_restart(self) -> bool""" + """ + must_restart(self) -> bool + """ return _idaapi.ctree_visitor_t_must_restart(self, *args) def is_postorder(self, *args): - """is_postorder(self) -> bool""" + """ + is_postorder(self) -> bool + """ return _idaapi.ctree_visitor_t_is_postorder(self, *args) def only_insns(self, *args): - """only_insns(self) -> bool""" + """ + only_insns(self) -> bool + """ return _idaapi.ctree_visitor_t_only_insns(self, *args) def prune_now(self, *args): - """prune_now(self)""" + """ + prune_now(self) + """ return _idaapi.ctree_visitor_t_prune_now(self, *args) def clr_prune(self, *args): - """clr_prune(self)""" + """ + clr_prune(self) + """ return _idaapi.ctree_visitor_t_clr_prune(self, *args) def set_restart(self, *args): - """set_restart(self)""" + """ + set_restart(self) + """ return _idaapi.ctree_visitor_t_set_restart(self, *args) def clr_restart(self, *args): - """clr_restart(self)""" + """ + clr_restart(self) + """ return _idaapi.ctree_visitor_t_clr_restart(self, *args) parents = _swig_property(_idaapi.ctree_visitor_t_parents_get, _idaapi.ctree_visitor_t_parents_set) - def __init__(self, *args): - """__init__(self, _flags) -> ctree_visitor_t""" + def __init__(self, *args): + """ + __init__(self, _flags) -> ctree_visitor_t + """ if self.__class__ == ctree_visitor_t: _self = None else: @@ -33170,35 +37084,51 @@ class ctree_visitor_t(object): try: self.this.append(this) except: self.this = this def apply_to(self, *args): - """apply_to(self, item, parent) -> int""" + """ + apply_to(self, item, parent) -> int + """ return _idaapi.ctree_visitor_t_apply_to(self, *args) def apply_to_exprs(self, *args): - """apply_to_exprs(self, item, parent) -> int""" + """ + apply_to_exprs(self, item, parent) -> int + """ return _idaapi.ctree_visitor_t_apply_to_exprs(self, *args) def parent_expr(self, *args): - """parent_expr(self) -> cexpr_t""" + """ + parent_expr(self) -> cexpr_t + """ return _idaapi.ctree_visitor_t_parent_expr(self, *args) def parent_insn(self, *args): - """parent_insn(self) -> cinsn_t""" + """ + parent_insn(self) -> cinsn_t + """ return _idaapi.ctree_visitor_t_parent_insn(self, *args) def visit_insn(self, *args): - """visit_insn(self, arg0) -> int""" + """ + visit_insn(self, arg0) -> int + """ return _idaapi.ctree_visitor_t_visit_insn(self, *args) def visit_expr(self, *args): - """visit_expr(self, arg0) -> int""" + """ + visit_expr(self, arg0) -> int + """ return _idaapi.ctree_visitor_t_visit_expr(self, *args) def leave_insn(self, *args): - """leave_insn(self, arg0) -> int""" + """ + leave_insn(self, arg0) -> int + """ return _idaapi.ctree_visitor_t_leave_insn(self, *args) def leave_expr(self, *args): - """leave_expr(self, arg0) -> int""" + """ + leave_expr(self, arg0) -> int + """ return _idaapi.ctree_visitor_t_leave_expr(self, *args) __swig_destroy__ = _idaapi.delete_ctree_visitor_t @@ -33217,11 +37147,15 @@ CV_RESTART = _idaapi.CV_RESTART CV_INSNS = _idaapi.CV_INSNS class ctree_parentee_t(ctree_visitor_t): - """Proxy of C++ ctree_parentee_t class""" + """ + Proxy of C++ ctree_parentee_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, post=False) -> ctree_parentee_t""" + def __init__(self, *args): + """ + __init__(self, post=False) -> ctree_parentee_t + """ if self.__class__ == ctree_parentee_t: _self = None else: @@ -33230,7 +37164,9 @@ class ctree_parentee_t(ctree_visitor_t): try: self.this.append(this) except: self.this = this def recalc_parent_types(self, *args): - """recalc_parent_types(self) -> bool""" + """ + recalc_parent_types(self) -> bool + """ return _idaapi.ctree_parentee_t_recalc_parent_types(self, *args) __swig_destroy__ = _idaapi.delete_ctree_parentee_t @@ -33243,12 +37179,16 @@ ctree_parentee_t_swigregister = _idaapi.ctree_parentee_t_swigregister ctree_parentee_t_swigregister(ctree_parentee_t) class cfunc_parentee_t(ctree_parentee_t): - """Proxy of C++ cfunc_parentee_t class""" + """ + Proxy of C++ cfunc_parentee_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr func = _swig_property(_idaapi.cfunc_parentee_t_func_get, _idaapi.cfunc_parentee_t_func_set) - def __init__(self, *args): - """__init__(self, f, post=False) -> cfunc_parentee_t""" + def __init__(self, *args): + """ + __init__(self, f, post=False) -> cfunc_parentee_t + """ if self.__class__ == cfunc_parentee_t: _self = None else: @@ -33257,7 +37197,9 @@ class cfunc_parentee_t(ctree_parentee_t): try: self.this.append(this) except: self.this = this def calc_rvalue_type(self, *args): - """calc_rvalue_type(self, target, e) -> bool""" + """ + calc_rvalue_type(self, target, e) -> bool + """ return _idaapi.cfunc_parentee_t_calc_rvalue_type(self, *args) __swig_destroy__ = _idaapi.delete_cfunc_parentee_t @@ -33296,21 +37238,29 @@ ITP_BLOCK2 = _idaapi.ITP_BLOCK2 ITP_CASE = _idaapi.ITP_CASE ITP_SIGN = _idaapi.ITP_SIGN class treeloc_t(object): - """Proxy of C++ treeloc_t class""" + """ + Proxy of C++ treeloc_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr ea = _swig_property(_idaapi.treeloc_t_ea_get, _idaapi.treeloc_t_ea_set) itp = _swig_property(_idaapi.treeloc_t_itp_get, _idaapi.treeloc_t_itp_set) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.treeloc_t___lt__(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.treeloc_t___eq__(self, *args) - def __init__(self, *args): - """__init__(self) -> treeloc_t""" + def __init__(self, *args): + """ + __init__(self) -> treeloc_t + """ this = _idaapi.new_treeloc_t(*args) try: self.this.append(this) except: self.this = this @@ -33322,11 +37272,13 @@ treeloc_t_swigregister(treeloc_t) RETRIEVE_ONCE = _idaapi.RETRIEVE_ONCE RETRIEVE_ALWAYS = _idaapi.RETRIEVE_ALWAYS class citem_cmt_t(object): - """Proxy of C++ citem_cmt_t class""" + """ + Proxy of C++ citem_cmt_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr used = _swig_property(_idaapi.citem_cmt_t_used_get, _idaapi.citem_cmt_t_used_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> citem_cmt_t __init__(self, s) -> citem_cmt_t @@ -33335,7 +37287,9 @@ class citem_cmt_t(object): try: self.this.append(this) except: self.this = this def c_str(self, *args): - """c_str(self) -> char const *""" + """ + c_str(self) -> char const * + """ return _idaapi.citem_cmt_t_c_str(self, *args) __swig_destroy__ = _idaapi.delete_citem_cmt_t @@ -33344,12 +37298,14 @@ citem_cmt_t_swigregister = _idaapi.citem_cmt_t_swigregister citem_cmt_t_swigregister(citem_cmt_t) class citem_locator_t(object): - """Proxy of C++ citem_locator_t class""" + """ + Proxy of C++ citem_locator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr ea = _swig_property(_idaapi.citem_locator_t_ea_get, _idaapi.citem_locator_t_ea_set) op = _swig_property(_idaapi.citem_locator_t_op_get, _idaapi.citem_locator_t_op_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> citem_locator_t __init__(self, _ea, _op) -> citem_locator_t @@ -33359,31 +37315,45 @@ class citem_locator_t(object): try: self.this.append(this) except: self.this = this def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.citem_locator_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.citem_locator_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.citem_locator_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.citem_locator_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.citem_locator_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.citem_locator_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.citem_locator_t_compare(self, *args) __swig_destroy__ = _idaapi.delete_citem_locator_t @@ -33392,14 +37362,16 @@ citem_locator_t_swigregister = _idaapi.citem_locator_t_swigregister citem_locator_t_swigregister(citem_locator_t) class citem_t(object): - """Proxy of C++ citem_t class""" + """ + Proxy of C++ citem_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr ea = _swig_property(_idaapi.citem_t_ea_get, _idaapi.citem_t_ea_set) op = _swig_property(_idaapi.citem_t_op_get, _idaapi.citem_t_op_set) label_num = _swig_property(_idaapi.citem_t_label_num_get, _idaapi.citem_t_label_num_set) index = _swig_property(_idaapi.citem_t_index_get, _idaapi.citem_t_index_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> citem_t __init__(self, o) -> citem_t @@ -33408,15 +37380,21 @@ class citem_t(object): try: self.this.append(this) except: self.this = this def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.citem_t_swap(self, *args) def is_expr(self, *args): - """is_expr(self) -> bool""" + """ + is_expr(self) -> bool + """ return _idaapi.citem_t_is_expr(self, *args) def contains_label(self, *args): - """contains_label(self) -> bool""" + """ + contains_label(self) -> bool + """ return _idaapi.citem_t_contains_label(self, *args) def find_parent_of(self, *args): @@ -33427,7 +37405,9 @@ class citem_t(object): return _idaapi.citem_t_find_parent_of(self, *args) def print1(self, *args): - """print1(self, func) -> size_t""" + """ + print1(self, func) -> size_t + """ return _idaapi.citem_t_print1(self, *args) cinsn = _swig_property(_idaapi.citem_t_cinsn_get) @@ -33438,32 +37418,38 @@ citem_t_swigregister = _idaapi.citem_t_swigregister citem_t_swigregister(citem_t) class cexpr_t(citem_t): - """Proxy of C++ cexpr_t class""" + """ + Proxy of C++ cexpr_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr type = _swig_property(_idaapi.cexpr_t_type_get, _idaapi.cexpr_t_type_set) exflags = _swig_property(_idaapi.cexpr_t_exflags_get, _idaapi.cexpr_t_exflags_set) def cpadone(self, *args): - """cpadone(self) -> bool""" + """ + cpadone(self) -> bool + """ return _idaapi.cexpr_t_cpadone(self, *args) def is_odd_lvalue(self, *args): - """is_odd_lvalue(self) -> bool""" + """ + is_odd_lvalue(self) -> bool + """ return _idaapi.cexpr_t_is_odd_lvalue(self, *args) def is_fpop(self, *args): - """is_fpop(self) -> bool""" + """ + is_fpop(self) -> bool + """ return _idaapi.cexpr_t_is_fpop(self, *args) - def is_cstr(self, *args): - """is_cstr(self) -> bool""" - return _idaapi.cexpr_t_is_cstr(self, *args) - def set_cpadone(self, *args): - """set_cpadone(self)""" + """ + set_cpadone(self) + """ return _idaapi.cexpr_t_set_cpadone(self, *args) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> cexpr_t __init__(self, cop, _x) -> cexpr_t @@ -33475,157 +37461,233 @@ class cexpr_t(citem_t): try: self.this.append(this) except: self.this = this def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.cexpr_t_swap(self, *args) def assign(self, *args): - """assign(self, r) -> cexpr_t""" + """ + assign(self, r) -> cexpr_t + """ return _idaapi.cexpr_t_assign(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.cexpr_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.cexpr_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.cexpr_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.cexpr_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.cexpr_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.cexpr_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.cexpr_t_compare(self, *args) __swig_destroy__ = _idaapi.delete_cexpr_t __del__ = lambda self : None; def replace_by(self, *args): - """replace_by(self, r)""" + """ + replace_by(self, r) + """ return _idaapi.cexpr_t_replace_by(self, *args) def cleanup(self, *args): - """cleanup(self)""" + """ + cleanup(self) + """ return _idaapi.cexpr_t_cleanup(self, *args) def put_number(self, *args): - """put_number(self, func, value, nbytes, sign=no_sign)""" + """ + put_number(self, func, value, nbytes, sign=no_sign) + """ return _idaapi.cexpr_t_put_number(self, *args) def print1(self, *args): - """print1(self, func) -> size_t""" + """ + print1(self, func) -> size_t + """ return _idaapi.cexpr_t_print1(self, *args) def calc_type(self, *args): - """calc_type(self, recursive)""" + """ + calc_type(self, recursive) + """ return _idaapi.cexpr_t_calc_type(self, *args) def equal_effect(self, *args): - """equal_effect(self, r) -> bool""" + """ + equal_effect(self, r) -> bool + """ return _idaapi.cexpr_t_equal_effect(self, *args) def is_child_of(self, *args): - """is_child_of(self, parent) -> bool""" + """ + is_child_of(self, parent) -> bool + """ return _idaapi.cexpr_t_is_child_of(self, *args) def contains_operator(self, *args): - """contains_operator(self, needed_op) -> bool""" + """ + contains_operator(self, needed_op) -> bool + """ return _idaapi.cexpr_t_contains_operator(self, *args) def contains_comma(self, *args): - """contains_comma(self) -> bool""" + """ + contains_comma(self) -> bool + """ return _idaapi.cexpr_t_contains_comma(self, *args) def contains_insn(self, *args): - """contains_insn(self) -> bool""" + """ + contains_insn(self) -> bool + """ return _idaapi.cexpr_t_contains_insn(self, *args) def contains_insn_or_label(self, *args): - """contains_insn_or_label(self) -> bool""" + """ + contains_insn_or_label(self) -> bool + """ return _idaapi.cexpr_t_contains_insn_or_label(self, *args) def contains_comma_or_insn_or_label(self, *args): - """contains_comma_or_insn_or_label(self) -> bool""" + """ + contains_comma_or_insn_or_label(self) -> bool + """ return _idaapi.cexpr_t_contains_comma_or_insn_or_label(self, *args) def is_nice_expr(self, *args): - """is_nice_expr(self) -> bool""" + """ + is_nice_expr(self) -> bool + """ return _idaapi.cexpr_t_is_nice_expr(self, *args) def is_nice_cond(self, *args): - """is_nice_cond(self) -> bool""" + """ + is_nice_cond(self) -> bool + """ return _idaapi.cexpr_t_is_nice_cond(self, *args) def is_call_object_of(self, *args): - """is_call_object_of(self, parent) -> bool""" + """ + is_call_object_of(self, parent) -> bool + """ return _idaapi.cexpr_t_is_call_object_of(self, *args) def is_call_arg_of(self, *args): - """is_call_arg_of(self, parent) -> bool""" + """ + is_call_arg_of(self, parent) -> bool + """ return _idaapi.cexpr_t_is_call_arg_of(self, *args) def get_type_sign(self, *args): - """get_type_sign(self) -> type_sign_t""" + """ + get_type_sign(self) -> type_sign_t + """ return _idaapi.cexpr_t_get_type_sign(self, *args) def get_high_nbit_bound(self, *args): - """get_high_nbit_bound(self, pbits, psign, p_maybe_negative=None) -> int""" + """ + get_high_nbit_bound(self, pbits, psign, p_maybe_negative=None) -> int + """ return _idaapi.cexpr_t_get_high_nbit_bound(self, *args) def get_low_nbit_bound(self, *args): - """get_low_nbit_bound(self, psign, p_maybe_negative=None) -> int""" + """ + get_low_nbit_bound(self, psign, p_maybe_negative=None) -> int + """ return _idaapi.cexpr_t_get_low_nbit_bound(self, *args) def requires_lvalue(self, *args): - """requires_lvalue(self, child) -> bool""" + """ + requires_lvalue(self, child) -> bool + """ return _idaapi.cexpr_t_requires_lvalue(self, *args) def has_side_effects(self, *args): - """has_side_effects(self) -> bool""" + """ + has_side_effects(self) -> bool + """ return _idaapi.cexpr_t_has_side_effects(self, *args) def numval(self, *args): - """numval(self) -> uint64""" + """ + numval(self) -> uint64 + """ return _idaapi.cexpr_t_numval(self, *args) def is_const_value(self, *args): - """is_const_value(self, _v) -> bool""" + """ + is_const_value(self, _v) -> bool + """ return _idaapi.cexpr_t_is_const_value(self, *args) def is_negative_const(self, *args): - """is_negative_const(self) -> bool""" + """ + is_negative_const(self) -> bool + """ return _idaapi.cexpr_t_is_negative_const(self, *args) def is_non_zero_const(self, *args): - """is_non_zero_const(self) -> bool""" + """ + is_non_zero_const(self) -> bool + """ return _idaapi.cexpr_t_is_non_zero_const(self, *args) def is_zero_const(self, *args): - """is_zero_const(self) -> bool""" + """ + is_zero_const(self) -> bool + """ return _idaapi.cexpr_t_is_zero_const(self, *args) def get_const_value(self, *args): - """get_const_value(self, np) -> bool""" + """ + get_const_value(self, np) -> bool + """ return _idaapi.cexpr_t_get_const_value(self, *args) def maybe_ptr(self, *args): - """maybe_ptr(self) -> bool""" + """ + maybe_ptr(self) -> bool + """ return _idaapi.cexpr_t_maybe_ptr(self, *args) def get_ptr_or_array(self, *args): - """get_ptr_or_array(self) -> cexpr_t""" + """ + get_ptr_or_array(self) -> cexpr_t + """ return _idaapi.cexpr_t_get_ptr_or_array(self, *args) def find_op(self, *args): @@ -33650,7 +37712,9 @@ class cexpr_t(citem_t): return _idaapi.cexpr_t_theother(self, *args) def get_1num_op(self, *args): - """get_1num_op(self, o1, o2) -> bool""" + """ + get_1num_op(self, o1, o2) -> bool + """ return _idaapi.cexpr_t_get_1num_op(self, *args) n = _swig_property(_idaapi.cexpr_t_n_get) @@ -33673,16 +37737,19 @@ EXFL_CPADONE = _idaapi.EXFL_CPADONE EXFL_LVALUE = _idaapi.EXFL_LVALUE EXFL_FPOP = _idaapi.EXFL_FPOP EXFL_ALONE = _idaapi.EXFL_ALONE -EXFL_CSTR = _idaapi.EXFL_CSTR EXFL_ALL = _idaapi.EXFL_ALL class ceinsn_t(object): - """Proxy of C++ ceinsn_t class""" + """ + Proxy of C++ ceinsn_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr expr = _swig_property(_idaapi.ceinsn_t_expr_get, _idaapi.ceinsn_t_expr_set) - def __init__(self, *args): - """__init__(self) -> ceinsn_t""" + def __init__(self, *args): + """ + __init__(self) -> ceinsn_t + """ this = _idaapi.new_ceinsn_t(*args) try: self.this.append(this) except: self.this = this @@ -33695,12 +37762,14 @@ CALC_CURLY_BRACES = _idaapi.CALC_CURLY_BRACES NO_CURLY_BRACES = _idaapi.NO_CURLY_BRACES USE_CURLY_BRACES = _idaapi.USE_CURLY_BRACES class cif_t(ceinsn_t): - """Proxy of C++ cif_t class""" + """ + Proxy of C++ cif_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr ithen = _swig_property(_idaapi.cif_t_ithen_get, _idaapi.cif_t_ithen_set) ielse = _swig_property(_idaapi.cif_t_ielse_get, _idaapi.cif_t_ielse_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> cif_t __init__(self, r) -> cif_t @@ -33709,52 +37778,72 @@ class cif_t(ceinsn_t): try: self.this.append(this) except: self.this = this def assign(self, *args): - """assign(self, r) -> cif_t""" + """ + assign(self, r) -> cif_t + """ return _idaapi.cif_t_assign(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.cif_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.cif_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.cif_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.cif_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.cif_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.cif_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.cif_t_compare(self, *args) __swig_destroy__ = _idaapi.delete_cif_t __del__ = lambda self : None; def cleanup(self, *args): - """cleanup(self)""" + """ + cleanup(self) + """ return _idaapi.cif_t_cleanup(self, *args) cif_t_swigregister = _idaapi.cif_t_swigregister cif_t_swigregister(cif_t) class cloop_t(ceinsn_t): - """Proxy of C++ cloop_t class""" + """ + Proxy of C++ cloop_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr body = _swig_property(_idaapi.cloop_t_body_get, _idaapi.cloop_t_body_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> cloop_t __init__(self, b) -> cloop_t @@ -33764,54 +37853,76 @@ class cloop_t(ceinsn_t): try: self.this.append(this) except: self.this = this def assign(self, *args): - """assign(self, r) -> cloop_t""" + """ + assign(self, r) -> cloop_t + """ return _idaapi.cloop_t_assign(self, *args) __swig_destroy__ = _idaapi.delete_cloop_t __del__ = lambda self : None; def cleanup(self, *args): - """cleanup(self)""" + """ + cleanup(self) + """ return _idaapi.cloop_t_cleanup(self, *args) cloop_t_swigregister = _idaapi.cloop_t_swigregister cloop_t_swigregister(cloop_t) class cfor_t(cloop_t): - """Proxy of C++ cfor_t class""" + """ + Proxy of C++ cfor_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr init = _swig_property(_idaapi.cfor_t_init_get, _idaapi.cfor_t_init_set) step = _swig_property(_idaapi.cfor_t_step_get, _idaapi.cfor_t_step_set) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.cfor_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.cfor_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.cfor_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.cfor_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.cfor_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.cfor_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.cfor_t_compare(self, *args) - def __init__(self, *args): - """__init__(self) -> cfor_t""" + def __init__(self, *args): + """ + __init__(self) -> cfor_t + """ this = _idaapi.new_cfor_t(*args) try: self.this.append(this) except: self.this = this @@ -33821,39 +37932,57 @@ cfor_t_swigregister = _idaapi.cfor_t_swigregister cfor_t_swigregister(cfor_t) class cwhile_t(cloop_t): - """Proxy of C++ cwhile_t class""" + """ + Proxy of C++ cwhile_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.cwhile_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.cwhile_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.cwhile_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.cwhile_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.cwhile_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.cwhile_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.cwhile_t_compare(self, *args) - def __init__(self, *args): - """__init__(self) -> cwhile_t""" + def __init__(self, *args): + """ + __init__(self) -> cwhile_t + """ this = _idaapi.new_cwhile_t(*args) try: self.this.append(this) except: self.this = this @@ -33863,39 +37992,57 @@ cwhile_t_swigregister = _idaapi.cwhile_t_swigregister cwhile_t_swigregister(cwhile_t) class cdo_t(cloop_t): - """Proxy of C++ cdo_t class""" + """ + Proxy of C++ cdo_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.cdo_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.cdo_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.cdo_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.cdo_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.cdo_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.cdo_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.cdo_t_compare(self, *args) - def __init__(self, *args): - """__init__(self) -> cdo_t""" + def __init__(self, *args): + """ + __init__(self) -> cdo_t + """ this = _idaapi.new_cdo_t(*args) try: self.this.append(this) except: self.this = this @@ -33905,39 +38052,57 @@ cdo_t_swigregister = _idaapi.cdo_t_swigregister cdo_t_swigregister(cdo_t) class creturn_t(ceinsn_t): - """Proxy of C++ creturn_t class""" + """ + Proxy of C++ creturn_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.creturn_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.creturn_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.creturn_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.creturn_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.creturn_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.creturn_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.creturn_t_compare(self, *args) - def __init__(self, *args): - """__init__(self) -> creturn_t""" + def __init__(self, *args): + """ + __init__(self) -> creturn_t + """ this = _idaapi.new_creturn_t(*args) try: self.this.append(this) except: self.this = this @@ -33947,40 +38112,58 @@ creturn_t_swigregister = _idaapi.creturn_t_swigregister creturn_t_swigregister(creturn_t) class cgoto_t(object): - """Proxy of C++ cgoto_t class""" + """ + Proxy of C++ cgoto_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr label_num = _swig_property(_idaapi.cgoto_t_label_num_get, _idaapi.cgoto_t_label_num_set) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.cgoto_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.cgoto_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.cgoto_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.cgoto_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.cgoto_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.cgoto_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.cgoto_t_compare(self, *args) - def __init__(self, *args): - """__init__(self) -> cgoto_t""" + def __init__(self, *args): + """ + __init__(self) -> cgoto_t + """ this = _idaapi.new_cgoto_t(*args) try: self.this.append(this) except: self.this = this @@ -33990,10 +38173,12 @@ cgoto_t_swigregister = _idaapi.cgoto_t_swigregister cgoto_t_swigregister(cgoto_t) class casm_t(uvalvec_t): - """Proxy of C++ casm_t class""" + """ + Proxy of C++ casm_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self, ea) -> casm_t __init__(self, r) -> casm_t @@ -34002,35 +38187,51 @@ class casm_t(uvalvec_t): try: self.this.append(this) except: self.this = this def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.casm_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.casm_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.casm_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.casm_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.casm_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.casm_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.casm_t_compare(self, *args) def one_insn(self, *args): - """one_insn(self) -> bool""" + """ + one_insn(self) -> bool + """ return _idaapi.casm_t_one_insn(self, *args) __swig_destroy__ = _idaapi.delete_casm_t @@ -34039,10 +38240,12 @@ casm_t_swigregister = _idaapi.casm_t_swigregister casm_t_swigregister(casm_t) class cinsn_t(citem_t): - """Proxy of C++ cinsn_t class""" + """ + Proxy of C++ cinsn_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> cinsn_t __init__(self, r) -> cinsn_t @@ -34051,93 +38254,137 @@ class cinsn_t(citem_t): try: self.this.append(this) except: self.this = this def swap(self, *args): - """swap(self, r)""" + """ + swap(self, r) + """ return _idaapi.cinsn_t_swap(self, *args) def assign(self, *args): - """assign(self, r) -> cinsn_t""" + """ + assign(self, r) -> cinsn_t + """ return _idaapi.cinsn_t_assign(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.cinsn_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.cinsn_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.cinsn_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.cinsn_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.cinsn_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.cinsn_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.cinsn_t_compare(self, *args) __swig_destroy__ = _idaapi.delete_cinsn_t __del__ = lambda self : None; def replace_by(self, *args): - """replace_by(self, r)""" + """ + replace_by(self, r) + """ return _idaapi.cinsn_t_replace_by(self, *args) def cleanup(self, *args): - """cleanup(self)""" + """ + cleanup(self) + """ return _idaapi.cinsn_t_cleanup(self, *args) def zero(self, *args): - """zero(self)""" + """ + zero(self) + """ return _idaapi.cinsn_t_zero(self, *args) def new_insn(self, *args): - """new_insn(self, insn_ea) -> cinsn_t""" + """ + new_insn(self, insn_ea) -> cinsn_t + """ return _idaapi.cinsn_t_new_insn(self, *args) def create_if(self, *args): - """create_if(self, cnd) -> cif_t""" + """ + create_if(self, cnd) -> cif_t + """ return _idaapi.cinsn_t_create_if(self, *args) def _print(self, *args): - """_print(self, indent, vp, use_curly=CALC_CURLY_BRACES)""" + """ + _print(self, indent, vp, use_curly=CALC_CURLY_BRACES) + """ return _idaapi.cinsn_t__print(self, *args) def print1(self, *args): - """print1(self, func) -> size_t""" + """ + print1(self, func) -> size_t + """ return _idaapi.cinsn_t_print1(self, *args) def is_ordinary_flow(self, *args): - """is_ordinary_flow(self) -> bool""" + """ + is_ordinary_flow(self) -> bool + """ return _idaapi.cinsn_t_is_ordinary_flow(self, *args) def contains_insn(self, *args): - """contains_insn(self, type) -> bool""" + """ + contains_insn(self, type) -> bool + """ return _idaapi.cinsn_t_contains_insn(self, *args) def collect_free_breaks(self, *args): - """collect_free_breaks(self, breaks) -> bool""" + """ + collect_free_breaks(self, breaks) -> bool + """ return _idaapi.cinsn_t_collect_free_breaks(self, *args) def collect_free_continues(self, *args): - """collect_free_continues(self, continues) -> bool""" + """ + collect_free_continues(self, continues) -> bool + """ return _idaapi.cinsn_t_collect_free_continues(self, *args) def contains_free_break(self, *args): - """contains_free_break(self) -> bool""" + """ + contains_free_break(self) -> bool + """ return _idaapi.cinsn_t_contains_free_break(self, *args) def contains_free_continue(self, *args): - """contains_free_continue(self) -> bool""" + """ + contains_free_continue(self) -> bool + """ return _idaapi.cinsn_t_contains_free_continue(self, *args) cblock = _swig_property(_idaapi.cinsn_t_cblock_get) @@ -34154,39 +38401,57 @@ cinsn_t_swigregister = _idaapi.cinsn_t_swigregister cinsn_t_swigregister(cinsn_t) class cblock_t(qlist_cinsn_t): - """Proxy of C++ cblock_t class""" + """ + Proxy of C++ cblock_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.cblock_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.cblock_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.cblock_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.cblock_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.cblock_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.cblock_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.cblock_t_compare(self, *args) - def __init__(self, *args): - """__init__(self) -> cblock_t""" + def __init__(self, *args): + """ + __init__(self) -> cblock_t + """ this = _idaapi.new_cblock_t(*args) try: self.this.append(this) except: self.this = this @@ -34196,46 +38461,66 @@ cblock_t_swigregister = _idaapi.cblock_t_swigregister cblock_t_swigregister(cblock_t) class carg_t(cexpr_t): - """Proxy of C++ carg_t class""" + """ + Proxy of C++ carg_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr is_vararg = _swig_property(_idaapi.carg_t_is_vararg_get, _idaapi.carg_t_is_vararg_set) formal_type = _swig_property(_idaapi.carg_t_formal_type_get, _idaapi.carg_t_formal_type_set) def consume_cexpr(self, *args): - """consume_cexpr(self, e)""" + """ + consume_cexpr(self, e) + """ return _idaapi.carg_t_consume_cexpr(self, *args) - def __init__(self, *args): - """__init__(self) -> carg_t""" + def __init__(self, *args): + """ + __init__(self) -> carg_t + """ this = _idaapi.new_carg_t(*args) try: self.this.append(this) except: self.this = this def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.carg_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.carg_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.carg_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.carg_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.carg_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.carg_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.carg_t_compare(self, *args) __swig_destroy__ = _idaapi.delete_carg_t @@ -34244,11 +38529,13 @@ carg_t_swigregister = _idaapi.carg_t_swigregister carg_t_swigregister(carg_t) class carglist_t(qvector_carg_t): - """Proxy of C++ carglist_t class""" + """ + Proxy of C++ carglist_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr functype = _swig_property(_idaapi.carglist_t_functype_get, _idaapi.carglist_t_functype_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> carglist_t __init__(self, ftype) -> carglist_t @@ -34257,31 +38544,45 @@ class carglist_t(qvector_carg_t): try: self.this.append(this) except: self.this = this def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.carglist_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.carglist_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.carglist_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.carglist_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.carglist_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.carglist_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.carglist_t_compare(self, *args) __swig_destroy__ = _idaapi.delete_carglist_t @@ -34290,48 +38591,70 @@ carglist_t_swigregister = _idaapi.carglist_t_swigregister carglist_t_swigregister(carglist_t) class ccase_t(cinsn_t): - """Proxy of C++ ccase_t class""" + """ + Proxy of C++ ccase_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr values = _swig_property(_idaapi.ccase_t_values_get, _idaapi.ccase_t_values_set) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.ccase_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.ccase_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.ccase_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.ccase_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.ccase_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.ccase_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.ccase_t_compare(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.ccase_t_size(self, *args) def value(self, *args): - """value(self, i) -> uint64 const &""" + """ + value(self, i) -> uint64 const & + """ return _idaapi.ccase_t_value(self, *args) - def __init__(self, *args): - """__init__(self) -> ccase_t""" + def __init__(self, *args): + """ + __init__(self) -> ccase_t + """ this = _idaapi.new_ccase_t(*args) try: self.this.append(this) except: self.this = this @@ -34341,39 +38664,57 @@ ccase_t_swigregister = _idaapi.ccase_t_swigregister ccase_t_swigregister(ccase_t) class ccases_t(qvector_ccase_t): - """Proxy of C++ ccases_t class""" + """ + Proxy of C++ ccases_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.ccases_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.ccases_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.ccases_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.ccases_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.ccases_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.ccases_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.ccases_t_compare(self, *args) - def __init__(self, *args): - """__init__(self) -> ccases_t""" + def __init__(self, *args): + """ + __init__(self) -> ccases_t + """ this = _idaapi.new_ccases_t(*args) try: self.this.append(this) except: self.this = this @@ -34383,41 +38724,59 @@ ccases_t_swigregister = _idaapi.ccases_t_swigregister ccases_t_swigregister(ccases_t) class cswitch_t(ceinsn_t): - """Proxy of C++ cswitch_t class""" + """ + Proxy of C++ cswitch_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr mvnf = _swig_property(_idaapi.cswitch_t_mvnf_get, _idaapi.cswitch_t_mvnf_set) cases = _swig_property(_idaapi.cswitch_t_cases_get, _idaapi.cswitch_t_cases_set) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.cswitch_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.cswitch_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.cswitch_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.cswitch_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.cswitch_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.cswitch_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.cswitch_t_compare(self, *args) - def __init__(self, *args): - """__init__(self) -> cswitch_t""" + def __init__(self, *args): + """ + __init__(self) -> cswitch_t + """ this = _idaapi.new_cswitch_t(*args) try: self.this.append(this) except: self.this = this @@ -34427,41 +38786,59 @@ cswitch_t_swigregister = _idaapi.cswitch_t_swigregister cswitch_t_swigregister(cswitch_t) class ctree_anchor_t(object): - """Proxy of C++ ctree_anchor_t class""" + """ + Proxy of C++ ctree_anchor_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr value = _swig_property(_idaapi.ctree_anchor_t_value_get, _idaapi.ctree_anchor_t_value_set) - def __init__(self, *args): - """__init__(self) -> ctree_anchor_t""" + def __init__(self, *args): + """ + __init__(self) -> ctree_anchor_t + """ this = _idaapi.new_ctree_anchor_t(*args) try: self.this.append(this) except: self.this = this def get_index(self, *args): - """get_index(self) -> int""" + """ + get_index(self) -> int + """ return _idaapi.ctree_anchor_t_get_index(self, *args) def get_itp(self, *args): - """get_itp(self) -> item_preciser_t""" + """ + get_itp(self) -> item_preciser_t + """ return _idaapi.ctree_anchor_t_get_itp(self, *args) def is_valid_anchor(self, *args): - """is_valid_anchor(self) -> bool""" + """ + is_valid_anchor(self) -> bool + """ return _idaapi.ctree_anchor_t_is_valid_anchor(self, *args) def is_citem_anchor(self, *args): - """is_citem_anchor(self) -> bool""" + """ + is_citem_anchor(self) -> bool + """ return _idaapi.ctree_anchor_t_is_citem_anchor(self, *args) def is_lvar_anchor(self, *args): - """is_lvar_anchor(self) -> bool""" + """ + is_lvar_anchor(self) -> bool + """ return _idaapi.ctree_anchor_t_is_lvar_anchor(self, *args) def is_itp_anchor(self, *args): - """is_itp_anchor(self) -> bool""" + """ + is_itp_anchor(self) -> bool + """ return _idaapi.ctree_anchor_t_is_itp_anchor(self, *args) def is_blkcmt_anchor(self, *args): - """is_blkcmt_anchor(self) -> bool""" + """ + is_blkcmt_anchor(self) -> bool + """ return _idaapi.ctree_anchor_t_is_blkcmt_anchor(self, *args) __swig_destroy__ = _idaapi.delete_ctree_anchor_t @@ -34481,38 +38858,50 @@ VDI_LVAR = _idaapi.VDI_LVAR VDI_FUNC = _idaapi.VDI_FUNC VDI_TAIL = _idaapi.VDI_TAIL class ctree_item_t(object): - """Proxy of C++ ctree_item_t class""" + """ + Proxy of C++ ctree_item_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr citype = _swig_property(_idaapi.ctree_item_t_citype_get, _idaapi.ctree_item_t_citype_set) def get_memptr(self, *args): - """get_memptr(self, p_sptr=None) -> member_t""" + """ + get_memptr(self, p_sptr=None) -> member_t + """ return _idaapi.ctree_item_t_get_memptr(self, *args) def get_lvar(self, *args): - """get_lvar(self) -> lvar_t""" + """ + get_lvar(self) -> lvar_t + """ return _idaapi.ctree_item_t_get_lvar(self, *args) def get_ea(self, *args): - """get_ea(self) -> ea_t""" + """ + get_ea(self) -> ea_t + """ return _idaapi.ctree_item_t_get_ea(self, *args) def get_label_num(self, *args): - """get_label_num(self, gln_flags) -> int""" + """ + get_label_num(self, gln_flags) -> int + """ return _idaapi.ctree_item_t_get_label_num(self, *args) def is_citem(self, *args): - """is_citem(self) -> bool""" + """ + is_citem(self) -> bool + """ return _idaapi.ctree_item_t_is_citem(self, *args) it = _swig_property(_idaapi.ctree_item_t_it_get) - e = _swig_property(_idaapi.ctree_item_t_e_get) - i = _swig_property(_idaapi.ctree_item_t_i_get) l = _swig_property(_idaapi.ctree_item_t_l_get) f = _swig_property(_idaapi.ctree_item_t_f_get) loc = _swig_property(_idaapi.ctree_item_t_loc_get) - def __init__(self, *args): - """__init__(self) -> ctree_item_t""" + def __init__(self, *args): + """ + __init__(self) -> ctree_item_t + """ this = _idaapi.new_ctree_item_t(*args) try: self.this.append(this) except: self.this = this @@ -34528,82 +38917,122 @@ FORBID_UNUSED_LABELS = _idaapi.FORBID_UNUSED_LABELS ALLOW_UNUSED_LABELS = _idaapi.ALLOW_UNUSED_LABELS def lnot(*args): - """lnot(e) -> cexpr_t""" + """ + lnot(e) -> cexpr_t + """ return _idaapi.lnot(*args) def new_block(*args): - """new_block() -> cinsn_t""" + """ + new_block() -> cinsn_t + """ return _idaapi.new_block(*args) def vcreate_helper(*args): - """vcreate_helper(standalone, type, format, va) -> cexpr_t""" + """ + vcreate_helper(standalone, type, format, va) -> cexpr_t + """ return _idaapi.vcreate_helper(*args) def create_helper(*args): - """create_helper(standalone, type, format) -> cexpr_t""" + """ + create_helper(standalone, type, format) -> cexpr_t + """ return _idaapi.create_helper(*args) def vcall_helper(*args): - """vcall_helper(rettype, args, format, va) -> cexpr_t""" + """ + vcall_helper(rettype, args, format, va) -> cexpr_t + """ return _idaapi.vcall_helper(*args) def call_helper(*args): - """call_helper(rettype, args, format) -> cexpr_t""" + """ + call_helper(rettype, args, format) -> cexpr_t + """ return _idaapi.call_helper(*args) def make_num(*args): - """make_num(n, func=None, ea=BADADDR, opnum=0, sign=no_sign, size=0) -> cexpr_t""" + """ + make_num(n, func=None, ea=BADADDR, opnum=0, sign=no_sign, size=0) -> cexpr_t + """ return _idaapi.make_num(*args) def make_ref(*args): - """make_ref(e) -> cexpr_t""" + """ + make_ref(e) -> cexpr_t + """ return _idaapi.make_ref(*args) def dereference(*args): - """dereference(e, ptrsize, is_float=False) -> cexpr_t""" + """ + dereference(e, ptrsize, is_float=False) -> cexpr_t + """ return _idaapi.dereference(*args) def save_user_labels(*args): - """save_user_labels(func_ea, user_labels)""" + """ + save_user_labels(func_ea, user_labels) + """ return _idaapi.save_user_labels(*args) def save_user_cmts(*args): - """save_user_cmts(func_ea, user_cmts)""" + """ + save_user_cmts(func_ea, user_cmts) + """ return _idaapi.save_user_cmts(*args) def save_user_numforms(*args): - """save_user_numforms(func_ea, numforms)""" + """ + save_user_numforms(func_ea, numforms) + """ return _idaapi.save_user_numforms(*args) def save_user_iflags(*args): - """save_user_iflags(func_ea, iflags)""" + """ + save_user_iflags(func_ea, iflags) + """ return _idaapi.save_user_iflags(*args) def save_user_unions(*args): - """save_user_unions(func_ea, unions)""" + """ + save_user_unions(func_ea, unions) + """ return _idaapi.save_user_unions(*args) def restore_user_labels(*args): - """restore_user_labels(func_ea) -> user_labels_t""" + """ + restore_user_labels(func_ea) -> user_labels_t + """ return _idaapi.restore_user_labels(*args) def restore_user_cmts(*args): - """restore_user_cmts(func_ea) -> user_cmts_t""" + """ + restore_user_cmts(func_ea) -> user_cmts_t + """ return _idaapi.restore_user_cmts(*args) def restore_user_numforms(*args): - """restore_user_numforms(func_ea) -> user_numforms_t""" + """ + restore_user_numforms(func_ea) -> user_numforms_t + """ return _idaapi.restore_user_numforms(*args) def restore_user_iflags(*args): - """restore_user_iflags(func_ea) -> user_iflags_t""" + """ + restore_user_iflags(func_ea) -> user_iflags_t + """ return _idaapi.restore_user_iflags(*args) def restore_user_unions(*args): - """restore_user_unions(func_ea) -> user_unions_t""" + """ + restore_user_unions(func_ea) -> user_unions_t + """ return _idaapi.restore_user_unions(*args) class cfunc_t(object): - """Proxy of C++ cfunc_t class""" + """ + Proxy of C++ cfunc_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr @@ -34624,123 +39053,177 @@ class cfunc_t(object): __swig_destroy__ = _idaapi.delete_cfunc_t __del__ = lambda self : None; def release(self, *args): - """release(self)""" + """ + release(self) + """ return _idaapi.cfunc_t_release(self, *args) def build_c_tree(self, *args): - """build_c_tree(self)""" + """ + build_c_tree(self) + """ return _idaapi.cfunc_t_build_c_tree(self, *args) def verify(self, *args): - """verify(self, aul, even_without_debugger)""" + """ + verify(self, aul, even_without_debugger) + """ return _idaapi.cfunc_t_verify(self, *args) def print_dcl(self, *args): - """print_dcl(self, buf, bufsize) -> size_t""" + """ + print_dcl(self, buf, bufsize) -> size_t + """ return _idaapi.cfunc_t_print_dcl(self, *args) - def print_dcl2(self, *args): - """print_dcl2(self) -> size_t""" - return _idaapi.cfunc_t_print_dcl2(self, *args) - def print_func(self, *args): - """print_func(self, vp)""" + """ + print_func(self, vp) + """ return _idaapi.cfunc_t_print_func(self, *args) def get_func_type(self, *args): - """get_func_type(self, type) -> bool""" + """ + get_func_type(self, type) -> bool + """ return _idaapi.cfunc_t_get_func_type(self, *args) def get_lvars(self, *args): - """get_lvars(self) -> lvars_t""" + """ + get_lvars(self) -> lvars_t + """ return _idaapi.cfunc_t_get_lvars(self, *args) def find_label(self, *args): - """find_label(self, label) -> citem_t""" + """ + find_label(self, label) -> citem_t + """ return _idaapi.cfunc_t_find_label(self, *args) def remove_unused_labels(self, *args): - """remove_unused_labels(self)""" + """ + remove_unused_labels(self) + """ return _idaapi.cfunc_t_remove_unused_labels(self, *args) def get_user_cmt(self, *args): - """get_user_cmt(self, loc, rt) -> char const *""" + """ + get_user_cmt(self, loc, rt) -> char const * + """ return _idaapi.cfunc_t_get_user_cmt(self, *args) def set_user_cmt(self, *args): - """set_user_cmt(self, loc, cmt)""" + """ + set_user_cmt(self, loc, cmt) + """ return _idaapi.cfunc_t_set_user_cmt(self, *args) def get_user_iflags(self, *args): - """get_user_iflags(self, loc) -> int32""" + """ + get_user_iflags(self, loc) -> int32 + """ return _idaapi.cfunc_t_get_user_iflags(self, *args) def set_user_iflags(self, *args): - """set_user_iflags(self, loc, iflags)""" + """ + set_user_iflags(self, loc, iflags) + """ return _idaapi.cfunc_t_set_user_iflags(self, *args) def has_orphan_cmts(self, *args): - """has_orphan_cmts(self) -> bool""" + """ + has_orphan_cmts(self) -> bool + """ return _idaapi.cfunc_t_has_orphan_cmts(self, *args) def del_orphan_cmts(self, *args): - """del_orphan_cmts(self) -> int""" + """ + del_orphan_cmts(self) -> int + """ return _idaapi.cfunc_t_del_orphan_cmts(self, *args) def get_user_union_selection(self, *args): - """get_user_union_selection(self, ea, path) -> bool""" + """ + get_user_union_selection(self, ea, path) -> bool + """ return _idaapi.cfunc_t_get_user_union_selection(self, *args) def set_user_union_selection(self, *args): - """set_user_union_selection(self, ea, path)""" + """ + set_user_union_selection(self, ea, path) + """ return _idaapi.cfunc_t_set_user_union_selection(self, *args) def save_user_labels(self, *args): - """save_user_labels(self)""" + """ + save_user_labels(self) + """ return _idaapi.cfunc_t_save_user_labels(self, *args) def save_user_cmts(self, *args): - """save_user_cmts(self)""" + """ + save_user_cmts(self) + """ return _idaapi.cfunc_t_save_user_cmts(self, *args) def save_user_numforms(self, *args): - """save_user_numforms(self)""" + """ + save_user_numforms(self) + """ return _idaapi.cfunc_t_save_user_numforms(self, *args) def save_user_iflags(self, *args): - """save_user_iflags(self)""" + """ + save_user_iflags(self) + """ return _idaapi.cfunc_t_save_user_iflags(self, *args) def save_user_unions(self, *args): - """save_user_unions(self)""" + """ + save_user_unions(self) + """ return _idaapi.cfunc_t_save_user_unions(self, *args) def get_line_item(self, *args): - """get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool""" + """ + get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool + """ return _idaapi.cfunc_t_get_line_item(self, *args) def get_warnings(self, *args): - """get_warnings(self) -> hexwarns_t""" + """ + get_warnings(self) -> hexwarns_t + """ return _idaapi.cfunc_t_get_warnings(self, *args) def get_eamap(self, *args): - """get_eamap(self) -> eamap_t""" + """ + get_eamap(self) -> eamap_t + """ return _idaapi.cfunc_t_get_eamap(self, *args) def get_boundaries(self, *args): - """get_boundaries(self) -> boundaries_t""" + """ + get_boundaries(self) -> boundaries_t + """ return _idaapi.cfunc_t_get_boundaries(self, *args) def get_pseudocode(self, *args): - """get_pseudocode(self) -> strvec_t""" + """ + get_pseudocode(self) -> strvec_t + """ return _idaapi.cfunc_t_get_pseudocode(self, *args) def gather_derefs(self, *args): - """gather_derefs(self, ci, udm=None) -> bool""" + """ + gather_derefs(self, ci, udm=None) -> bool + """ return _idaapi.cfunc_t_gather_derefs(self, *args) def __str__(self, *args): - """__str__(self) -> qstring""" + """ + __str__(self) -> qstring + """ return _idaapi.cfunc_t___str__(self, *args) cfunc_t_swigregister = _idaapi.cfunc_t_swigregister @@ -34752,23 +39235,33 @@ CFS_LVARS_HIDDEN = _idaapi.CFS_LVARS_HIDDEN def mark_cfunc_dirty(*args): - """mark_cfunc_dirty(ea) -> bool""" + """ + mark_cfunc_dirty(ea) -> bool + """ return _idaapi.mark_cfunc_dirty(*args) def clear_cached_cfuncs(*args): - """clear_cached_cfuncs()""" + """ + clear_cached_cfuncs() + """ return _idaapi.clear_cached_cfuncs(*args) def has_cached_cfunc(*args): - """has_cached_cfunc(ea) -> bool""" + """ + has_cached_cfunc(ea) -> bool + """ return _idaapi.has_cached_cfunc(*args) def get_ctype_name(*args): - """get_ctype_name(op) -> char const *""" + """ + get_ctype_name(op) -> char const * + """ return _idaapi.get_ctype_name(*args) def create_field_name(*args): - """create_field_name(type, offset=BADADDR) -> qstring""" + """ + create_field_name(type, offset=BADADDR) -> qstring + """ return _idaapi.create_field_name(*args) hxe_flowchart = _idaapi.hxe_flowchart hxe_prolog = _idaapi.hxe_prolog @@ -34793,50 +39286,69 @@ hxe_double_click = _idaapi.hxe_double_click hxe_curpos = _idaapi.hxe_curpos hxe_create_hint = _idaapi.hxe_create_hint hxe_text_ready = _idaapi.hxe_text_ready -hxe_populating_popup = _idaapi.hxe_populating_popup USE_KEYBOARD = _idaapi.USE_KEYBOARD USE_MOUSE = _idaapi.USE_MOUSE class ctext_position_t(object): - """Proxy of C++ ctext_position_t class""" + """ + Proxy of C++ ctext_position_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr lnnum = _swig_property(_idaapi.ctext_position_t_lnnum_get, _idaapi.ctext_position_t_lnnum_set) x = _swig_property(_idaapi.ctext_position_t_x_get, _idaapi.ctext_position_t_x_set) y = _swig_property(_idaapi.ctext_position_t_y_get, _idaapi.ctext_position_t_y_set) def in_ctree(self, *args): - """in_ctree(self, hdrlines) -> bool""" + """ + in_ctree(self, hdrlines) -> bool + """ return _idaapi.ctext_position_t_in_ctree(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.ctext_position_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.ctext_position_t___ne__(self, *args) def __lt__(self, *args): - """__lt__(self, r) -> bool""" + """ + __lt__(self, r) -> bool + """ return _idaapi.ctext_position_t___lt__(self, *args) def __gt__(self, *args): - """__gt__(self, r) -> bool""" + """ + __gt__(self, r) -> bool + """ return _idaapi.ctext_position_t___gt__(self, *args) def __le__(self, *args): - """__le__(self, r) -> bool""" + """ + __le__(self, r) -> bool + """ return _idaapi.ctext_position_t___le__(self, *args) def __ge__(self, *args): - """__ge__(self, r) -> bool""" + """ + __ge__(self, r) -> bool + """ return _idaapi.ctext_position_t___ge__(self, *args) def compare(self, *args): - """compare(self, r) -> int""" + """ + compare(self, r) -> int + """ return _idaapi.ctext_position_t_compare(self, *args) - def __init__(self, *args): - """__init__(self) -> ctext_position_t""" + def __init__(self, *args): + """ + __init__(self) -> ctext_position_t + """ this = _idaapi.new_ctext_position_t(*args) try: self.this.append(this) except: self.this = this @@ -34880,12 +39392,16 @@ def compare(*args): return _idaapi.compare(*args) class history_item_t(ctext_position_t): - """Proxy of C++ history_item_t class""" + """ + Proxy of C++ history_item_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr ea = _swig_property(_idaapi.history_item_t_ea_get, _idaapi.history_item_t_ea_set) - def __init__(self, *args): - """__init__(self) -> history_item_t""" + def __init__(self, *args): + """ + __init__(self) -> history_item_t + """ this = _idaapi.new_history_item_t(*args) try: self.this.append(this) except: self.this = this @@ -34895,34 +39411,48 @@ history_item_t_swigregister = _idaapi.history_item_t_swigregister history_item_t_swigregister(history_item_t) class vdui_t(object): - """Proxy of C++ vdui_t class""" + """ + Proxy of C++ vdui_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr form = _swig_property(_idaapi.vdui_t_form_get, _idaapi.vdui_t_form_set) flags = _swig_property(_idaapi.vdui_t_flags_get, _idaapi.vdui_t_flags_set) def visible(self, *args): - """visible(self) -> bool""" + """ + visible(self) -> bool + """ return _idaapi.vdui_t_visible(self, *args) def valid(self, *args): - """valid(self) -> bool""" + """ + valid(self) -> bool + """ return _idaapi.vdui_t_valid(self, *args) def locked(self, *args): - """locked(self) -> bool""" + """ + locked(self) -> bool + """ return _idaapi.vdui_t_locked(self, *args) def set_visible(self, *args): - """set_visible(self, v)""" + """ + set_visible(self, v) + """ return _idaapi.vdui_t_set_visible(self, *args) def set_valid(self, *args): - """set_valid(self, v)""" + """ + set_valid(self, v) + """ return _idaapi.vdui_t_set_valid(self, *args) def set_locked(self, *args): - """set_locked(self, v)""" + """ + set_locked(self, v) + """ return _idaapi.vdui_t_set_locked(self, *args) view_idx = _swig_property(_idaapi.vdui_t_view_idx_get, _idaapi.vdui_t_view_idx_set) @@ -34936,151 +39466,225 @@ class vdui_t(object): item = _swig_property(_idaapi.vdui_t_item_get, _idaapi.vdui_t_item_set) tail = _swig_property(_idaapi.vdui_t_tail_get, _idaapi.vdui_t_tail_set) def refresh_view(self, *args): - """refresh_view(self, redo_mba)""" + """ + refresh_view(self, redo_mba) + """ return _idaapi.vdui_t_refresh_view(self, *args) def refresh_ctext(self, *args): - """refresh_ctext(self, activate=True)""" + """ + refresh_ctext(self, activate=True) + """ return _idaapi.vdui_t_refresh_ctext(self, *args) def switch_to(self, *args): - """switch_to(self, f, activate)""" + """ + switch_to(self, f, activate) + """ return _idaapi.vdui_t_switch_to(self, *args) def in_ctree(self, *args): - """in_ctree(self) -> bool""" + """ + in_ctree(self) -> bool + """ return _idaapi.vdui_t_in_ctree(self, *args) def get_number(self, *args): - """get_number(self) -> cnumber_t""" + """ + get_number(self) -> cnumber_t + """ return _idaapi.vdui_t_get_number(self, *args) def get_current_label(self, *args): - """get_current_label(self) -> int""" + """ + get_current_label(self) -> int + """ return _idaapi.vdui_t_get_current_label(self, *args) def clear(self, *args): - """clear(self)""" + """ + clear(self) + """ return _idaapi.vdui_t_clear(self, *args) def refresh_cpos(self, *args): - """refresh_cpos(self, idv) -> bool""" + """ + refresh_cpos(self, idv) -> bool + """ return _idaapi.vdui_t_refresh_cpos(self, *args) def get_current_item(self, *args): - """get_current_item(self, idv) -> bool""" + """ + get_current_item(self, idv) -> bool + """ return _idaapi.vdui_t_get_current_item(self, *args) def ui_rename_lvar(self, *args): - """ui_rename_lvar(self, v) -> bool""" + """ + ui_rename_lvar(self, v) -> bool + """ return _idaapi.vdui_t_ui_rename_lvar(self, *args) def rename_lvar(self, *args): - """rename_lvar(self, v, name, is_user_name) -> bool""" + """ + rename_lvar(self, v, name, is_user_name) -> bool + """ return _idaapi.vdui_t_rename_lvar(self, *args) def ui_set_lvar_type(self, *args): - """ui_set_lvar_type(self, v) -> bool""" + """ + ui_set_lvar_type(self, v) -> bool + """ return _idaapi.vdui_t_ui_set_lvar_type(self, *args) def set_lvar_type(self, *args): - """set_lvar_type(self, v, type) -> bool""" + """ + set_lvar_type(self, v, type) -> bool + """ return _idaapi.vdui_t_set_lvar_type(self, *args) def ui_edit_lvar_cmt(self, *args): - """ui_edit_lvar_cmt(self, v) -> bool""" + """ + ui_edit_lvar_cmt(self, v) -> bool + """ return _idaapi.vdui_t_ui_edit_lvar_cmt(self, *args) def set_lvar_cmt(self, *args): - """set_lvar_cmt(self, v, cmt) -> bool""" + """ + set_lvar_cmt(self, v, cmt) -> bool + """ return _idaapi.vdui_t_set_lvar_cmt(self, *args) def ui_map_lvar(self, *args): - """ui_map_lvar(self, v) -> bool""" + """ + ui_map_lvar(self, v) -> bool + """ return _idaapi.vdui_t_ui_map_lvar(self, *args) def ui_unmap_lvar(self, *args): - """ui_unmap_lvar(self, v) -> bool""" + """ + ui_unmap_lvar(self, v) -> bool + """ return _idaapi.vdui_t_ui_unmap_lvar(self, *args) def map_lvar(self, *args): - """map_lvar(self, frm, to) -> bool""" + """ + map_lvar(self, frm, to) -> bool + """ return _idaapi.vdui_t_map_lvar(self, *args) def set_strmem_type(self, *args): - """set_strmem_type(self, sptr, mptr) -> bool""" + """ + set_strmem_type(self, sptr, mptr) -> bool + """ return _idaapi.vdui_t_set_strmem_type(self, *args) def rename_strmem(self, *args): - """rename_strmem(self, sptr, mptr) -> bool""" + """ + rename_strmem(self, sptr, mptr) -> bool + """ return _idaapi.vdui_t_rename_strmem(self, *args) def set_global_type(self, *args): - """set_global_type(self, ea) -> bool""" + """ + set_global_type(self, ea) -> bool + """ return _idaapi.vdui_t_set_global_type(self, *args) def rename_global(self, *args): - """rename_global(self, ea) -> bool""" + """ + rename_global(self, ea) -> bool + """ return _idaapi.vdui_t_rename_global(self, *args) def rename_label(self, *args): - """rename_label(self, label) -> bool""" + """ + rename_label(self, label) -> bool + """ return _idaapi.vdui_t_rename_label(self, *args) def jump_enter(self, *args): - """jump_enter(self, idv, omflags) -> bool""" + """ + jump_enter(self, idv, omflags) -> bool + """ return _idaapi.vdui_t_jump_enter(self, *args) def ctree_to_disasm(self, *args): - """ctree_to_disasm(self) -> bool""" + """ + ctree_to_disasm(self) -> bool + """ return _idaapi.vdui_t_ctree_to_disasm(self, *args) def calc_cmt_type(self, *args): - """calc_cmt_type(self, lnnum, cmttype) -> cmt_type_t""" + """ + calc_cmt_type(self, lnnum, cmttype) -> cmt_type_t + """ return _idaapi.vdui_t_calc_cmt_type(self, *args) def edit_cmt(self, *args): - """edit_cmt(self, loc) -> bool""" + """ + edit_cmt(self, loc) -> bool + """ return _idaapi.vdui_t_edit_cmt(self, *args) def edit_func_cmt(self, *args): - """edit_func_cmt(self) -> bool""" + """ + edit_func_cmt(self) -> bool + """ return _idaapi.vdui_t_edit_func_cmt(self, *args) def del_orphan_cmts(self, *args): - """del_orphan_cmts(self) -> bool""" + """ + del_orphan_cmts(self) -> bool + """ return _idaapi.vdui_t_del_orphan_cmts(self, *args) def set_num_radix(self, *args): - """set_num_radix(self, base) -> bool""" + """ + set_num_radix(self, base) -> bool + """ return _idaapi.vdui_t_set_num_radix(self, *args) def set_num_enum(self, *args): - """set_num_enum(self) -> bool""" + """ + set_num_enum(self) -> bool + """ return _idaapi.vdui_t_set_num_enum(self, *args) def set_num_stroff(self, *args): - """set_num_stroff(self) -> bool""" + """ + set_num_stroff(self) -> bool + """ return _idaapi.vdui_t_set_num_stroff(self, *args) def invert_sign(self, *args): - """invert_sign(self) -> bool""" + """ + invert_sign(self) -> bool + """ return _idaapi.vdui_t_invert_sign(self, *args) def invert_bits(self, *args): - """invert_bits(self) -> bool""" + """ + invert_bits(self) -> bool + """ return _idaapi.vdui_t_invert_bits(self, *args) def collapse_item(self, *args): - """collapse_item(self, hide) -> bool""" + """ + collapse_item(self, hide) -> bool + """ return _idaapi.vdui_t_collapse_item(self, *args) def collapse_lvars(self, *args): - """collapse_lvars(self, hide) -> bool""" + """ + collapse_lvars(self, hide) -> bool + """ return _idaapi.vdui_t_collapse_lvars(self, *args) def split_item(self, *args): - """split_item(self, split) -> bool""" + """ + split_item(self, split) -> bool + """ return _idaapi.vdui_t_split_item(self, *args) __swig_destroy__ = _idaapi.delete_vdui_t @@ -35396,27 +40000,35 @@ hx_set_type = _idaapi.hx_set_type hx_vdloc_t_compare = _idaapi.hx_vdloc_t_compare hx_get_float_type = _idaapi.hx_get_float_type hx_vdui_t_get_current_label = _idaapi.hx_vdui_t_get_current_label -hx_get_tform_vdui = _idaapi.hx_get_tform_vdui -hx_cfunc_t_print_dcl2 = _idaapi.hx_cfunc_t_print_dcl2 def term_hexrays_plugin(*args): - """term_hexrays_plugin()""" + """ + term_hexrays_plugin() + """ return _idaapi.term_hexrays_plugin(*args) class user_numforms_iterator_t(object): - """Proxy of C++ user_numforms_iterator_t class""" + """ + Proxy of C++ user_numforms_iterator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr x = _swig_property(_idaapi.user_numforms_iterator_t_x_get, _idaapi.user_numforms_iterator_t_x_set) def __eq__(self, *args): - """__eq__(self, p) -> bool""" + """ + __eq__(self, p) -> bool + """ return _idaapi.user_numforms_iterator_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, p) -> bool""" + """ + __ne__(self, p) -> bool + """ return _idaapi.user_numforms_iterator_t___ne__(self, *args) - def __init__(self, *args): - """__init__(self) -> user_numforms_iterator_t""" + def __init__(self, *args): + """ + __init__(self) -> user_numforms_iterator_t + """ this = _idaapi.new_user_numforms_iterator_t(*args) try: self.this.append(this) except: self.this = this @@ -35427,67 +40039,99 @@ user_numforms_iterator_t_swigregister(user_numforms_iterator_t) def user_numforms_begin(*args): - """user_numforms_begin(map) -> user_numforms_iterator_t""" + """ + user_numforms_begin(map) -> user_numforms_iterator_t + """ return _idaapi.user_numforms_begin(*args) def user_numforms_end(*args): - """user_numforms_end(map) -> user_numforms_iterator_t""" + """ + user_numforms_end(map) -> user_numforms_iterator_t + """ return _idaapi.user_numforms_end(*args) def user_numforms_next(*args): - """user_numforms_next(p) -> user_numforms_iterator_t""" + """ + user_numforms_next(p) -> user_numforms_iterator_t + """ return _idaapi.user_numforms_next(*args) def user_numforms_prev(*args): - """user_numforms_prev(p) -> user_numforms_iterator_t""" + """ + user_numforms_prev(p) -> user_numforms_iterator_t + """ return _idaapi.user_numforms_prev(*args) def user_numforms_first(*args): - """user_numforms_first(p) -> operand_locator_t""" + """ + user_numforms_first(p) -> operand_locator_t + """ return _idaapi.user_numforms_first(*args) def user_numforms_second(*args): - """user_numforms_second(p) -> number_format_t""" + """ + user_numforms_second(p) -> number_format_t + """ return _idaapi.user_numforms_second(*args) def user_numforms_find(*args): - """user_numforms_find(map, key) -> user_numforms_iterator_t""" + """ + user_numforms_find(map, key) -> user_numforms_iterator_t + """ return _idaapi.user_numforms_find(*args) def user_numforms_insert(*args): - """user_numforms_insert(map, key, val) -> user_numforms_iterator_t""" + """ + user_numforms_insert(map, key, val) -> user_numforms_iterator_t + """ return _idaapi.user_numforms_insert(*args) def user_numforms_erase(*args): - """user_numforms_erase(map, p)""" + """ + user_numforms_erase(map, p) + """ return _idaapi.user_numforms_erase(*args) def user_numforms_clear(*args): - """user_numforms_clear(map)""" + """ + user_numforms_clear(map) + """ return _idaapi.user_numforms_clear(*args) def user_numforms_size(*args): - """user_numforms_size(map) -> size_t""" + """ + user_numforms_size(map) -> size_t + """ return _idaapi.user_numforms_size(*args) def user_numforms_free(*args): - """user_numforms_free(map)""" + """ + user_numforms_free(map) + """ return _idaapi.user_numforms_free(*args) class lvar_mapping_iterator_t(object): - """Proxy of C++ lvar_mapping_iterator_t class""" + """ + Proxy of C++ lvar_mapping_iterator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr x = _swig_property(_idaapi.lvar_mapping_iterator_t_x_get, _idaapi.lvar_mapping_iterator_t_x_set) def __eq__(self, *args): - """__eq__(self, p) -> bool""" + """ + __eq__(self, p) -> bool + """ return _idaapi.lvar_mapping_iterator_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, p) -> bool""" + """ + __ne__(self, p) -> bool + """ return _idaapi.lvar_mapping_iterator_t___ne__(self, *args) - def __init__(self, *args): - """__init__(self) -> lvar_mapping_iterator_t""" + def __init__(self, *args): + """ + __init__(self) -> lvar_mapping_iterator_t + """ this = _idaapi.new_lvar_mapping_iterator_t(*args) try: self.this.append(this) except: self.this = this @@ -35498,67 +40142,99 @@ lvar_mapping_iterator_t_swigregister(lvar_mapping_iterator_t) def lvar_mapping_begin(*args): - """lvar_mapping_begin(map) -> lvar_mapping_iterator_t""" + """ + lvar_mapping_begin(map) -> lvar_mapping_iterator_t + """ return _idaapi.lvar_mapping_begin(*args) def lvar_mapping_end(*args): - """lvar_mapping_end(map) -> lvar_mapping_iterator_t""" + """ + lvar_mapping_end(map) -> lvar_mapping_iterator_t + """ return _idaapi.lvar_mapping_end(*args) def lvar_mapping_next(*args): - """lvar_mapping_next(p) -> lvar_mapping_iterator_t""" + """ + lvar_mapping_next(p) -> lvar_mapping_iterator_t + """ return _idaapi.lvar_mapping_next(*args) def lvar_mapping_prev(*args): - """lvar_mapping_prev(p) -> lvar_mapping_iterator_t""" + """ + lvar_mapping_prev(p) -> lvar_mapping_iterator_t + """ return _idaapi.lvar_mapping_prev(*args) def lvar_mapping_first(*args): - """lvar_mapping_first(p) -> lvar_locator_t""" + """ + lvar_mapping_first(p) -> lvar_locator_t + """ return _idaapi.lvar_mapping_first(*args) def lvar_mapping_second(*args): - """lvar_mapping_second(p) -> lvar_locator_t""" + """ + lvar_mapping_second(p) -> lvar_locator_t + """ return _idaapi.lvar_mapping_second(*args) def lvar_mapping_find(*args): - """lvar_mapping_find(map, key) -> lvar_mapping_iterator_t""" + """ + lvar_mapping_find(map, key) -> lvar_mapping_iterator_t + """ return _idaapi.lvar_mapping_find(*args) def lvar_mapping_insert(*args): - """lvar_mapping_insert(map, key, val) -> lvar_mapping_iterator_t""" + """ + lvar_mapping_insert(map, key, val) -> lvar_mapping_iterator_t + """ return _idaapi.lvar_mapping_insert(*args) def lvar_mapping_erase(*args): - """lvar_mapping_erase(map, p)""" + """ + lvar_mapping_erase(map, p) + """ return _idaapi.lvar_mapping_erase(*args) def lvar_mapping_clear(*args): - """lvar_mapping_clear(map)""" + """ + lvar_mapping_clear(map) + """ return _idaapi.lvar_mapping_clear(*args) def lvar_mapping_size(*args): - """lvar_mapping_size(map) -> size_t""" + """ + lvar_mapping_size(map) -> size_t + """ return _idaapi.lvar_mapping_size(*args) def lvar_mapping_free(*args): - """lvar_mapping_free(map)""" + """ + lvar_mapping_free(map) + """ return _idaapi.lvar_mapping_free(*args) class user_cmts_iterator_t(object): - """Proxy of C++ user_cmts_iterator_t class""" + """ + Proxy of C++ user_cmts_iterator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr x = _swig_property(_idaapi.user_cmts_iterator_t_x_get, _idaapi.user_cmts_iterator_t_x_set) def __eq__(self, *args): - """__eq__(self, p) -> bool""" + """ + __eq__(self, p) -> bool + """ return _idaapi.user_cmts_iterator_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, p) -> bool""" + """ + __ne__(self, p) -> bool + """ return _idaapi.user_cmts_iterator_t___ne__(self, *args) - def __init__(self, *args): - """__init__(self) -> user_cmts_iterator_t""" + def __init__(self, *args): + """ + __init__(self) -> user_cmts_iterator_t + """ this = _idaapi.new_user_cmts_iterator_t(*args) try: self.this.append(this) except: self.this = this @@ -35569,67 +40245,99 @@ user_cmts_iterator_t_swigregister(user_cmts_iterator_t) def user_cmts_begin(*args): - """user_cmts_begin(map) -> user_cmts_iterator_t""" + """ + user_cmts_begin(map) -> user_cmts_iterator_t + """ return _idaapi.user_cmts_begin(*args) def user_cmts_end(*args): - """user_cmts_end(map) -> user_cmts_iterator_t""" + """ + user_cmts_end(map) -> user_cmts_iterator_t + """ return _idaapi.user_cmts_end(*args) def user_cmts_next(*args): - """user_cmts_next(p) -> user_cmts_iterator_t""" + """ + user_cmts_next(p) -> user_cmts_iterator_t + """ return _idaapi.user_cmts_next(*args) def user_cmts_prev(*args): - """user_cmts_prev(p) -> user_cmts_iterator_t""" + """ + user_cmts_prev(p) -> user_cmts_iterator_t + """ return _idaapi.user_cmts_prev(*args) def user_cmts_first(*args): - """user_cmts_first(p) -> treeloc_t""" + """ + user_cmts_first(p) -> treeloc_t + """ return _idaapi.user_cmts_first(*args) def user_cmts_second(*args): - """user_cmts_second(p) -> citem_cmt_t""" + """ + user_cmts_second(p) -> citem_cmt_t + """ return _idaapi.user_cmts_second(*args) def user_cmts_find(*args): - """user_cmts_find(map, key) -> user_cmts_iterator_t""" + """ + user_cmts_find(map, key) -> user_cmts_iterator_t + """ return _idaapi.user_cmts_find(*args) def user_cmts_insert(*args): - """user_cmts_insert(map, key, val) -> user_cmts_iterator_t""" + """ + user_cmts_insert(map, key, val) -> user_cmts_iterator_t + """ return _idaapi.user_cmts_insert(*args) def user_cmts_erase(*args): - """user_cmts_erase(map, p)""" + """ + user_cmts_erase(map, p) + """ return _idaapi.user_cmts_erase(*args) def user_cmts_clear(*args): - """user_cmts_clear(map)""" + """ + user_cmts_clear(map) + """ return _idaapi.user_cmts_clear(*args) def user_cmts_size(*args): - """user_cmts_size(map) -> size_t""" + """ + user_cmts_size(map) -> size_t + """ return _idaapi.user_cmts_size(*args) def user_cmts_free(*args): - """user_cmts_free(map)""" + """ + user_cmts_free(map) + """ return _idaapi.user_cmts_free(*args) class user_iflags_iterator_t(object): - """Proxy of C++ user_iflags_iterator_t class""" + """ + Proxy of C++ user_iflags_iterator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr x = _swig_property(_idaapi.user_iflags_iterator_t_x_get, _idaapi.user_iflags_iterator_t_x_set) def __eq__(self, *args): - """__eq__(self, p) -> bool""" + """ + __eq__(self, p) -> bool + """ return _idaapi.user_iflags_iterator_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, p) -> bool""" + """ + __ne__(self, p) -> bool + """ return _idaapi.user_iflags_iterator_t___ne__(self, *args) - def __init__(self, *args): - """__init__(self) -> user_iflags_iterator_t""" + def __init__(self, *args): + """ + __init__(self) -> user_iflags_iterator_t + """ this = _idaapi.new_user_iflags_iterator_t(*args) try: self.this.append(this) except: self.this = this @@ -35640,67 +40348,99 @@ user_iflags_iterator_t_swigregister(user_iflags_iterator_t) def user_iflags_begin(*args): - """user_iflags_begin(map) -> user_iflags_iterator_t""" + """ + user_iflags_begin(map) -> user_iflags_iterator_t + """ return _idaapi.user_iflags_begin(*args) def user_iflags_end(*args): - """user_iflags_end(map) -> user_iflags_iterator_t""" + """ + user_iflags_end(map) -> user_iflags_iterator_t + """ return _idaapi.user_iflags_end(*args) def user_iflags_next(*args): - """user_iflags_next(p) -> user_iflags_iterator_t""" + """ + user_iflags_next(p) -> user_iflags_iterator_t + """ return _idaapi.user_iflags_next(*args) def user_iflags_prev(*args): - """user_iflags_prev(p) -> user_iflags_iterator_t""" + """ + user_iflags_prev(p) -> user_iflags_iterator_t + """ return _idaapi.user_iflags_prev(*args) def user_iflags_first(*args): - """user_iflags_first(p) -> citem_locator_t""" + """ + user_iflags_first(p) -> citem_locator_t + """ return _idaapi.user_iflags_first(*args) def user_iflags_second(*args): - """user_iflags_second(p) -> int32 &""" + """ + user_iflags_second(p) -> int32 & + """ return _idaapi.user_iflags_second(*args) def user_iflags_find(*args): - """user_iflags_find(map, key) -> user_iflags_iterator_t""" + """ + user_iflags_find(map, key) -> user_iflags_iterator_t + """ return _idaapi.user_iflags_find(*args) def user_iflags_insert(*args): - """user_iflags_insert(map, key, val) -> user_iflags_iterator_t""" + """ + user_iflags_insert(map, key, val) -> user_iflags_iterator_t + """ return _idaapi.user_iflags_insert(*args) def user_iflags_erase(*args): - """user_iflags_erase(map, p)""" + """ + user_iflags_erase(map, p) + """ return _idaapi.user_iflags_erase(*args) def user_iflags_clear(*args): - """user_iflags_clear(map)""" + """ + user_iflags_clear(map) + """ return _idaapi.user_iflags_clear(*args) def user_iflags_size(*args): - """user_iflags_size(map) -> size_t""" + """ + user_iflags_size(map) -> size_t + """ return _idaapi.user_iflags_size(*args) def user_iflags_free(*args): - """user_iflags_free(map)""" + """ + user_iflags_free(map) + """ return _idaapi.user_iflags_free(*args) class user_unions_iterator_t(object): - """Proxy of C++ user_unions_iterator_t class""" + """ + Proxy of C++ user_unions_iterator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr x = _swig_property(_idaapi.user_unions_iterator_t_x_get, _idaapi.user_unions_iterator_t_x_set) def __eq__(self, *args): - """__eq__(self, p) -> bool""" + """ + __eq__(self, p) -> bool + """ return _idaapi.user_unions_iterator_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, p) -> bool""" + """ + __ne__(self, p) -> bool + """ return _idaapi.user_unions_iterator_t___ne__(self, *args) - def __init__(self, *args): - """__init__(self) -> user_unions_iterator_t""" + def __init__(self, *args): + """ + __init__(self) -> user_unions_iterator_t + """ this = _idaapi.new_user_unions_iterator_t(*args) try: self.this.append(this) except: self.this = this @@ -35711,67 +40451,99 @@ user_unions_iterator_t_swigregister(user_unions_iterator_t) def user_unions_begin(*args): - """user_unions_begin(map) -> user_unions_iterator_t""" + """ + user_unions_begin(map) -> user_unions_iterator_t + """ return _idaapi.user_unions_begin(*args) def user_unions_end(*args): - """user_unions_end(map) -> user_unions_iterator_t""" + """ + user_unions_end(map) -> user_unions_iterator_t + """ return _idaapi.user_unions_end(*args) def user_unions_next(*args): - """user_unions_next(p) -> user_unions_iterator_t""" + """ + user_unions_next(p) -> user_unions_iterator_t + """ return _idaapi.user_unions_next(*args) def user_unions_prev(*args): - """user_unions_prev(p) -> user_unions_iterator_t""" + """ + user_unions_prev(p) -> user_unions_iterator_t + """ return _idaapi.user_unions_prev(*args) def user_unions_first(*args): - """user_unions_first(p) -> ea_t const &""" + """ + user_unions_first(p) -> ea_t const & + """ return _idaapi.user_unions_first(*args) def user_unions_second(*args): - """user_unions_second(p) -> intvec_t""" + """ + user_unions_second(p) -> intvec_t + """ return _idaapi.user_unions_second(*args) def user_unions_find(*args): - """user_unions_find(map, key) -> user_unions_iterator_t""" + """ + user_unions_find(map, key) -> user_unions_iterator_t + """ return _idaapi.user_unions_find(*args) def user_unions_insert(*args): - """user_unions_insert(map, key, val) -> user_unions_iterator_t""" + """ + user_unions_insert(map, key, val) -> user_unions_iterator_t + """ return _idaapi.user_unions_insert(*args) def user_unions_erase(*args): - """user_unions_erase(map, p)""" + """ + user_unions_erase(map, p) + """ return _idaapi.user_unions_erase(*args) def user_unions_clear(*args): - """user_unions_clear(map)""" + """ + user_unions_clear(map) + """ return _idaapi.user_unions_clear(*args) def user_unions_size(*args): - """user_unions_size(map) -> size_t""" + """ + user_unions_size(map) -> size_t + """ return _idaapi.user_unions_size(*args) def user_unions_free(*args): - """user_unions_free(map)""" + """ + user_unions_free(map) + """ return _idaapi.user_unions_free(*args) class user_labels_iterator_t(object): - """Proxy of C++ user_labels_iterator_t class""" + """ + Proxy of C++ user_labels_iterator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr x = _swig_property(_idaapi.user_labels_iterator_t_x_get, _idaapi.user_labels_iterator_t_x_set) def __eq__(self, *args): - """__eq__(self, p) -> bool""" + """ + __eq__(self, p) -> bool + """ return _idaapi.user_labels_iterator_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, p) -> bool""" + """ + __ne__(self, p) -> bool + """ return _idaapi.user_labels_iterator_t___ne__(self, *args) - def __init__(self, *args): - """__init__(self) -> user_labels_iterator_t""" + def __init__(self, *args): + """ + __init__(self) -> user_labels_iterator_t + """ this = _idaapi.new_user_labels_iterator_t(*args) try: self.this.append(this) except: self.this = this @@ -35782,67 +40554,99 @@ user_labels_iterator_t_swigregister(user_labels_iterator_t) def user_labels_begin(*args): - """user_labels_begin(map) -> user_labels_iterator_t""" + """ + user_labels_begin(map) -> user_labels_iterator_t + """ return _idaapi.user_labels_begin(*args) def user_labels_end(*args): - """user_labels_end(map) -> user_labels_iterator_t""" + """ + user_labels_end(map) -> user_labels_iterator_t + """ return _idaapi.user_labels_end(*args) def user_labels_next(*args): - """user_labels_next(p) -> user_labels_iterator_t""" + """ + user_labels_next(p) -> user_labels_iterator_t + """ return _idaapi.user_labels_next(*args) def user_labels_prev(*args): - """user_labels_prev(p) -> user_labels_iterator_t""" + """ + user_labels_prev(p) -> user_labels_iterator_t + """ return _idaapi.user_labels_prev(*args) def user_labels_first(*args): - """user_labels_first(p) -> int const &""" + """ + user_labels_first(p) -> int const & + """ return _idaapi.user_labels_first(*args) def user_labels_second(*args): - """user_labels_second(p) -> qstring &""" + """ + user_labels_second(p) -> qstring & + """ return _idaapi.user_labels_second(*args) def user_labels_find(*args): - """user_labels_find(map, key) -> user_labels_iterator_t""" + """ + user_labels_find(map, key) -> user_labels_iterator_t + """ return _idaapi.user_labels_find(*args) def user_labels_insert(*args): - """user_labels_insert(map, key, val) -> user_labels_iterator_t""" + """ + user_labels_insert(map, key, val) -> user_labels_iterator_t + """ return _idaapi.user_labels_insert(*args) def user_labels_erase(*args): - """user_labels_erase(map, p)""" + """ + user_labels_erase(map, p) + """ return _idaapi.user_labels_erase(*args) def user_labels_clear(*args): - """user_labels_clear(map)""" + """ + user_labels_clear(map) + """ return _idaapi.user_labels_clear(*args) def user_labels_size(*args): - """user_labels_size(map) -> size_t""" + """ + user_labels_size(map) -> size_t + """ return _idaapi.user_labels_size(*args) def user_labels_free(*args): - """user_labels_free(map)""" + """ + user_labels_free(map) + """ return _idaapi.user_labels_free(*args) class eamap_iterator_t(object): - """Proxy of C++ eamap_iterator_t class""" + """ + Proxy of C++ eamap_iterator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr x = _swig_property(_idaapi.eamap_iterator_t_x_get, _idaapi.eamap_iterator_t_x_set) def __eq__(self, *args): - """__eq__(self, p) -> bool""" + """ + __eq__(self, p) -> bool + """ return _idaapi.eamap_iterator_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, p) -> bool""" + """ + __ne__(self, p) -> bool + """ return _idaapi.eamap_iterator_t___ne__(self, *args) - def __init__(self, *args): - """__init__(self) -> eamap_iterator_t""" + def __init__(self, *args): + """ + __init__(self) -> eamap_iterator_t + """ this = _idaapi.new_eamap_iterator_t(*args) try: self.this.append(this) except: self.this = this @@ -35853,67 +40657,99 @@ eamap_iterator_t_swigregister(eamap_iterator_t) def eamap_begin(*args): - """eamap_begin(map) -> eamap_iterator_t""" + """ + eamap_begin(map) -> eamap_iterator_t + """ return _idaapi.eamap_begin(*args) def eamap_end(*args): - """eamap_end(map) -> eamap_iterator_t""" + """ + eamap_end(map) -> eamap_iterator_t + """ return _idaapi.eamap_end(*args) def eamap_next(*args): - """eamap_next(p) -> eamap_iterator_t""" + """ + eamap_next(p) -> eamap_iterator_t + """ return _idaapi.eamap_next(*args) def eamap_prev(*args): - """eamap_prev(p) -> eamap_iterator_t""" + """ + eamap_prev(p) -> eamap_iterator_t + """ return _idaapi.eamap_prev(*args) def eamap_first(*args): - """eamap_first(p) -> ea_t const &""" + """ + eamap_first(p) -> ea_t const & + """ return _idaapi.eamap_first(*args) def eamap_second(*args): - """eamap_second(p) -> cinsnptrvec_t""" + """ + eamap_second(p) -> cinsnptrvec_t + """ return _idaapi.eamap_second(*args) def eamap_find(*args): - """eamap_find(map, key) -> eamap_iterator_t""" + """ + eamap_find(map, key) -> eamap_iterator_t + """ return _idaapi.eamap_find(*args) def eamap_insert(*args): - """eamap_insert(map, key, val) -> eamap_iterator_t""" + """ + eamap_insert(map, key, val) -> eamap_iterator_t + """ return _idaapi.eamap_insert(*args) def eamap_erase(*args): - """eamap_erase(map, p)""" + """ + eamap_erase(map, p) + """ return _idaapi.eamap_erase(*args) def eamap_clear(*args): - """eamap_clear(map)""" + """ + eamap_clear(map) + """ return _idaapi.eamap_clear(*args) def eamap_size(*args): - """eamap_size(map) -> size_t""" + """ + eamap_size(map) -> size_t + """ return _idaapi.eamap_size(*args) def eamap_free(*args): - """eamap_free(map)""" + """ + eamap_free(map) + """ return _idaapi.eamap_free(*args) class boundaries_iterator_t(object): - """Proxy of C++ boundaries_iterator_t class""" + """ + Proxy of C++ boundaries_iterator_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr x = _swig_property(_idaapi.boundaries_iterator_t_x_get, _idaapi.boundaries_iterator_t_x_set) def __eq__(self, *args): - """__eq__(self, p) -> bool""" + """ + __eq__(self, p) -> bool + """ return _idaapi.boundaries_iterator_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, p) -> bool""" + """ + __ne__(self, p) -> bool + """ return _idaapi.boundaries_iterator_t___ne__(self, *args) - def __init__(self, *args): - """__init__(self) -> boundaries_iterator_t""" + def __init__(self, *args): + """ + __init__(self) -> boundaries_iterator_t + """ this = _idaapi.new_boundaries_iterator_t(*args) try: self.this.append(this) except: self.this = this @@ -35924,51 +40760,75 @@ boundaries_iterator_t_swigregister(boundaries_iterator_t) def boundaries_begin(*args): - """boundaries_begin(map) -> boundaries_iterator_t""" + """ + boundaries_begin(map) -> boundaries_iterator_t + """ return _idaapi.boundaries_begin(*args) def boundaries_end(*args): - """boundaries_end(map) -> boundaries_iterator_t""" + """ + boundaries_end(map) -> boundaries_iterator_t + """ return _idaapi.boundaries_end(*args) def boundaries_next(*args): - """boundaries_next(p) -> boundaries_iterator_t""" + """ + boundaries_next(p) -> boundaries_iterator_t + """ return _idaapi.boundaries_next(*args) def boundaries_prev(*args): - """boundaries_prev(p) -> boundaries_iterator_t""" + """ + boundaries_prev(p) -> boundaries_iterator_t + """ return _idaapi.boundaries_prev(*args) def boundaries_first(*args): - """boundaries_first(p) -> cinsn_t""" + """ + boundaries_first(p) -> cinsn_t + """ return _idaapi.boundaries_first(*args) def boundaries_second(*args): - """boundaries_second(p) -> areaset_t""" + """ + boundaries_second(p) -> areaset_t + """ return _idaapi.boundaries_second(*args) def boundaries_find(*args): - """boundaries_find(map, key) -> boundaries_iterator_t""" + """ + boundaries_find(map, key) -> boundaries_iterator_t + """ return _idaapi.boundaries_find(*args) def boundaries_insert(*args): - """boundaries_insert(map, key, val) -> boundaries_iterator_t""" + """ + boundaries_insert(map, key, val) -> boundaries_iterator_t + """ return _idaapi.boundaries_insert(*args) def boundaries_erase(*args): - """boundaries_erase(map, p)""" + """ + boundaries_erase(map, p) + """ return _idaapi.boundaries_erase(*args) def boundaries_clear(*args): - """boundaries_clear(map)""" + """ + boundaries_clear(map) + """ return _idaapi.boundaries_clear(*args) def boundaries_size(*args): - """boundaries_size(map) -> size_t""" + """ + boundaries_size(map) -> size_t + """ return _idaapi.boundaries_size(*args) def boundaries_free(*args): - """boundaries_free(map)""" + """ + boundaries_free(map) + """ return _idaapi.boundaries_free(*args) import idaapi @@ -35976,10 +40836,12 @@ hexrays_failure_t.__str__ = lambda self: str(self.str) # --------------------------------------------------------------------- class DecompilationFailure(Exception): - """ Raised on a decompilation error. + """ + Raised on a decompilation error. The associated hexrays_failure_t object is stored in the - 'info' member of this exception. """ + 'info' member of this exception. +""" def __init__(self, info): Exception.__init__(self, 'Decompilation failed: %s' % (str(info), )) @@ -36023,7 +40885,9 @@ _listify_types(cinsnptrvec_t, history_t) def citem_to_specific_type(self): - """ cast the citem_t object to its more specific type, either cexpr_t or cinsn_t. """ + """ + cast the citem_t object to its more specific type, either cexpr_t or cinsn_t. + """ if self.op >= cot_empty and self.op <= cot_last: return self.cexpr @@ -36033,13 +40897,17 @@ def citem_to_specific_type(self): raise RuntimeError('unknown op type %s' % (repr(self.op), )) citem_t.to_specific_type = property(citem_to_specific_type) -""" array used for translating cinsn_t->op type to their names. """ +""" + array used for translating cinsn_t->op type to their names. +""" cinsn_t.op_to_typename = {} for k in dir(_idaapi): if k.startswith('cit_'): cinsn_t.op_to_typename[getattr(_idaapi, k)] = k[4:] -""" array used for translating cexpr_t->op type to their names. """ +""" + array used for translating cexpr_t->op type to their names. +""" cexpr_t.op_to_typename = {} for k in dir(_idaapi): if k.startswith('cot_'): @@ -36051,7 +40919,9 @@ cinsn_t.opname = property(property_op_to_typename) cexpr_t.opname = property(property_op_to_typename) def cexpr_operands(self): - """ return a dictionary with the operands of a cexpr_t. """ + """ + return a dictionary with the operands of a cexpr_t. + """ if self.op >= cot_comma and self.op <= cot_asgumod or \ self.op >= cot_lor and self.op <= cot_fdiv or \ @@ -36096,8 +40966,10 @@ def cexpr_operands(self): cexpr_t.operands = property(cexpr_operands) def cinsn_details(self): - """ return the details pointer for the cinsn_t object depending on the value of its op member. \ - this is one of the cblock_t, cif_t, etc. objects. """ + """ + return the details pointer for the cinsn_t object depending on the value of its op member. \ + this is one of the cblock_t, cif_t, etc. objects. +""" if self.op not in self.op_to_typename: raise RuntimeError('unknown item->op type') @@ -36181,7 +41053,9 @@ cblock_t.insert = cblock_insert cfuncptr_t.__str__ = lambda self: str(self.__deref__()) def cfunc_type(self): - """ Get the function's return type tinfo_t object. """ + """ + Get the function's return type tinfo_t object. + """ tif = tinfo_t() result = self.get_func_type(tif) if not result: @@ -36225,7 +41099,9 @@ lvar_t.is_mapdst_var = property(lvar_t.is_mapdst_var) # dictify all dict-like types def _map___getitem__(self, key): - """ Returns the value associated with the provided key. """ + """ + Returns the value associated with the provided key. + """ if not isinstance(key, self.keytype): raise KeyError('type of key should be ' + repr(self.keytype) + ' but got ' + repr(type(key))) if key not in self: @@ -36233,7 +41109,9 @@ def _map___getitem__(self, key): return self.second(self.find(key)) def _map___setitem__(self, key, value): - """ Returns the value associated with the provided key. """ + """ + Returns the value associated with the provided key. + """ if not isinstance(key, self.keytype): raise KeyError('type of `key` should be ' + repr(self.keytype) + ' but got ' + repr(type(key))) if not isinstance(value, self.valuetype): @@ -36242,7 +41120,9 @@ def _map___setitem__(self, key, value): return def _map___delitem__(self, key): - """ Removes the value associated with the provided key. """ + """ + Removes the value associated with the provided key. + """ if not isinstance(key, self.keytype): raise KeyError('type of `key` should be ' + repr(self.keytype) + ' but got ' + repr(type(key))) if key not in self: @@ -36251,7 +41131,9 @@ def _map___delitem__(self, key): return def _map___contains__(self, key): - """ Returns true if the specified key exists in the . """ + """ + Returns true if the specified key exists in the . + """ if not isinstance(key, self.keytype): raise KeyError('type of `key` should be ' + repr(self.keytype) + ' but got ' + repr(type(key))) if self.find(key) != self.end(): @@ -36307,7 +41189,9 @@ def _map_has_key(self, key): return key in self def _map_pop(self, key): - """ Sets the value associated with the provided key. """ + """ + Sets the value associated with the provided key. + """ if not isinstance(key, self.keytype): raise KeyError('type of `key` should be ' + repr(self.keytype) + ' but got ' + repr(type(key))) if key not in self: @@ -36317,14 +41201,18 @@ def _map_pop(self, key): return ret def _map_popitem(self): - """ Sets the value associated with the provided key. """ + """ + Sets the value associated with the provided key. + """ if len(self) == 0: raise KeyError('key not found') key = self.keys()[0] return (key, self.pop(key)) def _map_setdefault(self, key, default=None): - """ Sets the value associated with the provided key. """ + """ + Sets the value associated with the provided key. + """ if not isinstance(key, self.keytype): raise KeyError('type of `key` should be ' + repr(self.keytype) + ' but got ' + repr(type(key))) if key in self: @@ -36378,93 +41266,167 @@ _map_as_dict(user_cmts_t, 'user_cmts', treeloc_t, citem_cmt_t) _map_as_dict(user_numforms_t, 'user_numforms', operand_locator_t, number_format_t) _map_as_dict(user_iflags_t, 'user_iflags', citem_locator_t, (int, long)) _map_as_dict(user_unions_t, 'user_unions', (int, long), intvec_t) -_map_as_dict(eamap_t, 'eamap', long, cinsnptrvec_t) +_map_as_dict(eamap_t, 'eamap', int, cinsnptrvec_t) #_map_as_dict(boundaries_t, 'boundaries', cinsn_t, areaset_t) def qstrvec_t_create(*args): - """qstrvec_t_create() -> PyObject *""" + """ + qstrvec_t_create() -> PyObject * + """ return _idaapi.qstrvec_t_create(*args) def qstrvec_t_destroy(*args): - """qstrvec_t_destroy(py_obj) -> bool""" + """ + qstrvec_t_destroy(py_obj) -> bool + """ return _idaapi.qstrvec_t_destroy(*args) def qstrvec_t_get_clink(*args): - """qstrvec_t_get_clink(self) -> qstrvec_t *""" + """ + qstrvec_t_get_clink(self) -> qstrvec_t * + """ return _idaapi.qstrvec_t_get_clink(*args) def qstrvec_t_get_clink_ptr(*args): - """qstrvec_t_get_clink_ptr(self) -> PyObject *""" + """ + qstrvec_t_get_clink_ptr(self) -> PyObject * + """ return _idaapi.qstrvec_t_get_clink_ptr(*args) def parse_command_line3(*args): - """parse_command_line3(cmdline) -> PyObject *""" + """ + parse_command_line3(cmdline) -> PyObject * + """ return _idaapi.parse_command_line3(*args) def get_inf_structure(*args): - """get_inf_structure() -> idainfo""" + """ + get_inf_structure() -> idainfo + + + Returns the global variable 'inf' (an instance of idainfo structure, see ida.hpp) + """ return _idaapi.get_inf_structure(*args) def set_script_timeout(*args): - """set_script_timeout(timeout) -> int""" + """ + set_script_timeout(timeout) -> int + + + Changes the script timeout value. The script wait box dialog will be hidden and shown again when the timeout elapses. + See also L{disable_script_timeout}. + + @param timeout: This value is in seconds. + If this value is set to zero then the script will never timeout. + @return: Returns the old timeout value + """ return _idaapi.set_script_timeout(*args) def disable_script_timeout(*args): - """disable_script_timeout()""" + """ + disable_script_timeout() + + + Disables the script timeout and hides the script wait box. + Calling L{set_script_timeout} will not have any effects until the script is compiled and executed again + + @return: None + """ return _idaapi.disable_script_timeout(*args) def enable_extlang_python(*args): - """enable_extlang_python(enable)""" + """ + enable_extlang_python(enable) + + + Enables or disables Python extlang. + When enabled, all expressions will be evaluated by Python. + @param enable: Set to True to enable, False otherwise + """ return _idaapi.enable_extlang_python(*args) def enable_python_cli(*args): - """enable_python_cli(enable)""" + """ + enable_python_cli(enable) + """ return _idaapi.enable_python_cli(*args) def qstrvec_t_assign(*args): - """qstrvec_t_assign(self, other) -> bool""" + """ + qstrvec_t_assign(self, other) -> bool + """ return _idaapi.qstrvec_t_assign(*args) def qstrvec_t_addressof(*args): - """qstrvec_t_addressof(self, idx) -> PyObject *""" + """ + qstrvec_t_addressof(self, idx) -> PyObject * + """ return _idaapi.qstrvec_t_addressof(*args) def qstrvec_t_set(*args): - """qstrvec_t_set(self, idx, s) -> bool""" + """ + qstrvec_t_set(self, idx, s) -> bool + """ return _idaapi.qstrvec_t_set(*args) def qstrvec_t_from_list(*args): - """qstrvec_t_from_list(self, py_list) -> bool""" + """ + qstrvec_t_from_list(self, py_list) -> bool + """ return _idaapi.qstrvec_t_from_list(*args) def qstrvec_t_size(*args): - """qstrvec_t_size(self) -> size_t""" + """ + qstrvec_t_size(self) -> size_t + """ return _idaapi.qstrvec_t_size(*args) def qstrvec_t_get(*args): - """qstrvec_t_get(self, idx) -> PyObject *""" + """ + qstrvec_t_get(self, idx) -> PyObject * + """ return _idaapi.qstrvec_t_get(*args) def qstrvec_t_add(*args): - """qstrvec_t_add(self, s) -> bool""" + """ + qstrvec_t_add(self, s) -> bool + """ return _idaapi.qstrvec_t_add(*args) def qstrvec_t_clear(*args): - """qstrvec_t_clear(self, qclear) -> bool""" + """ + qstrvec_t_clear(self, qclear) -> bool + """ return _idaapi.qstrvec_t_clear(*args) def qstrvec_t_insert(*args): - """qstrvec_t_insert(self, idx, s) -> bool""" + """ + qstrvec_t_insert(self, idx, s) -> bool + """ return _idaapi.qstrvec_t_insert(*args) def qstrvec_t_remove(*args): - """qstrvec_t_remove(self, idx) -> bool""" + """ + qstrvec_t_remove(self, idx) -> bool + """ return _idaapi.qstrvec_t_remove(*args) def notify_when(*args): - """notify_when(when, py_callable) -> bool""" + """ + notify_when(when, py_callable) -> bool + + + Register a callback that will be called when an event happens. + @param when: one of NW_XXXX constants + @param callback: This callback prototype varies depending on the 'when' parameter: + The general callback format: + def notify_when_callback(nw_code) + In the case of NW_OPENIDB: + def notify_when_callback(nw_code, is_old_database) + @return: Boolean + """ return _idaapi.notify_when(*args) fcb_normal = _idaapi.fcb_normal fcb_indjump = _idaapi.fcb_indjump @@ -36475,24 +41437,34 @@ fcb_enoret = _idaapi.fcb_enoret fcb_extern = _idaapi.fcb_extern fcb_error = _idaapi.fcb_error class node_iterator(object): - """Proxy of C++ node_iterator class""" + """ + Proxy of C++ node_iterator class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, _g, n) -> node_iterator""" + def __init__(self, *args): + """ + __init__(self, _g, n) -> node_iterator + """ this = _idaapi.new_node_iterator(*args) try: self.this.append(this) except: self.this = this def __eq__(self, *args): - """__eq__(self, n) -> bool""" + """ + __eq__(self, n) -> bool + """ return _idaapi.node_iterator___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, n) -> bool""" + """ + __ne__(self, n) -> bool + """ return _idaapi.node_iterator___ne__(self, *args) def __ref__(self, *args): - """__ref__(self) -> int""" + """ + __ref__(self) -> int + """ return _idaapi.node_iterator___ref__(self, *args) __swig_destroy__ = _idaapi.delete_node_iterator @@ -36502,15 +41474,21 @@ node_iterator_swigregister(node_iterator) def gen_gdl(*args): - """gen_gdl(g, fname)""" + """ + gen_gdl(g, fname) + """ return _idaapi.gen_gdl(*args) def display_gdl(*args): - """display_gdl(fname) -> int""" + """ + display_gdl(fname) -> int + """ return _idaapi.display_gdl(*args) def gen_flow_graph(*args): - """gen_flow_graph(filename, title, pfn, ea1, ea2, gflags) -> bool""" + """ + gen_flow_graph(filename, title, pfn, ea1, ea2, gflags) -> bool + """ return _idaapi.gen_flow_graph(*args) CHART_PRINT_NAMES = _idaapi.CHART_PRINT_NAMES CHART_GEN_DOT = _idaapi.CHART_GEN_DOT @@ -36518,13 +41496,17 @@ CHART_GEN_GDL = _idaapi.CHART_GEN_GDL CHART_WINGRAPH = _idaapi.CHART_WINGRAPH def gen_simple_call_chart(*args): - """gen_simple_call_chart(filename, wait, title, gflags) -> bool""" + """ + gen_simple_call_chart(filename, wait, title, gflags) -> bool + """ return _idaapi.gen_simple_call_chart(*args) +CHART_NOLIBFUNCS = _idaapi.CHART_NOLIBFUNCS def gen_complex_call_chart(*args): - """gen_complex_call_chart(filename, wait, title, ea1, ea2, flags, recursion_depth=-1) -> bool""" + """ + gen_complex_call_chart(filename, wait, title, ea1, ea2, flags, recursion_depth=-1) -> bool + """ return _idaapi.gen_complex_call_chart(*args) -CHART_NOLIBFUNCS = _idaapi.CHART_NOLIBFUNCS CHART_REFERENCING = _idaapi.CHART_REFERENCING CHART_REFERENCED = _idaapi.CHART_REFERENCED CHART_RECURSIVE = _idaapi.CHART_RECURSIVE @@ -36536,11 +41518,15 @@ CHART_IGNORE_LIB_FROM = _idaapi.CHART_IGNORE_LIB_FROM CHART_PRINT_COMMENTS = _idaapi.CHART_PRINT_COMMENTS CHART_PRINT_DOTS = _idaapi.CHART_PRINT_DOTS class qbasic_block_t(area_t): - """Proxy of C++ qbasic_block_t class""" + """ + Proxy of C++ qbasic_block_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> qbasic_block_t""" + def __init__(self, *args): + """ + __init__(self) -> qbasic_block_t + """ this = _idaapi.new_qbasic_block_t(*args) try: self.this.append(this) except: self.this = this @@ -36551,14 +41537,20 @@ qbasic_block_t_swigregister(qbasic_block_t) def is_noret_block(*args): - """is_noret_block(btype) -> bool""" + """ + is_noret_block(btype) -> bool + """ return _idaapi.is_noret_block(*args) def is_ret_block(*args): - """is_ret_block(btype) -> bool""" + """ + is_ret_block(btype) -> bool + """ return _idaapi.is_ret_block(*args) class qflow_chart_t(object): - """Proxy of C++ qflow_chart_t class""" + """ + Proxy of C++ qflow_chart_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr title = _swig_property(_idaapi.qflow_chart_t_title_get, _idaapi.qflow_chart_t_title_set) @@ -36566,7 +41558,7 @@ class qflow_chart_t(object): pfn = _swig_property(_idaapi.qflow_chart_t_pfn_get, _idaapi.qflow_chart_t_pfn_set) flags = _swig_property(_idaapi.qflow_chart_t_flags_get, _idaapi.qflow_chart_t_flags_set) nproper = _swig_property(_idaapi.qflow_chart_t_nproper_get, _idaapi.qflow_chart_t_nproper_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> qflow_chart_t __init__(self, _title, _pfn, _ea1, _ea2, _flags) -> qflow_chart_t @@ -36582,59 +41574,87 @@ class qflow_chart_t(object): return _idaapi.qflow_chart_t_create(self, *args) def append_to_flowchart(self, *args): - """append_to_flowchart(self, ea1, ea2)""" + """ + append_to_flowchart(self, ea1, ea2) + """ return _idaapi.qflow_chart_t_append_to_flowchart(self, *args) def refresh(self, *args): - """refresh(self)""" + """ + refresh(self) + """ return _idaapi.qflow_chart_t_refresh(self, *args) def calc_block_type(self, *args): - """calc_block_type(self, blknum) -> fc_block_type_t""" + """ + calc_block_type(self, blknum) -> fc_block_type_t + """ return _idaapi.qflow_chart_t_calc_block_type(self, *args) def is_ret_block(self, *args): - """is_ret_block(self, blknum) -> bool""" + """ + is_ret_block(self, blknum) -> bool + """ return _idaapi.qflow_chart_t_is_ret_block(self, *args) def is_noret_block(self, *args): - """is_noret_block(self, blknum) -> bool""" + """ + is_noret_block(self, blknum) -> bool + """ return _idaapi.qflow_chart_t_is_noret_block(self, *args) def print_node_attributes(self, *args): - """print_node_attributes(self, arg2, arg3)""" + """ + print_node_attributes(self, arg2, arg3) + """ return _idaapi.qflow_chart_t_print_node_attributes(self, *args) def nsucc(self, *args): - """nsucc(self, node) -> int""" + """ + nsucc(self, node) -> int + """ return _idaapi.qflow_chart_t_nsucc(self, *args) def npred(self, *args): - """npred(self, node) -> int""" + """ + npred(self, node) -> int + """ return _idaapi.qflow_chart_t_npred(self, *args) def succ(self, *args): - """succ(self, node, i) -> int""" + """ + succ(self, node, i) -> int + """ return _idaapi.qflow_chart_t_succ(self, *args) def pred(self, *args): - """pred(self, node, i) -> int""" + """ + pred(self, node, i) -> int + """ return _idaapi.qflow_chart_t_pred(self, *args) def print_names(self, *args): - """print_names(self) -> bool""" + """ + print_names(self) -> bool + """ return _idaapi.qflow_chart_t_print_names(self, *args) def get_node_label(self, *args): - """get_node_label(self, arg2, arg3, arg4) -> char *""" + """ + get_node_label(self, arg2, arg3, arg4) -> char * + """ return _idaapi.qflow_chart_t_get_node_label(self, *args) def size(self, *args): - """size(self) -> int""" + """ + size(self) -> int + """ return _idaapi.qflow_chart_t_size(self, *args) def __getitem__(self, *args): - """__getitem__(self, n) -> qbasic_block_t""" + """ + __getitem__(self, n) -> qbasic_block_t + """ return _idaapi.qflow_chart_t___getitem__(self, *args) __swig_destroy__ = _idaapi.delete_qflow_chart_t @@ -36649,36 +41669,52 @@ FC_CHKBREAK = _idaapi.FC_CHKBREAK def display_flow_graph(*args): - """display_flow_graph(title, pfn, ea1, ea2, print_names) -> bool""" + """ + display_flow_graph(title, pfn, ea1, ea2, print_names) -> bool + """ return _idaapi.display_flow_graph(*args) def display_simple_call_chart(*args): - """display_simple_call_chart(wait, title, ignore_libfuncs) -> bool""" + """ + display_simple_call_chart(wait, title, ignore_libfuncs) -> bool + """ return _idaapi.display_simple_call_chart(*args) def display_complex_call_chart(*args): - """display_complex_call_chart(wait, title, ea1, ea2, flags, recursion_depth=-1) -> bool""" + """ + display_complex_call_chart(wait, title, ea1, ea2, flags, recursion_depth=-1) -> bool + """ return _idaapi.display_complex_call_chart(*args) # # ----------------------------------------------------------------------- class BasicBlock(object): - """Basic block class. It is returned by the Flowchart class""" + """ + Basic block class. It is returned by the Flowchart class + """ def __init__(self, id, bb, fc): self._fc = fc self.id = id - """Basic block ID""" + """ + Basic block ID + """ self.startEA = bb.startEA - """startEA of basic block""" + """ + startEA of basic block + """ self.endEA = bb.endEA - """endEA of basic block""" + """ + endEA of basic block + """ self.type = self._fc._q.calc_block_type(self.id) - """Block type (check fc_block_type_t enum)""" + """ + Block type (check fc_block_type_t enum) + """ + - def preds(self): """ Iterates the predecessors list @@ -36687,7 +41723,7 @@ class BasicBlock(object): for i in xrange(0, self._fc._q.npred(self.id)): yield self._fc[q.pred(self.id, i)] - + def succs(self): """ Iterates the successors list @@ -36711,30 +41747,34 @@ class FlowChart(object): """ if (f is None) and (bounds is None or type(bounds) != types.TupleType): raise Exception("Please specifiy either a function or start/end pair") - + if bounds is None: bounds = (BADADDR, BADADDR) - + # Create the flowchart self._q = qflow_chart_t("", f, bounds[0], bounds[1], flags) - + size = property(lambda self: self._q.size()) - """Number of blocks in the flow chart""" - + """ + Number of blocks in the flow chart + """ + def refresh(): - """Refreshes the flow chart""" + """ + Refreshes the flow chart + """ self._q.refresh() def _getitem(self, index): - return BasicBlock(index, self._q[index], self) - - + return BasicBlock(index, self._q[index], self) + + def __iter__(self): return (self._getitem(index) for index in xrange(0, self.size)) - - + + def __getitem__(self, index): """ Returns a basic block @@ -36743,167 +41783,372 @@ class FlowChart(object): """ if index >= self.size: raise KeyError - else: + else: return self._getitem(index) # +def msg(*args): + """ + msg(format) -> int + """ + return _idaapi.msg(*args) + +def warning(*args): + """ + warning(format) + """ + return _idaapi.warning(*args) + +def error(*args): + """ + error(format) + """ + return _idaapi.error(*args) + def refresh_lists(*args): - """refresh_lists()""" + """ + refresh_lists() + """ return _idaapi.refresh_lists(*args) def textctrl_info_t_create(*args): - """textctrl_info_t_create() -> PyObject *""" + """ + textctrl_info_t_create() -> PyObject * + """ return _idaapi.textctrl_info_t_create(*args) def textctrl_info_t_destroy(*args): - """textctrl_info_t_destroy(py_obj) -> bool""" + """ + textctrl_info_t_destroy(py_obj) -> bool + """ return _idaapi.textctrl_info_t_destroy(*args) def textctrl_info_t_get_clink(*args): - """textctrl_info_t_get_clink(self) -> textctrl_info_t *""" + """ + textctrl_info_t_get_clink(self) -> textctrl_info_t * + """ return _idaapi.textctrl_info_t_get_clink(*args) def textctrl_info_t_get_clink_ptr(*args): - """textctrl_info_t_get_clink_ptr(self) -> PyObject *""" + """ + textctrl_info_t_get_clink_ptr(self) -> PyObject * + """ return _idaapi.textctrl_info_t_get_clink_ptr(*args) def register_timer(*args): - """register_timer(interval, py_callback) -> PyObject *""" + """ + register_timer(interval, py_callback) -> PyObject * + + + Register a timer + + @param interval: Interval in milliseconds + @param callback: A Python callable that takes no parameters and returns an integer. + The callback may return: + -1 : to unregister the timer + >= 0 : the new or same timer interval + @return: None or a timer object + """ return _idaapi.register_timer(*args) def unregister_timer(*args): - """unregister_timer(py_timerctx) -> PyObject *""" + """ + unregister_timer(py_timerctx) -> PyObject * + + + Unregister a timer + + @param timer_obj: a timer object previously returned by a register_timer() + @return: Boolean + @note: After the timer has been deleted, the timer_obj will become invalid. + """ return _idaapi.unregister_timer(*args) def choose_idasgn(*args): - """choose_idasgn() -> PyObject *""" + """ + choose_idasgn() -> PyObject * + + + Opens the signature chooser + + @return: None or the selected signature name + """ return _idaapi.choose_idasgn(*args) def get_highlighted_identifier(*args): - """get_highlighted_identifier(flags=0) -> PyObject *""" + """ + get_highlighted_identifier(flags=0) -> PyObject * + + + Returns the currently highlighted identifier + + @param flags: reserved (pass 0) + @return: None or the highlighted identifier + """ return _idaapi.get_highlighted_identifier(*args) def py_load_custom_icon_fn(*args): - """py_load_custom_icon_fn(filename) -> int""" + """ + py_load_custom_icon_fn(filename) -> int + """ return _idaapi.py_load_custom_icon_fn(*args) def py_load_custom_icon_data(*args): - """py_load_custom_icon_data(data, format) -> int""" + """ + py_load_custom_icon_data(data, format) -> int + """ return _idaapi.py_load_custom_icon_data(*args) -def umsg(*args): - """umsg(o) -> PyObject *""" - return _idaapi.umsg(*args) - -def msg(*args): - """msg(o) -> PyObject *""" - return _idaapi.msg(*args) - def asktext(*args): - """asktext(max_text, defval, prompt) -> PyObject *""" + """ + asktext(max_text, defval, prompt) -> PyObject * + + + Asks for a long text + + @param max_text: Maximum text length + @param defval: The default value + @param prompt: The prompt value + @return: None or the entered string + """ return _idaapi.asktext(*args) def str2ea(*args): - """str2ea(str, screenEA=BADADDR) -> ea_t""" + """ + str2ea(str, screenEA=BADADDR) -> ea_t + + + Converts a string express to EA. The expression evaluator may be called as well. + + @return: BADADDR or address value + """ return _idaapi.str2ea(*args) def str2user(*args): - """str2user(str) -> PyObject *""" + """ + str2user(str) -> PyObject * + + + Insert C-style escape characters to string + + @return: new string with escape characters inserted + """ return _idaapi.str2user(*args) def process_ui_action(*args): - """process_ui_action(name, flags=0) -> bool""" + """ + process_ui_action(name, flags) -> bool + + + Invokes an IDA UI action by name + + @param name: action name + @param flags: Reserved. Must be zero + @return: Boolean + """ return _idaapi.process_ui_action(*args) def del_menu_item(*args): - """del_menu_item(py_ctx) -> bool""" + """ + del_menu_item(py_ctx) -> bool + + + Deletes a menu item previously added with add_menu_item() + + @param menu_ctx: value returned by add_menu_item() + @return: Boolean + """ return _idaapi.del_menu_item(*args) def del_hotkey(*args): - """del_hotkey(pyctx) -> bool""" + """ + del_hotkey(pyctx) -> bool + + + Deletes a previously registered function hotkey + + @param ctx: Hotkey context previously returned by add_hotkey() + + @return: Boolean. + """ return _idaapi.del_hotkey(*args) def add_hotkey(*args): - """add_hotkey(hotkey, pyfunc) -> PyObject *""" + """ + add_hotkey(hotkey, pyfunc) -> PyObject * + + + Associates a function call with a hotkey. + Callable pyfunc will be called each time the hotkey is pressed + + @param hotkey: The hotkey + @param pyfunc: Callable + + @return: Context object on success or None on failure. + """ return _idaapi.add_hotkey(*args) def py_menu_item_callback(*args): - """py_menu_item_callback(userdata) -> bool""" + """ + py_menu_item_callback(userdata) -> bool + """ return _idaapi.py_menu_item_callback(*args) def add_menu_item(*args): - """add_menu_item(menupath, name, hotkey, flags, pyfunc, args) -> PyObject *""" + """ + add_menu_item(menupath, name, hotkey, flags, pyfunc, args) -> PyObject * + + + Adds a menu item + + @param menupath: path to the menu item after or before which the insertion will take place + @param name: name of the menu item (~x~ is used to denote Alt-x hot letter) + @param hotkey: hotkey for the menu item (may be empty) + @param flags: one of SETMENU_... consts + @param callback: function which gets called when the user selects the menu item. + The function callback is of the form: + def callback(*args): + pass + @param args: tuple containing the arguments + + @return: None or a menu context (to be used by del_menu_item()) + """ return _idaapi.add_menu_item(*args) def execute_sync(*args): - """execute_sync(py_callable, reqf) -> int""" + """ + execute_sync(py_callable, reqf) -> int + + + Executes a function in the context of the main thread. + If the current thread not the main thread, then the call is queued and + executed afterwards. + + @note: The Python version of execute_sync() cannot be called from a different thread + for the time being. + @param callable: A python callable object + @param reqf: one of MFF_ flags + @return: -1 or the return value of the callable + """ return _idaapi.execute_sync(*args) def execute_ui_requests(*args): - """execute_ui_requests(py_list) -> bool""" + """ + execute_ui_requests(py_list) -> bool + + + Inserts a list of callables into the UI message processing queue. + When the UI is ready it will call one callable. + A callable can request to be called more than once if it returns True. + + @param callable_list: A list of python callable objects. + @note: A callable should return True if it wants to be called more than once. + @return: Boolean. False if the list contains a non callabale item + """ return _idaapi.execute_ui_requests(*args) class UI_Hooks(object): - """Proxy of C++ UI_Hooks class""" + """ + Proxy of C++ UI_Hooks class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr __swig_destroy__ = _idaapi.delete_UI_Hooks __del__ = lambda self : None; def hook(self, *args): - """hook(self) -> bool""" + """ + hook(self) -> bool + + + Creates an UI hook + + @return: Boolean true on success + """ return _idaapi.UI_Hooks_hook(self, *args) def unhook(self, *args): - """unhook(self) -> bool""" + """ + unhook(self) -> bool + + + Removes the UI hook + @return: Boolean true on success + """ return _idaapi.UI_Hooks_unhook(self, *args) def preprocess(self, *args): - """preprocess(self, arg0) -> int""" + """ + preprocess(self, arg0) -> int + + + IDA ui is about to handle a user command + + @param name: ui command name + (these names can be looked up in ida[tg]ui.cfg) + @return: 0-ok, nonzero - a plugin has handled the command + """ return _idaapi.UI_Hooks_preprocess(self, *args) def postprocess(self, *args): - """postprocess(self)""" + """ + postprocess(self) + + + An ida ui command has been handled + + @return: Ignored + """ return _idaapi.UI_Hooks_postprocess(self, *args) def saving(self, *args): - """saving(self)""" + """ + saving(self) + + + The kernel is saving the database. + + @return: Ignored + """ return _idaapi.UI_Hooks_saving(self, *args) def saved(self, *args): - """saved(self)""" + """ + saved(self) + + + The kernel has saved the database. + + @return: Ignored + """ return _idaapi.UI_Hooks_saved(self, *args) def term(self, *args): - """term(self)""" + """ + term(self) + + + IDA is terminated and the database is already closed. + The UI may close its windows in this callback. + """ return _idaapi.UI_Hooks_term(self, *args) def get_ea_hint(self, *args): - """get_ea_hint(self, arg0) -> PyObject *""" + """ + get_ea_hint(self, arg0) -> PyObject * + + + The UI wants to display a simple hint for an address in the navigation band + + @param ea: The address + @return: String with the hint or None + """ return _idaapi.UI_Hooks_get_ea_hint(self, *args) - def current_tform_changed(self, *args): - """current_tform_changed(self, arg0, arg1)""" - return _idaapi.UI_Hooks_current_tform_changed(self, *args) - - def updating_actions(self, *args): - """updating_actions(self, ctx)""" - return _idaapi.UI_Hooks_updating_actions(self, *args) - - def updated_actions(self, *args): - """updated_actions(self)""" - return _idaapi.UI_Hooks_updated_actions(self, *args) - - def populating_tform_popup(self, *args): - """populating_tform_popup(self, arg0, arg1)""" - return _idaapi.UI_Hooks_populating_tform_popup(self, *args) - - def finish_populating_tform_popup(self, *args): - """finish_populating_tform_popup(self, arg0, arg1)""" - return _idaapi.UI_Hooks_finish_populating_tform_popup(self, *args) - - def __init__(self, *args): - """__init__(self) -> UI_Hooks""" + def __init__(self, *args): + """ + __init__(self) -> UI_Hooks + """ if self.__class__ == UI_Hooks: _self = None else: @@ -36919,291 +42164,335 @@ UI_Hooks_swigregister = _idaapi.UI_Hooks_swigregister UI_Hooks_swigregister(UI_Hooks) -def register_action(*args): - """register_action(desc) -> bool""" - return _idaapi.register_action(*args) - -def unregister_action(*args): - """unregister_action(name) -> bool""" - return _idaapi.unregister_action(*args) - -def attach_dynamic_action_to_popup(*args): - """attach_dynamic_action_to_popup(form, popup_handle, desc, popuppath=None, flags=0) -> bool""" - return _idaapi.attach_dynamic_action_to_popup(*args) -class disasm_line_t(object): - """Proxy of C++ disasm_line_t class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - __swig_destroy__ = _idaapi.delete_disasm_line_t - __del__ = lambda self : None; - def __init__(self, *args): - """ - __init__(self) -> disasm_line_t - __init__(self, other) -> disasm_line_t - """ - this = _idaapi.new_disasm_line_t(*args) - try: self.this.append(this) - except: self.this = this - at = _swig_property(_idaapi.disasm_line_t_at_get, _idaapi.disasm_line_t_at_set) - line = _swig_property(_idaapi.disasm_line_t_line_get, _idaapi.disasm_line_t_line_set) - prefix_color = _swig_property(_idaapi.disasm_line_t_prefix_color_get, _idaapi.disasm_line_t_prefix_color_set) - bg_color = _swig_property(_idaapi.disasm_line_t_bg_color_get, _idaapi.disasm_line_t_bg_color_set) - is_default = _swig_property(_idaapi.disasm_line_t_is_default_get, _idaapi.disasm_line_t_is_default_set) -disasm_line_t_swigregister = _idaapi.disasm_line_t_swigregister -disasm_line_t_swigregister(disasm_line_t) - - -def gen_disasm_text(*args): - """gen_disasm_text(ea1, ea2, text, truncate_lines)""" - return _idaapi.gen_disasm_text(*args) - -def set_nav_colorizer(*args): - """set_nav_colorizer(new_py_colorizer) -> nav_colorizer_t *""" - return _idaapi.set_nav_colorizer(*args) - -def call_nav_colorizer(*args): - """call_nav_colorizer(col, ea, nbytes) -> uint32""" - return _idaapi.call_nav_colorizer(*args) - def choose_sizer(*args): - """choose_sizer(self) -> uint32""" + """ + choose_sizer(self) -> uint32 + """ return _idaapi.choose_sizer(*args) def choose_getl(*args): - """choose_getl(self, n, buf) -> char *""" + """ + choose_getl(self, n, buf) -> char * + """ return _idaapi.choose_getl(*args) def choose_enter(*args): - """choose_enter(self, n)""" + """ + choose_enter(self, n) + """ return _idaapi.choose_enter(*args) def choose2_find(*args): - """choose2_find(title) -> PyObject *""" + """ + choose2_find(title) -> PyObject * + """ return _idaapi.choose2_find(*args) def choose2_add_command(*args): - """choose2_add_command(self, caption, flags, menu_index, icon) -> int""" + """ + choose2_add_command(self, caption, flags, menu_index, icon) -> int + """ return _idaapi.choose2_add_command(*args) def choose2_refresh(*args): - """choose2_refresh(self)""" + """ + choose2_refresh(self) + """ return _idaapi.choose2_refresh(*args) def choose2_close(*args): - """choose2_close(self)""" + """ + choose2_close(self) + """ return _idaapi.choose2_close(*args) def choose2_create(*args): - """choose2_create(self, embedded) -> int""" + """ + choose2_create(self, embedded) -> int + """ return _idaapi.choose2_create(*args) def choose2_activate(*args): - """choose2_activate(self)""" + """ + choose2_activate(self) + """ return _idaapi.choose2_activate(*args) def choose2_get_embedded(*args): - """choose2_get_embedded(self) -> PyObject *""" + """ + choose2_get_embedded(self) -> PyObject * + """ return _idaapi.choose2_get_embedded(*args) def choose2_get_embedded_selection(*args): - """choose2_get_embedded_selection(self) -> PyObject *""" + """ + choose2_get_embedded_selection(self) -> PyObject * + """ return _idaapi.choose2_get_embedded_selection(*args) def textctrl_info_t_assign(*args): - """textctrl_info_t_assign(self, other) -> bool""" + """ + textctrl_info_t_assign(self, other) -> bool + """ return _idaapi.textctrl_info_t_assign(*args) def textctrl_info_t_set_text(*args): - """textctrl_info_t_set_text(self, s) -> bool""" + """ + textctrl_info_t_set_text(self, s) -> bool + """ return _idaapi.textctrl_info_t_set_text(*args) def textctrl_info_t_get_text(*args): - """textctrl_info_t_get_text(self) -> char const *""" + """ + textctrl_info_t_get_text(self) -> char const * + """ return _idaapi.textctrl_info_t_get_text(*args) def textctrl_info_t_set_flags(*args): - """textctrl_info_t_set_flags(self, flags) -> bool""" + """ + textctrl_info_t_set_flags(self, flags) -> bool + """ return _idaapi.textctrl_info_t_set_flags(*args) def textctrl_info_t_get_flags(*args): - """textctrl_info_t_get_flags(self, flags) -> unsigned int""" + """ + textctrl_info_t_get_flags(self, flags) -> unsigned int + """ return _idaapi.textctrl_info_t_get_flags(*args) def textctrl_info_t_set_tabsize(*args): - """textctrl_info_t_set_tabsize(self, tabsize) -> bool""" + """ + textctrl_info_t_set_tabsize(self, tabsize) -> bool + """ return _idaapi.textctrl_info_t_set_tabsize(*args) def textctrl_info_t_get_tabsize(*args): - """textctrl_info_t_get_tabsize(self, tabsize) -> unsigned int""" + """ + textctrl_info_t_get_tabsize(self, tabsize) -> unsigned int + """ return _idaapi.textctrl_info_t_get_tabsize(*args) def formchgcbfa_enable_field(*args): - """formchgcbfa_enable_field(p_fa, fid, enable) -> bool""" + """ + formchgcbfa_enable_field(p_fa, fid, enable) -> bool + """ return _idaapi.formchgcbfa_enable_field(*args) def formchgcbfa_show_field(*args): - """formchgcbfa_show_field(p_fa, fid, show) -> bool""" + """ + formchgcbfa_show_field(p_fa, fid, show) -> bool + """ return _idaapi.formchgcbfa_show_field(*args) def formchgcbfa_move_field(*args): - """formchgcbfa_move_field(p_fa, fid, x, y, w, h) -> bool""" + """ + formchgcbfa_move_field(p_fa, fid, x, y, w, h) -> bool + """ return _idaapi.formchgcbfa_move_field(*args) def formchgcbfa_get_focused_field(*args): - """formchgcbfa_get_focused_field(p_fa) -> int""" + """ + formchgcbfa_get_focused_field(p_fa) -> int + """ return _idaapi.formchgcbfa_get_focused_field(*args) def formchgcbfa_set_focused_field(*args): - """formchgcbfa_set_focused_field(p_fa, fid) -> bool""" + """ + formchgcbfa_set_focused_field(p_fa, fid) -> bool + """ return _idaapi.formchgcbfa_set_focused_field(*args) def formchgcbfa_refresh_field(*args): - """formchgcbfa_refresh_field(p_fa, fid)""" + """ + formchgcbfa_refresh_field(p_fa, fid) + """ return _idaapi.formchgcbfa_refresh_field(*args) def formchgcbfa_close(*args): - """formchgcbfa_close(p_fa, close_normally)""" + """ + formchgcbfa_close(p_fa, fid, close_normally) + """ return _idaapi.formchgcbfa_close(*args) def formchgcbfa_get_field_value(*args): - """formchgcbfa_get_field_value(p_fa, fid, ft, sz) -> PyObject *""" + """ + formchgcbfa_get_field_value(p_fa, fid, ft, sz) -> PyObject * + """ return _idaapi.formchgcbfa_get_field_value(*args) def formchgcbfa_set_field_value(*args): - """formchgcbfa_set_field_value(p_fa, fid, ft, py_val) -> bool""" + """ + formchgcbfa_set_field_value(p_fa, fid, ft, py_val) -> bool + """ return _idaapi.formchgcbfa_set_field_value(*args) def py_get_AskUsingForm(*args): - """py_get_AskUsingForm() -> size_t""" + """ + py_get_AskUsingForm() -> size_t + """ return _idaapi.py_get_AskUsingForm(*args) -def py_get_OpenForm(*args): - """py_get_OpenForm() -> size_t""" - return _idaapi.py_get_OpenForm(*args) - -def py_register_compiled_form(*args): - """py_register_compiled_form(py_form)""" - return _idaapi.py_register_compiled_form(*args) - -def py_unregister_compiled_form(*args): - """py_unregister_compiled_form(py_form)""" - return _idaapi.py_unregister_compiled_form(*args) - def plgform_new(*args): - """plgform_new() -> PyObject *""" + """ + plgform_new() -> PyObject * + """ return _idaapi.plgform_new(*args) def plgform_show(*args): - """plgform_show(py_link, py_obj, caption, options=FORM_TAB|FORM_MENU|FORM_RESTORE) -> bool""" + """ + plgform_show(py_link, py_obj, caption, options=FORM_TAB|FORM_MENU|FORM_RESTORE) -> bool + """ return _idaapi.plgform_show(*args) def plgform_close(*args): - """plgform_close(py_link, options)""" + """ + plgform_close(py_link, options) + """ return _idaapi.plgform_close(*args) def install_command_interpreter(*args): - """install_command_interpreter(py_obj) -> int""" + """ + install_command_interpreter(py_obj) -> int + """ return _idaapi.install_command_interpreter(*args) def remove_command_interpreter(*args): - """remove_command_interpreter(cli_idx)""" + """ + remove_command_interpreter(cli_idx) + """ return _idaapi.remove_command_interpreter(*args) def pyscv_init(*args): - """pyscv_init(py_link, title) -> PyObject *""" + """ + pyscv_init(py_link, title) -> PyObject * + """ return _idaapi.pyscv_init(*args) def pyscv_refresh(*args): - """pyscv_refresh(py_this) -> bool""" + """ + pyscv_refresh(py_this) -> bool + """ return _idaapi.pyscv_refresh(*args) def pyscv_delete(*args): - """pyscv_delete(py_this) -> bool""" + """ + pyscv_delete(py_this) -> bool + """ return _idaapi.pyscv_delete(*args) def pyscv_refresh_current(*args): - """pyscv_refresh_current(py_this) -> bool""" + """ + pyscv_refresh_current(py_this) -> bool + """ return _idaapi.pyscv_refresh_current(*args) def pyscv_get_current_line(*args): - """pyscv_get_current_line(py_this, mouse, notags) -> PyObject *""" + """ + pyscv_get_current_line(py_this, mouse, notags) -> PyObject * + """ return _idaapi.pyscv_get_current_line(*args) def pyscv_is_focused(*args): - """pyscv_is_focused(py_this) -> bool""" + """ + pyscv_is_focused(py_this) -> bool + """ return _idaapi.pyscv_is_focused(*args) def pyscv_clear_popup_menu(*args): - """pyscv_clear_popup_menu(py_this)""" + """ + pyscv_clear_popup_menu(py_this) + """ return _idaapi.pyscv_clear_popup_menu(*args) def pyscv_add_popup_menu(*args): - """pyscv_add_popup_menu(py_this, title, hotkey) -> size_t""" + """ + pyscv_add_popup_menu(py_this, title, hotkey) -> size_t + """ return _idaapi.pyscv_add_popup_menu(*args) def pyscv_count(*args): - """pyscv_count(py_this) -> size_t""" + """ + pyscv_count(py_this) -> size_t + """ return _idaapi.pyscv_count(*args) def pyscv_show(*args): - """pyscv_show(py_this) -> bool""" + """ + pyscv_show(py_this) -> bool + """ return _idaapi.pyscv_show(*args) def pyscv_close(*args): - """pyscv_close(py_this)""" + """ + pyscv_close(py_this) + """ return _idaapi.pyscv_close(*args) def pyscv_jumpto(*args): - """pyscv_jumpto(py_this, ln, x, y) -> bool""" + """ + pyscv_jumpto(py_this, ln, x, y) -> bool + """ return _idaapi.pyscv_jumpto(*args) def pyscv_get_line(*args): - """pyscv_get_line(py_this, nline) -> PyObject *""" + """ + pyscv_get_line(py_this, nline) -> PyObject * + """ return _idaapi.pyscv_get_line(*args) def pyscv_get_pos(*args): - """pyscv_get_pos(py_this, mouse) -> PyObject *""" + """ + pyscv_get_pos(py_this, mouse) -> PyObject * + """ return _idaapi.pyscv_get_pos(*args) def pyscv_clear_lines(*args): - """pyscv_clear_lines(py_this) -> PyObject *""" + """ + pyscv_clear_lines(py_this) -> PyObject * + """ return _idaapi.pyscv_clear_lines(*args) def pyscv_add_line(*args): - """pyscv_add_line(py_this, py_sl) -> bool""" + """ + pyscv_add_line(py_this, py_sl) -> bool + """ return _idaapi.pyscv_add_line(*args) def pyscv_insert_line(*args): - """pyscv_insert_line(py_this, nline, py_sl) -> bool""" + """ + pyscv_insert_line(py_this, nline, py_sl) -> bool + """ return _idaapi.pyscv_insert_line(*args) def pyscv_patch_line(*args): - """pyscv_patch_line(py_this, nline, offs, value) -> bool""" + """ + pyscv_patch_line(py_this, nline, offs, value) -> bool + """ return _idaapi.pyscv_patch_line(*args) def pyscv_del_line(*args): - """pyscv_del_line(py_this, nline) -> bool""" + """ + pyscv_del_line(py_this, nline) -> bool + """ return _idaapi.pyscv_del_line(*args) def pyscv_get_selection(*args): - """pyscv_get_selection(py_this) -> PyObject *""" + """ + pyscv_get_selection(py_this) -> PyObject * + """ return _idaapi.pyscv_get_selection(*args) def pyscv_get_current_word(*args): - """pyscv_get_current_word(py_this, mouse) -> PyObject *""" + """ + pyscv_get_current_word(py_this, mouse) -> PyObject * + """ return _idaapi.pyscv_get_current_word(*args) def pyscv_edit_line(*args): - """pyscv_edit_line(py_this, nline, py_sl) -> bool""" + """ + pyscv_edit_line(py_this, nline, py_sl) -> bool + """ return _idaapi.pyscv_edit_line(*args) - -def pyscv_get_tform(*args): - """pyscv_get_tform(py_this) -> TForm *""" - return _idaapi.pyscv_get_tform(*args) - -def pyscv_get_tcustom_control(*args): - """pyscv_get_tcustom_control(py_this) -> TCustomControl *""" - return _idaapi.pyscv_get_tcustom_control(*args) mbox_internal = _idaapi.mbox_internal mbox_info = _idaapi.mbox_info mbox_warning = _idaapi.mbox_warning @@ -37232,7 +42521,6 @@ chtype_strpath = _idaapi.chtype_strpath chtype_generic2 = _idaapi.chtype_generic2 chtype_idatil = _idaapi.chtype_idatil chtype_enum_by_value_and_size = _idaapi.chtype_enum_by_value_and_size -chtype_srcp = _idaapi.chtype_srcp beep_default = _idaapi.beep_default TCCRT_INVALID = _idaapi.TCCRT_INVALID TCCRT_FLAT = _idaapi.TCCRT_FLAT @@ -37248,118 +42536,83 @@ VME_UNKNOWN = _idaapi.VME_UNKNOWN VME_LEFT_BUTTON = _idaapi.VME_LEFT_BUTTON VME_RIGHT_BUTTON = _idaapi.VME_RIGHT_BUTTON VME_MID_BUTTON = _idaapi.VME_MID_BUTTON -SETMENU_POSMASK = _idaapi.SETMENU_POSMASK -SETMENU_INS = _idaapi.SETMENU_INS -SETMENU_APP = _idaapi.SETMENU_APP -KERNEL_VERSION_MAGIC1 = _idaapi.KERNEL_VERSION_MAGIC1 -KERNEL_VERSION_MAGIC2 = _idaapi.KERNEL_VERSION_MAGIC2 - -def get_kernel_version(*args): - """get_kernel_version() -> bool""" - return _idaapi.get_kernel_version(*args) class place_t(object): - """Proxy of C++ place_t class""" + """ + Proxy of C++ place_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr lnnum = _swig_property(_idaapi.place_t_lnnum_get, _idaapi.place_t_lnnum_set) def _print(self, *args): - """_print(self, ud, out_buf, bufsize)""" + """ + _print(self, ud, out_buf, bufsize) + """ return _idaapi.place_t__print(self, *args) def touval(self, *args): - """touval(self, ud) -> uval_t""" + """ + touval(self, ud) -> uval_t + """ return _idaapi.place_t_touval(self, *args) - def clone(self, *args): - """clone(self) -> place_t""" - return _idaapi.place_t_clone(self, *args) - - def copyfrom(self, *args): - """copyfrom(self, frm)""" - return _idaapi.place_t_copyfrom(self, *args) - - def makeplace(self, *args): - """makeplace(self, ud, x, lnnum) -> place_t""" - return _idaapi.place_t_makeplace(self, *args) - def compare(self, *args): - """compare(self, t2) -> int""" + """ + compare(self, t2) -> int + """ return _idaapi.place_t_compare(self, *args) def adjust(self, *args): - """adjust(self, ud)""" + """ + adjust(self, ud) + """ return _idaapi.place_t_adjust(self, *args) def prev(self, *args): - """prev(self, ud) -> bool""" + """ + prev(self, ud) -> bool + """ return _idaapi.place_t_prev(self, *args) def next(self, *args): - """next(self, ud) -> bool""" + """ + next(self, ud) -> bool + """ return _idaapi.place_t_next(self, *args) def beginning(self, *args): - """beginning(self, ud) -> bool""" + """ + beginning(self, ud) -> bool + """ return _idaapi.place_t_beginning(self, *args) def ending(self, *args): - """ending(self, ud) -> bool""" + """ + ending(self, ud) -> bool + """ return _idaapi.place_t_ending(self, *args) def generate(self, *args): - """generate(self, ud, lines, maxsize, default_lnnum, pfx_color, bgcolor) -> int""" + """ + generate(self, ud, lines, maxsize, default_lnnum, pfx_color, bgcolor) -> int + """ return _idaapi.place_t_generate(self, *args) - def as_idaplace_t(*args): - """as_idaplace_t(p) -> idaplace_t""" - return _idaapi.place_t_as_idaplace_t(*args) - - as_idaplace_t = staticmethod(as_idaplace_t) - def as_enumplace_t(*args): - """as_enumplace_t(p) -> enumplace_t""" - return _idaapi.place_t_as_enumplace_t(*args) - - as_enumplace_t = staticmethod(as_enumplace_t) - def as_structplace_t(*args): - """as_structplace_t(p) -> structplace_t""" - return _idaapi.place_t_as_structplace_t(*args) - - as_structplace_t = staticmethod(as_structplace_t) - def as_simpleline_place_t(*args): - """as_simpleline_place_t(p) -> simpleline_place_t""" - return _idaapi.place_t_as_simpleline_place_t(*args) - - as_simpleline_place_t = staticmethod(as_simpleline_place_t) __swig_destroy__ = _idaapi.delete_place_t __del__ = lambda self : None; place_t_swigregister = _idaapi.place_t_swigregister place_t_swigregister(place_t) -def place_t_as_idaplace_t(*args): - """place_t_as_idaplace_t(p) -> idaplace_t""" - return _idaapi.place_t_as_idaplace_t(*args) - -def place_t_as_enumplace_t(*args): - """place_t_as_enumplace_t(p) -> enumplace_t""" - return _idaapi.place_t_as_enumplace_t(*args) - -def place_t_as_structplace_t(*args): - """place_t_as_structplace_t(p) -> structplace_t""" - return _idaapi.place_t_as_structplace_t(*args) - -def place_t_as_simpleline_place_t(*args): - """place_t_as_simpleline_place_t(p) -> simpleline_place_t""" - return _idaapi.place_t_as_simpleline_place_t(*args) - class simpleline_t(object): - """Proxy of C++ simpleline_t class""" + """ + Proxy of C++ simpleline_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr line = _swig_property(_idaapi.simpleline_t_line_get, _idaapi.simpleline_t_line_set) color = _swig_property(_idaapi.simpleline_t_color_get, _idaapi.simpleline_t_color_set) bgcolor = _swig_property(_idaapi.simpleline_t_bgcolor_get, _idaapi.simpleline_t_bgcolor_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> simpleline_t __init__(self, c, str) -> simpleline_t @@ -37375,7 +42628,9 @@ simpleline_t_swigregister = _idaapi.simpleline_t_swigregister simpleline_t_swigregister(simpleline_t) class simpleline_place_t(place_t): - """Proxy of C++ simpleline_place_t class""" + """ + Proxy of C++ simpleline_place_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr @@ -37386,7 +42641,9 @@ simpleline_place_t_swigregister = _idaapi.simpleline_place_t_swigregister simpleline_place_t_swigregister(simpleline_place_t) class idaplace_t(place_t): - """Proxy of C++ idaplace_t class""" + """ + Proxy of C++ idaplace_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr @@ -37397,7 +42654,9 @@ idaplace_t_swigregister = _idaapi.idaplace_t_swigregister idaplace_t_swigregister(idaplace_t) class enumplace_t(place_t): - """Proxy of C++ enumplace_t class""" + """ + Proxy of C++ enumplace_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr @@ -37411,7 +42670,9 @@ enumplace_t_swigregister = _idaapi.enumplace_t_swigregister enumplace_t_swigregister(enumplace_t) class structplace_t(place_t): - """Proxy of C++ structplace_t class""" + """ + Proxy of C++ structplace_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr @@ -37423,12 +42684,14 @@ structplace_t_swigregister = _idaapi.structplace_t_swigregister structplace_t_swigregister(structplace_t) class twinpos_t(object): - """Proxy of C++ twinpos_t class""" + """ + Proxy of C++ twinpos_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr at = _swig_property(_idaapi.twinpos_t_at_get, _idaapi.twinpos_t_at_set) x = _swig_property(_idaapi.twinpos_t_x_get, _idaapi.twinpos_t_x_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> twinpos_t __init__(self, t) -> twinpos_t @@ -37438,21 +42701,40 @@ class twinpos_t(object): try: self.this.append(this) except: self.this = this def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.twinpos_t___ne__(self, *args) def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.twinpos_t___eq__(self, *args) - def place_as_idaplace_t(self): - return place_t.as_idaplace_t(self.at) - def place_as_enumplace_t(self): - return place_t.as_enumplace_t(self.at) - def place_as_structplace_t(self): - return place_t.as_structplace_t(self.at) - def place_as_simpleline_place_t(self): - return place_t.as_simpleline_place_t(self.at) + def place_as_idaplace_t(self, *args): + """ + place_as_idaplace_t(self) -> idaplace_t + """ + return _idaapi.twinpos_t_place_as_idaplace_t(self, *args) + + def place_as_enumplace_t(self, *args): + """ + place_as_enumplace_t(self) -> enumplace_t + """ + return _idaapi.twinpos_t_place_as_enumplace_t(self, *args) + + def place_as_structplace_t(self, *args): + """ + place_as_structplace_t(self) -> structplace_t + """ + return _idaapi.twinpos_t_place_as_structplace_t(self, *args) + + def place_as_simpleline_place_t(self, *args): + """ + place_as_simpleline_place_t(self) -> simpleline_place_t + """ + return _idaapi.twinpos_t_place_as_simpleline_place_t(self, *args) def place(self, view): ptype = get_viewer_place_type(view) @@ -37474,9 +42756,10 @@ twinpos_t_swigregister(twinpos_t) def request_refresh(*args): - """request_refresh(mask)""" + """ + request_refresh(mask) + """ return _idaapi.request_refresh(*args) -BWN_UNKNOWN = _idaapi.BWN_UNKNOWN BWN_EXPORTS = _idaapi.BWN_EXPORTS BWN_IMPORTS = _idaapi.BWN_IMPORTS BWN_NAMES = _idaapi.BWN_NAMES @@ -37494,31 +42777,16 @@ BWN_BPTS = _idaapi.BWN_BPTS BWN_THREADS = _idaapi.BWN_THREADS BWN_MODULES = _idaapi.BWN_MODULES BWN_TRACE = _idaapi.BWN_TRACE -BWN_CALL_STACK = _idaapi.BWN_CALL_STACK +BWN_STACK = _idaapi.BWN_STACK BWN_XREFS = _idaapi.BWN_XREFS -BWN_SEARCH = _idaapi.BWN_SEARCH +BWN_SEARCHS = _idaapi.BWN_SEARCHS BWN_FRAME = _idaapi.BWN_FRAME BWN_NAVBAND = _idaapi.BWN_NAVBAND BWN_ENUMS = _idaapi.BWN_ENUMS BWN_STRUCTS = _idaapi.BWN_STRUCTS -BWN_DISASM = _idaapi.BWN_DISASM -BWN_DUMP = _idaapi.BWN_DUMP -BWN_NOTEPAD = _idaapi.BWN_NOTEPAD -BWN_OUTPUT = _idaapi.BWN_OUTPUT -BWN_CLI = _idaapi.BWN_CLI -BWN_WATCH = _idaapi.BWN_WATCH -BWN_LOCALS = _idaapi.BWN_LOCALS -BWN_STKVIEW = _idaapi.BWN_STKVIEW -BWN_CHOOSER = _idaapi.BWN_CHOOSER -BWN_SHORTCUTCSR = _idaapi.BWN_SHORTCUTCSR -BWN_SHORTCUTWIN = _idaapi.BWN_SHORTCUTWIN -BWN_CPUREGS = _idaapi.BWN_CPUREGS -BWN_SO_STRUCTS = _idaapi.BWN_SO_STRUCTS -BWN_SO_OFFSETS = _idaapi.BWN_SO_OFFSETS -BWN_STACK = _idaapi.BWN_STACK BWN_DISASMS = _idaapi.BWN_DISASMS BWN_DUMPS = _idaapi.BWN_DUMPS -BWN_SEARCHS = _idaapi.BWN_SEARCHS +BWN_NOTEPAD = _idaapi.BWN_NOTEPAD IWID_EXPORTS = _idaapi.IWID_EXPORTS IWID_IMPORTS = _idaapi.IWID_IMPORTS IWID_NAMES = _idaapi.IWID_NAMES @@ -37548,17 +42816,19 @@ IWID_DUMPS = _idaapi.IWID_DUMPS IWID_NOTEPAD = _idaapi.IWID_NOTEPAD IWID_IDAMEMOS = _idaapi.IWID_IDAMEMOS IWID_ALL = _idaapi.IWID_ALL - -def is_chooser_tform(*args): - """is_chooser_tform(t) -> bool""" - return _idaapi.is_chooser_tform(*args) CHOOSER_NO_SELECTION = _idaapi.CHOOSER_NO_SELECTION CHOOSER_MULTI_SELECTION = _idaapi.CHOOSER_MULTI_SELECTION +CHOOSER_POPUP_MENU = _idaapi.CHOOSER_POPUP_MENU CHOOSER_HOTKEY = _idaapi.CHOOSER_HOTKEY CHOOSER_MENU_EDIT = _idaapi.CHOOSER_MENU_EDIT CHOOSER_MENU_JUMP = _idaapi.CHOOSER_MENU_JUMP CHOOSER_MENU_SEARCH = _idaapi.CHOOSER_MENU_SEARCH -CHOOSER_POPUP_MENU = _idaapi.CHOOSER_POPUP_MENU + +def set_nav_colorizer(*args): + """ + set_nav_colorizer(func) -> nav_colorizer_t * + """ + return _idaapi.set_nav_colorizer(*args) CVH_USERDATA = _idaapi.CVH_USERDATA CVH_KEYDOWN = _idaapi.CVH_KEYDOWN CVH_POPUP = _idaapi.CVH_POPUP @@ -37568,7 +42838,6 @@ CVH_CLOSE = _idaapi.CVH_CLOSE CVH_CLICK = _idaapi.CVH_CLICK CVH_QT_AWARE = _idaapi.CVH_QT_AWARE CVH_HELP = _idaapi.CVH_HELP -CVH_MOUSEMOVE = _idaapi.CVH_MOUSEMOVE CDVH_USERDATA = _idaapi.CDVH_USERDATA CDVH_SRCVIEW = _idaapi.CDVH_SRCVIEW CDVH_LINES_CLICK = _idaapi.CDVH_LINES_CLICK @@ -37581,36 +42850,15 @@ CDVH_LINES_RADIX = _idaapi.CDVH_LINES_RADIX CDVH_LINES_ALIGNMENT = _idaapi.CDVH_LINES_ALIGNMENT msg_activated = _idaapi.msg_activated msg_deactivated = _idaapi.msg_deactivated -obsolete_msg_popup = _idaapi.obsolete_msg_popup +msg_popup = _idaapi.msg_popup msg_click = _idaapi.msg_click msg_dblclick = _idaapi.msg_dblclick msg_closed = _idaapi.msg_closed msg_keydown = _idaapi.msg_keydown -class renderer_pos_info_t(object): - """Proxy of C++ renderer_pos_info_t class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> renderer_pos_info_t""" - this = _idaapi.new_renderer_pos_info_t(*args) - try: self.this.append(this) - except: self.this = this - node = _swig_property(_idaapi.renderer_pos_info_t_node_get, _idaapi.renderer_pos_info_t_node_set) - cx = _swig_property(_idaapi.renderer_pos_info_t_cx_get, _idaapi.renderer_pos_info_t_cx_set) - cy = _swig_property(_idaapi.renderer_pos_info_t_cy_get, _idaapi.renderer_pos_info_t_cy_set) - sx = _swig_property(_idaapi.renderer_pos_info_t_sx_get, _idaapi.renderer_pos_info_t_sx_set) - __swig_destroy__ = _idaapi.delete_renderer_pos_info_t - __del__ = lambda self : None; -renderer_pos_info_t_swigregister = _idaapi.renderer_pos_info_t_swigregister -renderer_pos_info_t_swigregister(renderer_pos_info_t) -EMPTY_SEL = cvar.EMPTY_SEL -START_SEL = cvar.START_SEL -END_SEL = cvar.END_SEL - view_activated = _idaapi.view_activated view_deactivated = _idaapi.view_deactivated view_keydown = _idaapi.view_keydown -obsolete_view_popup = _idaapi.obsolete_view_popup +view_popup = _idaapi.view_popup view_click = _idaapi.view_click view_dblclick = _idaapi.view_dblclick view_curpos = _idaapi.view_curpos @@ -37623,11 +42871,15 @@ MFF_READ = _idaapi.MFF_READ MFF_WRITE = _idaapi.MFF_WRITE MFF_NOWAIT = _idaapi.MFF_NOWAIT class ui_requests_t(object): - """Proxy of C++ ui_requests_t class""" + """ + Proxy of C++ ui_requests_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> ui_requests_t""" + def __init__(self, *args): + """ + __init__(self) -> ui_requests_t + """ this = _idaapi.new_ui_requests_t(*args) try: self.this.append(this) except: self.this = this @@ -37635,214 +42887,176 @@ class ui_requests_t(object): __del__ = lambda self : None; ui_requests_t_swigregister = _idaapi.ui_requests_t_swigregister ui_requests_t_swigregister(ui_requests_t) +EMPTY_SEL = cvar.EMPTY_SEL +START_SEL = cvar.START_SEL +END_SEL = cvar.END_SEL UIJMP_ACTIVATE = _idaapi.UIJMP_ACTIVATE UIJMP_DONTPUSH = _idaapi.UIJMP_DONTPUSH UIJMP_IDAVIEW = _idaapi.UIJMP_IDAVIEW -class action_ctx_base_t(object): - """Proxy of C++ action_ctx_base_t class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> action_ctx_base_t""" - this = _idaapi.new_action_ctx_base_t(*args) - try: self.this.append(this) - except: self.this = this - def reset(self, *args): - """reset(self)""" - return _idaapi.action_ctx_base_t_reset(self, *args) - - form = _swig_property(_idaapi.action_ctx_base_t_form_get, _idaapi.action_ctx_base_t_form_set) - form_type = _swig_property(_idaapi.action_ctx_base_t_form_type_get, _idaapi.action_ctx_base_t_form_type_set) - form_title = _swig_property(_idaapi.action_ctx_base_t_form_title_get, _idaapi.action_ctx_base_t_form_title_set) - chooser_selection = _swig_property(_idaapi.action_ctx_base_t_chooser_selection_get, _idaapi.action_ctx_base_t_chooser_selection_set) - action = _swig_property(_idaapi.action_ctx_base_t_action_get, _idaapi.action_ctx_base_t_action_set) - cur_flags = _swig_property(_idaapi.action_ctx_base_t_cur_flags_get, _idaapi.action_ctx_base_t_cur_flags_set) - def has_flag(self, *args): - """has_flag(self, flag) -> bool""" - return _idaapi.action_ctx_base_t_has_flag(self, *args) - - cur_ea = _swig_property(_idaapi.action_ctx_base_t_cur_ea_get, _idaapi.action_ctx_base_t_cur_ea_set) - cur_extracted_ea = _swig_property(_idaapi.action_ctx_base_t_cur_extracted_ea_get, _idaapi.action_ctx_base_t_cur_extracted_ea_set) - cur_func = _swig_property(_idaapi.action_ctx_base_t_cur_func_get, _idaapi.action_ctx_base_t_cur_func_set) - cur_fchunk = _swig_property(_idaapi.action_ctx_base_t_cur_fchunk_get, _idaapi.action_ctx_base_t_cur_fchunk_set) - cur_struc = _swig_property(_idaapi.action_ctx_base_t_cur_struc_get, _idaapi.action_ctx_base_t_cur_struc_set) - cur_strmem = _swig_property(_idaapi.action_ctx_base_t_cur_strmem_get, _idaapi.action_ctx_base_t_cur_strmem_set) - cur_enum = _swig_property(_idaapi.action_ctx_base_t_cur_enum_get, _idaapi.action_ctx_base_t_cur_enum_set) - cur_seg = _swig_property(_idaapi.action_ctx_base_t_cur_seg_get, _idaapi.action_ctx_base_t_cur_seg_set) - __swig_destroy__ = _idaapi.delete_action_ctx_base_t - __del__ = lambda self : None; -action_ctx_base_t_swigregister = _idaapi.action_ctx_base_t_swigregister -action_ctx_base_t_swigregister(action_ctx_base_t) -ACF_HAS_SELECTION = _idaapi.ACF_HAS_SELECTION -ACF_XTRN_EA = _idaapi.ACF_XTRN_EA - -class action_activation_ctx_t(action_ctx_base_t): - """Proxy of C++ action_activation_ctx_t class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> action_activation_ctx_t""" - this = _idaapi.new_action_activation_ctx_t(*args) - try: self.this.append(this) - except: self.this = this - __swig_destroy__ = _idaapi.delete_action_activation_ctx_t - __del__ = lambda self : None; -action_activation_ctx_t_swigregister = _idaapi.action_activation_ctx_t_swigregister -action_activation_ctx_t_swigregister(action_activation_ctx_t) - -class action_update_ctx_t(action_ctx_base_t): - """Proxy of C++ action_update_ctx_t class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> action_update_ctx_t""" - this = _idaapi.new_action_update_ctx_t(*args) - try: self.this.append(this) - except: self.this = this - __swig_destroy__ = _idaapi.delete_action_update_ctx_t - __del__ = lambda self : None; -action_update_ctx_t_swigregister = _idaapi.action_update_ctx_t_swigregister -action_update_ctx_t_swigregister(action_update_ctx_t) - -AHF_VERSION = _idaapi.AHF_VERSION -AHF_VERSION_MASK = _idaapi.AHF_VERSION_MASK -AST_ENABLE_ALWAYS = _idaapi.AST_ENABLE_ALWAYS -AST_ENABLE_FOR_IDB = _idaapi.AST_ENABLE_FOR_IDB -AST_ENABLE_FOR_FORM = _idaapi.AST_ENABLE_FOR_FORM -AST_ENABLE = _idaapi.AST_ENABLE -AST_DISABLE_ALWAYS = _idaapi.AST_DISABLE_ALWAYS -AST_DISABLE_FOR_IDB = _idaapi.AST_DISABLE_FOR_IDB -AST_DISABLE_FOR_FORM = _idaapi.AST_DISABLE_FOR_FORM -AST_DISABLE = _idaapi.AST_DISABLE - -def is_action_enabled(*args): - """is_action_enabled(s) -> bool""" - return _idaapi.is_action_enabled(*args) -class action_desc_t(object): - """Proxy of C++ action_desc_t class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - cb = _swig_property(_idaapi.action_desc_t_cb_get, _idaapi.action_desc_t_cb_set) - name = _swig_property(_idaapi.action_desc_t_name_get, _idaapi.action_desc_t_name_set) - label = _swig_property(_idaapi.action_desc_t_label_get, _idaapi.action_desc_t_label_set) - owner = _swig_property(_idaapi.action_desc_t_owner_get, _idaapi.action_desc_t_owner_set) - shortcut = _swig_property(_idaapi.action_desc_t_shortcut_get, _idaapi.action_desc_t_shortcut_set) - tooltip = _swig_property(_idaapi.action_desc_t_tooltip_get, _idaapi.action_desc_t_tooltip_set) - icon = _swig_property(_idaapi.action_desc_t_icon_get, _idaapi.action_desc_t_icon_set) - def __init__(self, *args): - """__init__(self, name, label, handler, shortcut=None, tooltip=None, icon=-1) -> action_desc_t""" - this = _idaapi.new_action_desc_t(*args) - try: self.this.append(this) - except: self.this = this - __swig_destroy__ = _idaapi.delete_action_desc_t - __del__ = lambda self : None; -action_desc_t_swigregister = _idaapi.action_desc_t_swigregister -action_desc_t_swigregister(action_desc_t) - -AA_NONE = _idaapi.AA_NONE -AA_LABEL = _idaapi.AA_LABEL -AA_SHORTCUT = _idaapi.AA_SHORTCUT -AA_TOOLTIP = _idaapi.AA_TOOLTIP -AA_ICON = _idaapi.AA_ICON -AA_STATE = _idaapi.AA_STATE -AA_CHECKABLE = _idaapi.AA_CHECKABLE -AA_CHECKED = _idaapi.AA_CHECKED -AA_VISIBILITY = _idaapi.AA_VISIBILITY def cancel_exec_request(*args): - """cancel_exec_request(req_id) -> bool""" + """ + cancel_exec_request(req_id) -> bool + """ return _idaapi.cancel_exec_request(*args) def banner(*args): - """banner(wait) -> bool""" + """ + banner(wait) -> bool + """ return _idaapi.banner(*args) def is_msg_inited(*args): - """is_msg_inited() -> bool""" + """ + is_msg_inited() -> bool + """ return _idaapi.is_msg_inited(*args) def refresh_idaview(*args): - """refresh_idaview()""" + """ + refresh_idaview() + """ return _idaapi.refresh_idaview(*args) def refresh_idaview_anyway(*args): - """refresh_idaview_anyway()""" + """ + refresh_idaview_anyway() + """ return _idaapi.refresh_idaview_anyway(*args) def analyzer_options(*args): - """analyzer_options()""" + """ + analyzer_options() + """ return _idaapi.analyzer_options(*args) def get_screen_ea(*args): - """get_screen_ea() -> ea_t""" + """ + get_screen_ea() -> ea_t + """ return _idaapi.get_screen_ea(*args) def get_opnum(*args): - """get_opnum() -> int""" + """ + get_opnum() -> int + """ return _idaapi.get_opnum(*args) def get_cursor(*args): - """get_cursor() -> bool""" + """ + get_cursor() -> bool + """ return _idaapi.get_cursor(*args) def get_output_cursor(*args): - """get_output_cursor() -> bool""" + """ + get_output_cursor() -> bool + """ return _idaapi.get_output_cursor(*args) def get_curline(*args): - """get_curline() -> char *""" + """ + get_curline() -> char * + """ return _idaapi.get_curline(*args) def read_selection(*args): - """read_selection() -> bool""" + """ + read_selection() -> bool + """ return _idaapi.read_selection(*args) def unmark_selection(*args): - """unmark_selection()""" + """ + unmark_selection() + """ return _idaapi.unmark_selection(*args) def open_url(*args): - """open_url(url)""" + """ + open_url(url) + """ return _idaapi.open_url(*args) def get_hexdump_ea(*args): - """get_hexdump_ea(hexdump_num) -> ea_t""" + """ + get_hexdump_ea(hexdump_num) -> ea_t + """ return _idaapi.get_hexdump_ea(*args) def get_key_code(*args): - """get_key_code(keyname) -> ushort""" + """ + get_key_code(keyname) -> ushort + """ return _idaapi.get_key_code(*args) def lookup_key_code(*args): - """lookup_key_code(key, shift, is_qt) -> ushort""" + """ + lookup_key_code(key, shift, is_qt) -> ushort + """ return _idaapi.lookup_key_code(*args) def refresh_navband(*args): - """refresh_navband(force)""" + """ + refresh_navband(force) + """ return _idaapi.refresh_navband(*args) def refresh_chooser(*args): - """refresh_chooser(title) -> bool""" + """ + refresh_chooser(title) -> bool + """ return _idaapi.refresh_chooser(*args) def close_chooser(*args): - """close_chooser(title) -> bool""" + """ + close_chooser(title) -> bool + """ return _idaapi.close_chooser(*args) +def gen_disasm_text(*args): + """ + gen_disasm_text(ea1, ea2, text, truncate_lines) + """ + return _idaapi.gen_disasm_text(*args) + def set_dock_pos(*args): - """set_dock_pos(src_ctrl, dest_ctrl, orient, left=0, top=0, right=0, bottom=0) -> bool""" + """ + set_dock_pos(src_ctrl, dest_ctrl, orient, left=0, top=0, right=0, bottom=0) -> bool + + + Sets the dock orientation of a window relatively to another window. + + @param src: Source docking control + @param dest: Destination docking control + @param orient: One of DOR_XXXX constants + @param left, top, right, bottom: These parameter if DOR_FLOATING is used, or if you want to specify the width of docked windows + @return: Boolean + + Example: + set_dock_pos('Structures', 'Enums', DOR_RIGHT) <- docks the Structures window to the right of Enums window + """ return _idaapi.set_dock_pos(*args) def free_custom_icon(*args): - """free_custom_icon(icon_id)""" + """ + free_custom_icon(icon_id) + + + Frees an icon loaded with load_custom_icon() + """ return _idaapi.free_custom_icon(*args) class __qtimer_t(object): - """Proxy of C++ __qtimer_t class""" + """ + Proxy of C++ __qtimer_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> __qtimer_t""" + def __init__(self, *args): + """ + __init__(self) -> __qtimer_t + """ this = _idaapi.new___qtimer_t(*args) try: self.this.append(this) except: self.this = this @@ -37852,80 +43066,76 @@ __qtimer_t_swigregister = _idaapi.__qtimer_t_swigregister __qtimer_t_swigregister(__qtimer_t) -def attach_action_to_menu(*args): - """attach_action_to_menu(menupath, name, flags) -> bool""" - return _idaapi.attach_action_to_menu(*args) - -def detach_action_from_menu(*args): - """detach_action_from_menu(menupath, name) -> bool""" - return _idaapi.detach_action_from_menu(*args) - -def attach_action_to_toolbar(*args): - """attach_action_to_toolbar(toolbar_name, name) -> bool""" - return _idaapi.attach_action_to_toolbar(*args) - -def detach_action_from_toolbar(*args): - """detach_action_from_toolbar(toolbar_name, name) -> bool""" - return _idaapi.detach_action_from_toolbar(*args) - -def register_and_attach_to_menu(*args): - """register_and_attach_to_menu(menupath, name, label, shortcut, flags, handler, owner) -> bool""" - return _idaapi.register_and_attach_to_menu(*args) - def set_menu_item_icon(*args): - """set_menu_item_icon(item_name, icon_id) -> bool""" + """ + set_menu_item_icon(item_name, icon_id) -> bool + """ return _idaapi.set_menu_item_icon(*args) def enable_menu_item(*args): - """enable_menu_item(item_name, enable) -> bool""" + """ + enable_menu_item(item_name, enable) -> bool + """ return _idaapi.enable_menu_item(*args) def create_tform(*args): - """create_tform(caption, handle) -> TForm *""" + """ + create_tform(caption, handle) -> TForm * + """ return _idaapi.create_tform(*args) def open_tform(*args): - """open_tform(form, options)""" + """ + open_tform(form, options) + """ return _idaapi.open_tform(*args) def close_tform(*args): - """close_tform(form, options)""" + """ + close_tform(form, options) + """ return _idaapi.close_tform(*args) def switchto_tform(*args): - """switchto_tform(form, take_focus)""" + """ + switchto_tform(form, take_focus) + """ return _idaapi.switchto_tform(*args) def find_tform(*args): - """find_tform(caption) -> TForm *""" + """ + find_tform(caption) -> TForm * + """ return _idaapi.find_tform(*args) def get_current_tform(*args): - """get_current_tform() -> TForm *""" + """ + get_current_tform() -> TForm * + """ return _idaapi.get_current_tform(*args) -def get_tform_type(*args): - """get_tform_type(form) -> tform_type_t""" - return _idaapi.get_tform_type(*args) - -def get_tform_title(*args): - """get_tform_title(form) -> bool""" - return _idaapi.get_tform_title(*args) - def create_ea_viewer(*args): - """create_ea_viewer(title, parent, minplace, maxplace, curplace, y, ud, flags=0, fillloc=None, jumploc=None) -> TCustomControl *""" + """ + create_ea_viewer(title, parent, minplace, maxplace, curplace, y, ud, flags=0, fillloc=None, jumploc=None) -> TCustomControl * + """ return _idaapi.create_ea_viewer(*args) def ea_viewer_history_push_and_jump(*args): - """ea_viewer_history_push_and_jump(v, ea, x, y, lnnum) -> bool""" + """ + ea_viewer_history_push_and_jump(v, ea, x, y, lnnum) -> bool + """ return _idaapi.ea_viewer_history_push_and_jump(*args) def get_ea_viewer_history_info(*args): - """get_ea_viewer_history_info(nback, nfwd, v) -> bool""" + """ + get_ea_viewer_history_info(nback, nfwd, v) -> bool + """ return _idaapi.get_ea_viewer_history_info(*args) def repaint_custom_viewer(*args): - """repaint_custom_viewer(custom_viewer)""" + """ + repaint_custom_viewer(custom_viewer) + """ return _idaapi.repaint_custom_viewer(*args) def jumpto(*args): @@ -37935,417 +43145,436 @@ def jumpto(*args): """ return _idaapi.jumpto(*args) -def get_custom_viewer_place(*args): - """get_custom_viewer_place(custom_viewer, mouse) -> place_t""" - return _idaapi.get_custom_viewer_place(*args) - def is_idaq(*args): - """is_idaq() -> bool""" + """ + is_idaq() -> bool + + + Returns True or False depending if IDAPython is hosted by IDAQ + """ return _idaapi.is_idaq(*args) -def attach_action_to_popup(*args): - """ - attach_action_to_popup(tcc, popup_handle, name, popuppath=None, flags=0) -> bool - attach_action_to_popup(form, popup_handle, name, popuppath=None, flags=0) -> bool - """ - return _idaapi.attach_action_to_popup(*args) - -def detach_action_from_popup(*args): - """detach_action_from_popup(form, name) -> bool""" - return _idaapi.detach_action_from_popup(*args) - -def update_action_label(*args): - """update_action_label(name, label) -> bool""" - return _idaapi.update_action_label(*args) - -def update_action_shortcut(*args): - """update_action_shortcut(name, shortcut) -> bool""" - return _idaapi.update_action_shortcut(*args) - -def update_action_tooltip(*args): - """update_action_tooltip(name, tooltip) -> bool""" - return _idaapi.update_action_tooltip(*args) - -def update_action_icon(*args): - """update_action_icon(name, icon) -> bool""" - return _idaapi.update_action_icon(*args) - -def update_action_state(*args): - """update_action_state(name, state) -> bool""" - return _idaapi.update_action_state(*args) - -def update_action_checkable(*args): - """update_action_checkable(name, checkable) -> bool""" - return _idaapi.update_action_checkable(*args) - -def update_action_checked(*args): - """update_action_checked(name, checked) -> bool""" - return _idaapi.update_action_checked(*args) - -def update_action_visibility(*args): - """update_action_visibility(name, visible) -> bool""" - return _idaapi.update_action_visibility(*args) - -def get_action_label(*args): - """get_action_label(name) -> bool""" - return _idaapi.get_action_label(*args) - -def get_action_shortcut(*args): - """get_action_shortcut(name) -> bool""" - return _idaapi.get_action_shortcut(*args) - -def get_action_tooltip(*args): - """get_action_tooltip(name) -> bool""" - return _idaapi.get_action_tooltip(*args) - -def get_action_icon(*args): - """get_action_icon(name) -> bool""" - return _idaapi.get_action_icon(*args) - -def get_action_state(*args): - """get_action_state(name) -> bool""" - return _idaapi.get_action_state(*args) - -def get_action_checkable(*args): - """get_action_checkable(name) -> bool""" - return _idaapi.get_action_checkable(*args) - -def get_action_checked(*args): - """get_action_checked(name) -> bool""" - return _idaapi.get_action_checked(*args) - -def get_action_visibility(*args): - """get_action_visibility(name) -> bool""" - return _idaapi.get_action_visibility(*args) - def set_custom_viewer_qt_aware(*args): - """set_custom_viewer_qt_aware(custom_viewer) -> bool""" + """ + set_custom_viewer_qt_aware(custom_viewer) -> bool + """ return _idaapi.set_custom_viewer_qt_aware(*args) def get_custom_viewer_curline(*args): - """get_custom_viewer_curline(custom_viewer, mouse) -> char const *""" + """ + get_custom_viewer_curline(custom_viewer, mouse) -> char const * + """ return _idaapi.get_custom_viewer_curline(*args) def get_output_curline(*args): - """get_output_curline(mouse) -> bool""" + """ + get_output_curline(mouse) -> bool + """ return _idaapi.get_output_curline(*args) def get_output_selected_text(*args): - """get_output_selected_text() -> bool""" + """ + get_output_selected_text() -> bool + """ return _idaapi.get_output_selected_text(*args) +def add_output_popup(*args): + """ + add_output_popup(name, cb, ud) + """ + return _idaapi.add_output_popup(*args) + def get_tform_idaview(*args): - """get_tform_idaview(parent) -> TCustomControl *""" + """ + get_tform_idaview(parent) -> TCustomControl * + """ return _idaapi.get_tform_idaview(*args) def get_current_viewer(*args): - """get_current_viewer() -> TCustomControl *""" + """ + get_current_viewer() -> TCustomControl * + """ return _idaapi.get_current_viewer(*args) def get_view_renderer_type(*args): - """get_view_renderer_type(v) -> tcc_renderer_type_t""" + """ + get_view_renderer_type(v) -> tcc_renderer_type_t + """ return _idaapi.get_view_renderer_type(*args) def set_view_renderer_type(*args): - """set_view_renderer_type(v, rt)""" + """ + set_view_renderer_type(v, rt) + """ return _idaapi.set_view_renderer_type(*args) def readsel2(*args): - """readsel2(v, p1, p2) -> bool""" + """ + readsel2(v, p1, p2) -> bool + + + Read the user selection, and store its information in p0 (from) and p1 (to). + + This can be used as follows: + + + >>> p0 = idaapi.twinpos_t() + p1 = idaapi.twinpos_t() + view = idaapi.get_current_viewer() + idaapi.readsel2(view, p0, p1) + + + At that point, p0 and p1 hold information for the selection. + But, the 'at' property of p0 and p1 is not properly typed. + To specialize it, call #place() on it, passing it the view + they were retrieved from. Like so: + + + >>> place0 = p0.place(view) + place1 = p1.place(view) + + + This will effectively "cast" the place into a specialized type, + holding proper information, depending on the view type (e.g., + disassembly, structures, enums, ...) + + @param view: The view to retrieve the selection for. + @param p0: Storage for the "from" part of the selection. + @param p1: Storage for the "to" part of the selection. + @return: a bool value indicating success. + """ return _idaapi.readsel2(*args) def create_code_viewer(*args): - """create_code_viewer(parent, custview, flags=0) -> TCustomControl *""" + """ + create_code_viewer(parent, custview, flags=0) -> TCustomControl * + """ return _idaapi.create_code_viewer(*args) def set_code_viewer_handler(*args): - """set_code_viewer_handler(code_viewer, handler_id, handler_or_data) -> void *""" + """ + set_code_viewer_handler(code_viewer, handler_id, handler_or_data) -> void * + """ return _idaapi.set_code_viewer_handler(*args) def set_code_viewer_user_data(*args): - """set_code_viewer_user_data(code_viewer, ud) -> bool""" + """ + set_code_viewer_user_data(code_viewer, ud) -> bool + """ return _idaapi.set_code_viewer_user_data(*args) def get_viewer_user_data(*args): - """get_viewer_user_data(viewer) -> void *""" + """ + get_viewer_user_data(viewer) -> void * + """ return _idaapi.get_viewer_user_data(*args) def get_viewer_place_type(*args): - """get_viewer_place_type(viewer) -> tcc_place_type_t""" + """ + get_viewer_place_type(viewer) -> tcc_place_type_t + """ return _idaapi.get_viewer_place_type(*args) def set_code_viewer_line_handlers(*args): - """set_code_viewer_line_handlers(code_viewer, click_handler, popup_handler, dblclick_handler, drawicon_handler, linenum_handler)""" + """ + set_code_viewer_line_handlers(code_viewer, click_handler, popup_handler, dblclick_handler, drawicon_handler, linenum_handler) + """ return _idaapi.set_code_viewer_line_handlers(*args) def set_code_viewer_lines_icon_margin(*args): - """set_code_viewer_lines_icon_margin(code_viewer, margin) -> bool""" + """ + set_code_viewer_lines_icon_margin(code_viewer, margin) -> bool + """ return _idaapi.set_code_viewer_lines_icon_margin(*args) def set_code_viewer_lines_alignment(*args): - """set_code_viewer_lines_alignment(code_viewer, align) -> bool""" + """ + set_code_viewer_lines_alignment(code_viewer, align) -> bool + """ return _idaapi.set_code_viewer_lines_alignment(*args) def set_code_viewer_lines_radix(*args): - """set_code_viewer_lines_radix(code_viewer, radix) -> bool""" + """ + set_code_viewer_lines_radix(code_viewer, radix) -> bool + """ return _idaapi.set_code_viewer_lines_radix(*args) def set_code_viewer_is_source(*args): - """set_code_viewer_is_source(code_viewer) -> bool""" + """ + set_code_viewer_is_source(code_viewer) -> bool + """ return _idaapi.set_code_viewer_is_source(*args) def get_tab_size(*args): - """get_tab_size(path) -> int""" + """ + get_tab_size(path) -> int + """ return _idaapi.get_tab_size(*args) def clearBreak(*args): - """clearBreak()""" + """ + clearBreak() + """ return _idaapi.clearBreak(*args) def setBreak(*args): - """setBreak()""" + """ + setBreak() + """ return _idaapi.setBreak(*args) def wasBreak(*args): - """wasBreak() -> bool""" + """ + wasBreak() -> bool + """ return _idaapi.wasBreak(*args) def ui_load_new_file(*args): - """ui_load_new_file(filename, li, neflags) -> bool""" + """ + ui_load_new_file(filename, li, neflags) -> bool + """ return _idaapi.ui_load_new_file(*args) def ui_run_debugger(*args): - """ui_run_debugger(dbgopts, $ignore, argc, argv) -> bool""" + """ + ui_run_debugger(dbgopts, $ignore, argc, argv) -> bool + """ return _idaapi.ui_run_debugger(*args) -def load_dbg_dbginfo(*args): - """load_dbg_dbginfo(path, li=None, base=BADADDR, verbose=False) -> bool""" - return _idaapi.load_dbg_dbginfo(*args) - def add_idc_hotkey(*args): - """add_idc_hotkey(hotkey, idcfunc) -> int""" + """ + add_idc_hotkey(hotkey, idcfunc) -> int + """ return _idaapi.add_idc_hotkey(*args) def del_idc_hotkey(*args): - """del_idc_hotkey(hotkey) -> bool""" + """ + del_idc_hotkey(hotkey) -> bool + """ return _idaapi.del_idc_hotkey(*args) -def get_user_strlist_options(*args): - """get_user_strlist_options(out)""" - return _idaapi.get_user_strlist_options(*args) - def open_exports_window(*args): - """open_exports_window(ea) -> TForm *""" + """ + open_exports_window(ea) -> TForm * + """ return _idaapi.open_exports_window(*args) def open_imports_window(*args): - """open_imports_window(ea) -> TForm *""" + """ + open_imports_window(ea) -> TForm * + """ return _idaapi.open_imports_window(*args) def open_names_window(*args): - """open_names_window(ea) -> TForm *""" + """ + open_names_window(ea) -> TForm * + """ return _idaapi.open_names_window(*args) def open_funcs_window(*args): - """open_funcs_window(ea) -> TForm *""" + """ + open_funcs_window(ea) -> TForm * + """ return _idaapi.open_funcs_window(*args) def open_strings_window(*args): - """open_strings_window(ea, selstart=BADADDR, selend=BADADDR) -> TForm *""" + """ + open_strings_window(ea, selstart=BADADDR, selend=BADADDR) -> TForm * + """ return _idaapi.open_strings_window(*args) def open_segments_window(*args): - """open_segments_window(ea) -> TForm *""" + """ + open_segments_window(ea) -> TForm * + """ return _idaapi.open_segments_window(*args) def open_segregs_window(*args): - """open_segregs_window(ea) -> TForm *""" + """ + open_segregs_window(ea) -> TForm * + """ return _idaapi.open_segregs_window(*args) def open_selectors_window(*args): - """open_selectors_window() -> TForm *""" + """ + open_selectors_window() -> TForm * + """ return _idaapi.open_selectors_window(*args) def open_signatures_window(*args): - """open_signatures_window() -> TForm *""" + """ + open_signatures_window() -> TForm * + """ return _idaapi.open_signatures_window(*args) def open_tils_window(*args): - """open_tils_window() -> TForm *""" + """ + open_tils_window() -> TForm * + """ return _idaapi.open_tils_window(*args) def open_loctypes_window(*args): - """open_loctypes_window(ordinal) -> TForm *""" + """ + open_loctypes_window(ordinal) -> TForm * + """ return _idaapi.open_loctypes_window(*args) def open_calls_window(*args): - """open_calls_window(ea) -> TForm *""" + """ + open_calls_window(ea) -> TForm * + """ return _idaapi.open_calls_window(*args) def open_problems_window(*args): - """open_problems_window(ea) -> TForm *""" + """ + open_problems_window(ea) -> TForm * + """ return _idaapi.open_problems_window(*args) def open_bpts_window(*args): - """open_bpts_window(ea) -> TForm *""" + """ + open_bpts_window(ea) -> TForm * + """ return _idaapi.open_bpts_window(*args) def open_threads_window(*args): - """open_threads_window() -> TForm *""" + """ + open_threads_window() -> TForm * + """ return _idaapi.open_threads_window(*args) def open_modules_window(*args): - """open_modules_window() -> TForm *""" + """ + open_modules_window() -> TForm * + """ return _idaapi.open_modules_window(*args) def open_trace_window(*args): - """open_trace_window() -> TForm *""" + """ + open_trace_window() -> TForm * + """ return _idaapi.open_trace_window(*args) def open_stack_window(*args): - """open_stack_window() -> TForm *""" + """ + open_stack_window() -> TForm * + """ return _idaapi.open_stack_window(*args) def open_xrefs_window(*args): - """open_xrefs_window(ea) -> TForm *""" + """ + open_xrefs_window(ea) -> TForm * + """ return _idaapi.open_xrefs_window(*args) def open_frame_window(*args): - """open_frame_window(pfn, offset) -> TForm *""" + """ + open_frame_window(pfn, offset) -> TForm * + """ return _idaapi.open_frame_window(*args) def open_navband_window(*args): - """open_navband_window(ea, zoom) -> TForm *""" + """ + open_navband_window(ea, zoom) -> TForm * + """ return _idaapi.open_navband_window(*args) def open_enums_window(*args): - """open_enums_window(const_id=BADADDR) -> TForm *""" + """ + open_enums_window(const_id=BADADDR) -> TForm * + """ return _idaapi.open_enums_window(*args) def open_structs_window(*args): - """open_structs_window(id=BADADDR, offset=0) -> TForm *""" + """ + open_structs_window(id=BADADDR, offset=0) -> TForm * + """ return _idaapi.open_structs_window(*args) def open_disasm_window(*args): - """open_disasm_window(window_title, ranges=None) -> TForm *""" + """ + open_disasm_window(window_title, ranges=None) -> TForm * + """ return _idaapi.open_disasm_window(*args) def open_hexdump_window(*args): - """open_hexdump_window(window_title) -> TForm *""" + """ + open_hexdump_window(window_title) -> TForm * + """ return _idaapi.open_hexdump_window(*args) def open_notepad_window(*args): - """open_notepad_window() -> TForm *""" + """ + open_notepad_window() -> TForm * + """ return _idaapi.open_notepad_window(*args) def choose_til(*args): - """choose_til() -> bool""" + """ + choose_til() -> bool + """ return _idaapi.choose_til(*args) def choose_entry(*args): - """choose_entry(title) -> ea_t""" + """ + choose_entry(title) -> ea_t + """ return _idaapi.choose_entry(*args) def choose_name(*args): - """choose_name(title) -> ea_t""" + """ + choose_name(title) -> ea_t + """ return _idaapi.choose_name(*args) def choose_stkvar_xref(*args): - """choose_stkvar_xref(pfn, mptr) -> ea_t""" + """ + choose_stkvar_xref(pfn, mptr) -> ea_t + """ return _idaapi.choose_stkvar_xref(*args) def choose_xref(*args): - """choose_xref(to) -> ea_t""" + """ + choose_xref(to) -> ea_t + """ return _idaapi.choose_xref(*args) def choose_enum(*args): - """choose_enum(title, default_id) -> enum_t""" + """ + choose_enum(title, default_id) -> enum_t + """ return _idaapi.choose_enum(*args) def choose_enum_by_value(*args): - """choose_enum_by_value(title, default_id, value, nbytes) -> enum_t""" + """ + choose_enum_by_value(title, default_id, value, nbytes) -> enum_t + """ return _idaapi.choose_enum_by_value(*args) def choose_func(*args): - """choose_func(title, default_ea) -> func_t""" + """ + choose_func(title, default_ea) -> func_t + """ return _idaapi.choose_func(*args) def choose_segm(*args): - """choose_segm(title, default_ea) -> segment_t""" + """ + choose_segm(title, default_ea) -> segment_t + """ return _idaapi.choose_segm(*args) +def choose_segreg(*args): + """ + choose_segreg(title) -> segreg_t + """ + return _idaapi.choose_segreg(*args) + def choose_struc(*args): - """choose_struc(title) -> struc_t""" + """ + choose_struc(title) -> struc_t + """ return _idaapi.choose_struc(*args) -def choose_srcp(*args): - """choose_srcp(title) -> segreg_area_t""" - return _idaapi.choose_srcp(*args) - -def get_chooser_obj(*args): - """get_chooser_obj(chooser_caption) -> void *""" - return _idaapi.get_chooser_obj(*args) - -def enable_chooser_item_attrs(*args): - """enable_chooser_item_attrs(chooser_caption, enable) -> bool""" - return _idaapi.enable_chooser_item_attrs(*args) - -def show_wait_box(*args): - """show_wait_box(format)""" - return _idaapi.show_wait_box(*args) - -def hide_wait_box(*args): - """hide_wait_box()""" - return _idaapi.hide_wait_box(*args) - -def replace_wait_box(*args): - """replace_wait_box(format)""" - return _idaapi.replace_wait_box(*args) - -def beep(*args): - """beep(beep_type=beep_default)""" - return _idaapi.beep(*args) - -def askfile2_cv(*args): - """askfile2_cv(forsave, defdir, filters, format, va) -> char *""" - return _idaapi.askfile2_cv(*args) - -def ask_for_feedback(*args): - """ask_for_feedback(format)""" - return _idaapi.ask_for_feedback(*args) - -def askident(*args): - """askident(defval, format) -> char *""" - return _idaapi.askident(*args) - -def _askaddr(*args): - """_askaddr(addr, format) -> bool""" - return _idaapi._askaddr(*args) - -def _askseg(*args): - """_askseg(sel, format) -> bool""" - return _idaapi._askseg(*args) - -def _asklong(*args): - """_asklong(value, format) -> bool""" - return _idaapi._asklong(*args) - -def vaskqstr(*args): - """vaskqstr(str, format, va) -> bool""" - return _idaapi.vaskqstr(*args) - -def vumsg(*args): - """vumsg(format, va) -> int""" - return _idaapi.vumsg(*args) - -def display_copyright_warning(*args): - """display_copyright_warning() -> bool""" - return _idaapi.display_copyright_warning(*args) - -def add_output_popup(*args): - """add_output_popup(n, c, u)""" - return _idaapi.add_output_popup(*args) - def add_chooser_command(*args): """ add_chooser_command(chooser_caption, cmd_caption, chooser_cb, menu_index=-1, icon=-1, flags=0) -> bool @@ -38353,24 +43582,100 @@ def add_chooser_command(*args): """ return _idaapi.add_chooser_command(*args) -def choose_segreg(*args): - """choose_segreg(title) -> segreg_t""" - return _idaapi.choose_segreg(*args) +def get_chooser_obj(*args): + """ + get_chooser_obj(chooser_caption) -> void * + """ + return _idaapi.get_chooser_obj(*args) -def error(*args): - """error(format)""" - return _idaapi.error(*args) +def enable_chooser_item_attrs(*args): + """ + enable_chooser_item_attrs(chooser_caption, enable) -> bool + """ + return _idaapi.enable_chooser_item_attrs(*args) -def warning(*args): - """warning(format)""" - return _idaapi.warning(*args) +def show_wait_box(*args): + """ + show_wait_box(format) + """ + return _idaapi.show_wait_box(*args) + +def hide_wait_box(*args): + """ + hide_wait_box() + """ + return _idaapi.hide_wait_box(*args) + +def replace_wait_box(*args): + """ + replace_wait_box(format) + """ + return _idaapi.replace_wait_box(*args) + +def OpenForm_cv(*args): + """ + OpenForm_cv(format, flags, va) -> TForm * + """ + return _idaapi.OpenForm_cv(*args) + +def beep(*args): + """ + beep(beep_type=beep_default) + """ + return _idaapi.beep(*args) + +def askfile2_cv(*args): + """ + askfile2_cv(forsave, defdir, filters, format, va) -> char * + """ + return _idaapi.askfile2_cv(*args) + +def ask_for_feedback(*args): + """ + ask_for_feedback(format) + """ + return _idaapi.ask_for_feedback(*args) + +def askident(*args): + """ + askident(defval, format) -> char * + """ + return _idaapi.askident(*args) + +def _askaddr(*args): + """ + _askaddr(addr, format) -> bool + """ + return _idaapi._askaddr(*args) + +def _askseg(*args): + """ + _askseg(sel, format) -> bool + """ + return _idaapi._askseg(*args) + +def _asklong(*args): + """ + _asklong(value, format) -> bool + """ + return _idaapi._asklong(*args) + +def display_copyright_warning(*args): + """ + display_copyright_warning() -> bool + """ + return _idaapi.display_copyright_warning(*args) def info(*args): - """info(format)""" + """ + info(format) + """ return _idaapi.info(*args) def nomem(*args): - """nomem(format)""" + """ + nomem(format) + """ return _idaapi.nomem(*args) ASKBTN_YES = _idaapi.ASKBTN_YES ASKBTN_NO = _idaapi.ASKBTN_NO @@ -38380,15 +43685,21 @@ ASKBTN_BTN2 = _idaapi.ASKBTN_BTN2 ASKBTN_BTN3 = _idaapi.ASKBTN_BTN3 def askyn_c(*args): - """askyn_c(deflt, format) -> int""" + """ + askyn_c(deflt, format) -> int + """ return _idaapi.askyn_c(*args) def askbuttons_c(*args): - """askbuttons_c(Yes, No, Cancel, deflt, format) -> int""" + """ + askbuttons_c(Yes, No, Cancel, deflt, format) -> int + """ return _idaapi.askbuttons_c(*args) def askstr(*args): - """askstr(hist, defval, format) -> char *""" + """ + askstr(hist, defval, format) -> char * + """ return _idaapi.askstr(*args) HIST_SEG = _idaapi.HIST_SEG HIST_CMT = _idaapi.HIST_CMT @@ -38401,19 +43712,21 @@ HIST_TYPE = _idaapi.HIST_TYPE HIST_CMD = _idaapi.HIST_CMD HIST_DIR = _idaapi.HIST_DIR -def askqstr(*args): - """askqstr(str, format) -> bool""" - return _idaapi.askqstr(*args) - def askfile_c(*args): - """askfile_c(savefile, defval, format) -> char *""" + """ + askfile_c(savefile, defval, format) -> char * + """ return _idaapi.askfile_c(*args) def askfile2_c(*args): - """askfile2_c(forsave, defdir, filters, format) -> char *""" + """ + askfile2_c(forsave, defdir, filters, format) -> char * + """ return _idaapi.askfile2_c(*args) class addon_info_t(object): - """Proxy of C++ addon_info_t class""" + """ + Proxy of C++ addon_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr cb = _swig_property(_idaapi.addon_info_t_cb_get, _idaapi.addon_info_t_cb_set) @@ -38425,8 +43738,10 @@ class addon_info_t(object): freeform = _swig_property(_idaapi.addon_info_t_freeform_get, _idaapi.addon_info_t_freeform_set) custom_data = _swig_property(_idaapi.addon_info_t_custom_data_get, _idaapi.addon_info_t_custom_data_set) custom_size = _swig_property(_idaapi.addon_info_t_custom_size_get, _idaapi.addon_info_t_custom_size_set) - def __init__(self, *args): - """__init__(self) -> addon_info_t""" + def __init__(self, *args): + """ + __init__(self) -> addon_info_t + """ this = _idaapi.new_addon_info_t(*args) try: self.this.append(this) except: self.this = this @@ -38437,32 +43752,46 @@ addon_info_t_swigregister(addon_info_t) def register_addon(*args): - """register_addon(info) -> int""" + """ + register_addon(info) -> int + """ return _idaapi.register_addon(*args) def addon_count(*args): - """addon_count() -> int""" + """ + addon_count() -> int + """ return _idaapi.addon_count(*args) def get_addon_info(*args): - """get_addon_info(id, info) -> bool""" + """ + get_addon_info(id, info) -> bool + """ return _idaapi.get_addon_info(*args) def get_addon_info_idx(*args): - """get_addon_info_idx(index, info) -> bool""" + """ + get_addon_info_idx(index, info) -> bool + """ return _idaapi.get_addon_info_idx(*args) def add_spaces(*args): - """add_spaces(str, bufsize, len) -> char *""" + """ + add_spaces(str, bufsize, len) -> char * + """ return _idaapi.add_spaces(*args) class strarray_t(object): - """Proxy of C++ strarray_t class""" + """ + Proxy of C++ strarray_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr code = _swig_property(_idaapi.strarray_t_code_get, _idaapi.strarray_t_code_set) text = _swig_property(_idaapi.strarray_t_text_get, _idaapi.strarray_t_text_set) - def __init__(self, *args): - """__init__(self) -> strarray_t""" + def __init__(self, *args): + """ + __init__(self) -> strarray_t + """ this = _idaapi.new_strarray_t(*args) try: self.this.append(this) except: self.this = this @@ -38473,7 +43802,9 @@ strarray_t_swigregister(strarray_t) def strarray(*args): - """strarray(array, array_size, code) -> char const *""" + """ + strarray(array, array_size, code) -> char const * + """ return _idaapi.strarray(*args) IK_CANCEL = _idaapi.IK_CANCEL IK_BACK = _idaapi.IK_BACK @@ -38594,142 +43925,6 @@ IK_OEM_CLEAR = _idaapi.IK_OEM_CLEAR CB_INIT = _idaapi.CB_INIT CB_YES = _idaapi.CB_YES CB_CLOSE = _idaapi.CB_CLOSE -class disasm_text_t(object): - """Proxy of C++ qvector<(disasm_line_t)> class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - def __init__(self, *args): - """ - __init__(self) -> disasm_text_t - __init__(self, x) -> disasm_text_t - """ - this = _idaapi.new_disasm_text_t(*args) - try: self.this.append(this) - except: self.this = this - __swig_destroy__ = _idaapi.delete_disasm_text_t - __del__ = lambda self : None; - def push_back(self, *args): - """ - push_back(self, x) - push_back(self) -> disasm_line_t - """ - return _idaapi.disasm_text_t_push_back(self, *args) - - def pop_back(self, *args): - """pop_back(self)""" - return _idaapi.disasm_text_t_pop_back(self, *args) - - def size(self, *args): - """size(self) -> size_t""" - return _idaapi.disasm_text_t_size(self, *args) - - def empty(self, *args): - """empty(self) -> bool""" - return _idaapi.disasm_text_t_empty(self, *args) - - def at(self, *args): - """at(self, _idx) -> disasm_line_t""" - return _idaapi.disasm_text_t_at(self, *args) - - def front(self, *args): - """ - front(self) -> disasm_line_t - front(self) -> disasm_line_t - """ - return _idaapi.disasm_text_t_front(self, *args) - - def back(self, *args): - """ - back(self) -> disasm_line_t - back(self) -> disasm_line_t - """ - return _idaapi.disasm_text_t_back(self, *args) - - def qclear(self, *args): - """qclear(self)""" - return _idaapi.disasm_text_t_qclear(self, *args) - - def clear(self, *args): - """clear(self)""" - return _idaapi.disasm_text_t_clear(self, *args) - - def resize(self, *args): - """ - resize(self, _newsize, x) - resize(self, _newsize) - """ - return _idaapi.disasm_text_t_resize(self, *args) - - def grow(self, *args): - """grow(self, x=disasm_line_t())""" - return _idaapi.disasm_text_t_grow(self, *args) - - def capacity(self, *args): - """capacity(self) -> size_t""" - return _idaapi.disasm_text_t_capacity(self, *args) - - def reserve(self, *args): - """reserve(self, cnt)""" - return _idaapi.disasm_text_t_reserve(self, *args) - - def truncate(self, *args): - """truncate(self)""" - return _idaapi.disasm_text_t_truncate(self, *args) - - def swap(self, *args): - """swap(self, r)""" - return _idaapi.disasm_text_t_swap(self, *args) - - def extract(self, *args): - """extract(self) -> disasm_line_t""" - return _idaapi.disasm_text_t_extract(self, *args) - - def inject(self, *args): - """inject(self, s, len)""" - return _idaapi.disasm_text_t_inject(self, *args) - - def begin(self, *args): - """ - begin(self) -> disasm_line_t - begin(self) -> disasm_line_t - """ - return _idaapi.disasm_text_t_begin(self, *args) - - def end(self, *args): - """ - end(self) -> disasm_line_t - end(self) -> disasm_line_t - """ - return _idaapi.disasm_text_t_end(self, *args) - - def insert(self, *args): - """insert(self, it, x) -> disasm_line_t""" - return _idaapi.disasm_text_t_insert(self, *args) - - def erase(self, *args): - """ - erase(self, it) -> disasm_line_t - erase(self, first, last) -> disasm_line_t - """ - return _idaapi.disasm_text_t_erase(self, *args) - - def __len__(self, *args): - """__len__(self) -> size_t""" - return _idaapi.disasm_text_t___len__(self, *args) - - def __getitem__(self, *args): - """__getitem__(self, i) -> disasm_line_t""" - return _idaapi.disasm_text_t___getitem__(self, *args) - - def __setitem__(self, *args): - """__setitem__(self, i, v)""" - return _idaapi.disasm_text_t___setitem__(self, *args) - - __iter__ = _bounded_getitem_iterator - -disasm_text_t_swigregister = _idaapi.disasm_text_t_swigregister -disasm_text_t_swigregister(disasm_text_t) - def choose_choose(*args): """ @@ -38748,7 +43943,7 @@ DP_INSIDE = 0x0010 # this flag alone cannot be used to determine orientation DP_BEFORE = 0x0020 # used with combination of other flags -DP_TAB = 0x0040 +DP_RAW = 0x0040 DP_FLOATING = 0x0080 # ---------------------------------------------------------------------- @@ -38799,17 +43994,6 @@ def askseg(defval, format): else: return None -# ---------------------------------------------------------------------- -class action_handler_t: - def __init__(self): - pass - - def activate(self, ctx): - return 0 - - def update(self, ctx): - pass - class Choose2(object): @@ -38820,18 +44004,22 @@ class Choose2(object): """ CH_MODAL = 0x01 - """Modal chooser""" + """ + Modal chooser + """ CH_MULTI = 0x02 - """Allow multi selection""" + """ + Allow multi selection + """ CH_MULTI_EDIT = 0x04 CH_NOBTNS = 0x08 CH_ATTRS = 0x10 CH_NOIDB = 0x20 - """use the chooser even without an open database, same as x0=-2""" - CH_UTF8 = 0x40 - """string encoding is utf-8""" + """ + use the chooser even without an open database, same as x0=-2 + """ CH_BUILTIN_MASK = 0xF80000 @@ -38919,17 +44107,23 @@ class Choose2(object): def Activate(self): - """Activates a visible chooser""" + """ + Activates a visible chooser + """ return _idaapi.choose2_activate(self) def Refresh(self): - """Causes the refresh callback to trigger""" + """ + Causes the refresh callback to trigger + """ return _idaapi.choose2_refresh(self) def Close(self): - """Closes the chooser""" + """ + Closes the chooser + """ return _idaapi.choose2_close(self) @@ -38940,11 +44134,12 @@ class Choose2(object): icon = -1, emb=None): """ - Deprecated: Use - - register_action() - - attach_action_to_menu() - - attach_action_to_popup() + Adds a new chooser command + Save the returned value and later use it in the OnCommand handler + + @return: Returns a negative value on failure or the command index """ + # Use the 'emb' as a sentinel. It will be passed the correct value from the EmbeddedChooserControl if self.embedded and ((emb is None) or (emb != 2002)): raise RuntimeError("Please add a command through EmbeddedChooserControl.AddCommand()") @@ -39081,21 +44276,35 @@ except: # ----------------------------------------------------------------------- # textctrl_info_t clinked object class textctrl_info_t(py_clinked_object_t): - """Class representing textctrl_info_t""" + """ + Class representing textctrl_info_t + """ # Some constants TXTF_AUTOINDENT = 0x0001 - """Auto-indent on new line""" + """ + Auto-indent on new line + """ TXTF_ACCEPTTABS = 0x0002 - """Tab key inserts 'tabsize' spaces""" + """ + Tab key inserts 'tabsize' spaces + """ TXTF_READONLY = 0x0004 - """Text cannot be edited (but can be selected and copied)""" + """ + Text cannot be edited (but can be selected and copied) + """ TXTF_SELECTED = 0x0008 - """Shows the field with its text selected""" + """ + Shows the field with its text selected + """ TXTF_MODIFIED = 0x0010 - """Gets/sets the modified status""" + """ + Gets/sets the modified status + """ TXTF_FIXEDFONT = 0x0020 - """The control uses IDA's fixed font""" + """ + The control uses IDA's fixed font + """ def __init__(self, text="", flags=0, tabsize=0): py_clinked_object_t.__init__(self) @@ -39116,90 +44325,156 @@ class textctrl_info_t(py_clinked_object_t): return _idaapi.textctrl_info_t_get_clink_ptr(self) def assign(self, other): - """Copies the contents of 'other' to 'self'""" + """ + Copies the contents of 'other' to 'self' + """ return _idaapi.textctrl_info_t_assign(self, other) def __set_text(self, s): - """Sets the text value""" + """ + Sets the text value + """ return _idaapi.textctrl_info_t_set_text(self, s) def __get_text(self): - """Sets the text value""" + """ + Sets the text value + """ return _idaapi.textctrl_info_t_get_text(self) def __set_flags__(self, flags): - """Sets the flags value""" + """ + Sets the flags value + """ return _idaapi.textctrl_info_t_set_flags(self, flags) def __get_flags__(self): - """Returns the flags value""" + """ + Returns the flags value + """ return _idaapi.textctrl_info_t_get_flags(self) def __set_tabsize__(self, tabsize): - """Sets the tabsize value""" + """ + Sets the tabsize value + """ return _idaapi.textctrl_info_t_set_tabsize(self, tabsize) def __get_tabsize__(self): - """Returns the tabsize value""" + """ + Returns the tabsize value + """ return _idaapi.textctrl_info_t_get_tabsize(self) value = property(__get_text, __set_text) - """Alias for the text property""" + """ + Alias for the text property + """ text = property(__get_text, __set_text) - """Text value""" + """ + Text value + """ flags = property(__get_flags__, __set_flags__) - """Flags value""" + """ + Flags value + """ tabsize = property(__get_tabsize__, __set_tabsize__) # ----------------------------------------------------------------------- class Form(object): FT_ASCII = 'A' - """Ascii string - char *""" + """ + Ascii string - char * + """ FT_SEG = 'S' - """Segment - sel_t *""" + """ + Segment - sel_t * + """ FT_HEX = 'N' - """Hex number - uval_t *""" + """ + Hex number - uval_t * + """ FT_SHEX = 'n' - """Signed hex number - sval_t *""" + """ + Signed hex number - sval_t * + """ FT_COLOR = 'K' - """Color button - bgcolor_t *""" + """ + Color button - bgcolor_t * + """ FT_ADDR = '$' - """Address - ea_t *""" + """ + Address - ea_t * + """ FT_UINT64 = 'L' - """default base uint64 - uint64""" + """ + default base uint64 - uint64 + """ FT_INT64 = 'l' - """default base int64 - int64""" + """ + default base int64 - int64 + """ FT_RAWHEX = 'M' - """Hex number, no 0x prefix - uval_t *""" + """ + Hex number, no 0x prefix - uval_t * + """ FT_FILE = 'f' - """File browse - char * at least QMAXPATH""" + """ + File browse - char * at least QMAXPATH + """ FT_DEC = 'D' - """Decimal number - sval_t *""" + """ + Decimal number - sval_t * + """ FT_OCT = 'O' - """Octal number, C notation - sval_t *""" + """ + Octal number, C notation - sval_t * + """ FT_BIN = 'Y' - """Binary number, 0b prefix - sval_t *""" + """ + Binary number, 0b prefix - sval_t * + """ FT_CHAR = 'H' - """Char value -- sval_t *""" + """ + Char value -- sval_t * + """ FT_IDENT = 'I' - """Identifier - char * at least MAXNAMELEN""" + """ + Identifier - char * at least MAXNAMELEN + """ FT_BUTTON = 'B' - """Button - def handler(code)""" + """ + Button - def handler(code) + """ FT_DIR = 'F' - """Path to directory - char * at least QMAXPATH""" + """ + Path to directory - char * at least QMAXPATH + """ FT_TYPE = 'T' - """Type declaration - char * at least MAXSTR""" + """ + Type declaration - char * at least MAXSTR + """ _FT_USHORT = '_US' - """Unsigned short""" + """ + Unsigned short + """ FT_FORMCHG = '%/' - """Form change callback - formchgcb_t""" + """ + Form change callback - formchgcb_t + """ FT_ECHOOSER = 'E' - """Embedded chooser - idaapi.Choose2""" + """ + Embedded chooser - idaapi.Choose2 + """ FT_MULTI_LINE_TEXT = 't' - """Multi text control - textctrl_info_t""" + """ + Multi text control - textctrl_info_t + """ FT_DROPDOWN_LIST = 'b' - """Dropdown list control - Form.DropdownControl""" + """ + Dropdown list control - Form.DropdownControl + """ FT_CHKGRP = 'C' FT_CHKGRP2= 'c' @@ -39275,13 +44550,19 @@ class Form(object): class Control(object): def __init__(self): self.id = 0 - """Automatically assigned control ID""" + """ + Automatically assigned control ID + """ self.arg = None - """Control argument value. This could be one element or a list/tuple (for multiple args per control)""" + """ + Control argument value. This could be one element or a list/tuple (for multiple args per control) + """ self.form = None - """Reference to the parent form. It is filled by Form.Add()""" + """ + Reference to the parent form. It is filled by Form.Add() + """ def get_tag(self): @@ -39394,7 +44675,9 @@ class Form(object): self.parent.value = pv checked = property(__get_value, __set_value) - """Get/Sets checkbox item check status""" + """ + Get/Sets checkbox item check status + """ class RadGroupItemControl(GroupItemControl): @@ -39411,7 +44694,9 @@ class Form(object): self.parent.value = self.pos selected = property(__get_value, __set_value) - """Get/Sets radiobox item selection status""" + """ + Get/Sets radiobox item selection status + """ class GroupControl(Control, NumericArgument): @@ -39728,7 +45013,9 @@ class Form(object): value = property(lambda self: self.chooser) - """Returns the embedded chooser instance""" + """ + Returns the embedded chooser instance + """ def AddCommand(self, @@ -39836,7 +45123,9 @@ class Form(object): def set_items(self, items): - """Sets the dropdown list items""" + """ + Sets the dropdown list items + """ self.from_list(items) @@ -39874,7 +45163,7 @@ class Form(object): def __init__(self, form, controls): """ Contruct a Form class. - This class wraps around AskUsingForm() or OpenForm() and provides an easier / alternative syntax for describing forms. + This class wraps around AskUsingForm() and provides an easier / alternative syntax for describing forms. The form control names are wrapped inside the opening and closing curly braces and the control themselves are defined and instantiated via various form controls (subclasses of Form). @@ -39883,21 +45172,18 @@ class Form(object): """ self._reset() self.form = form - """Form string""" + """ + Form string + """ self.controls = controls - """Dictionary of controls""" + """ + Dictionary of controls + """ self.__args = None self.title = None - """The Form title. It will be filled when the form is compiled""" - - self.modal = True - """By default, forms are modal""" - - self.openform_flags = 0 """ - If non-modal, these flags will be passed to OpenForm. - This is an OR'ed combination of the PluginForm.FORM_* values. + The Form title. It will be filled when the form is compiled """ @@ -39915,9 +45201,6 @@ class Form(object): # (Note that we are not removing the form control attributes, no need) self._reset() - # Unregister, so we don't try and free it again at closing-time. - _idaapi.py_unregister_compiled_form(self) - def _reset(self): """ @@ -39928,7 +45211,9 @@ class Form(object): def __getitem__(self, name): - """Returns a control object by name""" + """ + Returns a control object by name + """ return self.__controls[name] @@ -40034,11 +45319,6 @@ class Form(object): """ # First argument is the form string args = [None] - - # Second argument, if form is not modal, is the set of flags - if not self.modal: - args.append(self.openform_flags | 0x80) # Add FORM_QWIDGET - ctrlcnt = 1 # Reset all group control internal flags @@ -40121,22 +45401,6 @@ class Form(object): ctrlcnt += 1 - # If no FormChangeCb instance was passed, and thus there's no '%/' - # in the resulting form string, let's provide a minimal one, so that - # we will retrieve 'p_fa', and thus actions that rely on it will work. - if form.find(Form.FT_FORMCHG) < 0: - form = form + Form.FT_FORMCHG - fccb = Form.FormChangeCb(lambda *args: 1) - self.Add("___dummyfchgcb", fccb) - # Regardless of the actual position of '%/' in the form - # string, a formchange callback _must_ be right after - # the form string. - if self.modal: - inspos = 1 - else: - inspos = 2 - args.insert(inspos, fccb.get_arg()) - # Patch in the final form string args[0] = form @@ -40161,9 +45425,6 @@ class Form(object): # Compile form and get args self.__args = self.CompileEx(self.form) - # Register this form, to make sure it will be freed at closing-time. - _idaapi.py_register_compiled_form(self) - return (self, self.__args) @@ -40176,34 +45437,18 @@ class Form(object): return self.__args is not None - def _ChkCompiled(self): + def Execute(self): + """ + Displays a compiled form. + @return: 1 - ok ; 0 - cancel + """ if not self.Compiled(): raise SyntaxError("Form is not compiled") - - def Execute(self): - """ - Displays a modal dialog containing the compiled form. - @return: 1 - ok ; 0 - cancel - """ - self._ChkCompiled() - if not self.modal: - raise SyntaxError("Form is not modal. Open() should be instead") - + # Call AskUsingForm() return AskUsingForm(*self.__args) - def Open(self): - """ - Opens a widget containing the compiled form. - """ - self._ChkCompiled() - if self.modal: - raise SyntaxError("Form is modal. Execute() should be instead") - - OpenForm(*self.__args) - - def EnableField(self, ctrl, enable): """ Enable or disable an input field @@ -40346,18 +45591,15 @@ try: # Setup the numeric argument size Form.NumericArgument.DefI64 = _idaapi.BADADDR == 0xFFFFFFFFFFFFFFFFL AskUsingForm__ = ctypes.CFUNCTYPE(ctypes.c_long)(_idaapi.py_get_AskUsingForm()) - OpenForm__ = ctypes.CFUNCTYPE(ctypes.c_long)(_idaapi.py_get_OpenForm()) except: def AskUsingForm__(*args): warning("AskUsingForm() needs ctypes library in order to work") return 0 - def OpenForm__(*args): - warning("OpenForm() needs ctypes library in order to work") def AskUsingForm(*args): """ - Calls AskUsingForm() + Calls the AskUsingForm() @param: Compiled Arguments obtain through the Form.Compile() function @return: 1 = ok, 0 = cancel """ @@ -40366,15 +45608,6 @@ def AskUsingForm(*args): set_script_timeout(old) return r -def OpenForm(*args): - """ - Calls OpenForm() - @param: Compiled Arguments obtain through the Form.Compile() function - """ - old = set_script_timeout(0) - r = OpenForm__(*args) - set_script_timeout(old) - # @@ -40387,19 +45620,33 @@ class PluginForm(object): """ FORM_MDI = 0x01 - """start by default as MDI (obsolete)""" + """ + start by default as MDI (obsolete) + """ FORM_TAB = 0x02 - """attached by default to a tab""" + """ + attached by default to a tab + """ FORM_RESTORE = 0x04 - """restore state from desktop config""" + """ + restore state from desktop config + """ FORM_ONTOP = 0x08 - """form should be "ontop""" + """ + form should be "ontop + """ FORM_MENU = 0x10 - """form must be listed in the windows menu (automatically set for all plugins)""" + """ + form must be listed in the windows menu (automatically set for all plugins) + """ FORM_CENTERED = 0x20 - """form will be centered on the screen""" + """ + form will be centered on the screen + """ FORM_PERSIST = 0x40 - """form will persist until explicitly closed with Close()""" + """ + form will persist until explicitly closed with Close() + """ def __init__(self): @@ -40483,16 +45730,24 @@ class PluginForm(object): return _idaapi.plgform_close(self.__clink__, options) FORM_SAVE = 0x1 - """Save state in desktop config""" + """ + Save state in desktop config + """ FORM_NO_CONTEXT = 0x2 - """Don't change the current context (useful for toolbars)""" + """ + Don't change the current context (useful for toolbars) + """ FORM_DONT_SAVE_SIZE = 0x4 - """Don't save size of the window""" + """ + Don't save size of the window + """ FORM_CLOSE_LATER = 0x8 - """This flag should be used when Close() is called from an event handler""" + """ + This flag should be used when Close() is called from an event handler + """ # class Choose: @@ -40686,12 +45941,16 @@ class cli_t(pyidc_opaque_object_t): # # class simplecustviewer_t(object): - """The base class for implementing simple custom viewers""" + """ + The base class for implementing simple custom viewers + """ def __init__(self): self.__this = None def __del__(self): - """Destructor. It also frees the associated C++ object""" + """ + Destructor. It also frees the associated C++ object + """ try: _idaapi.pyscv_delete(self.__this) except: @@ -40733,11 +45992,15 @@ class simplecustviewer_t(object): return _idaapi.pyscv_refresh(self.__this) def RefreshCurrent(self): - """Refreshes the current line only""" + """ + Refreshes the current line only + """ return _idaapi.pyscv_refresh_current(self.__this) def Count(self): - """Returns the number of lines in the view""" + """ + Returns the number of lines in the view + """ return _idaapi.pyscv_count(self.__this) def GetSelection(self): @@ -40750,7 +46013,9 @@ class simplecustviewer_t(object): return _idaapi.pyscv_get_selection(self.__this) def ClearLines(self): - """Clears all the lines""" + """ + Clears all the lines + """ _idaapi.pyscv_clear_lines(self.__this) def AddLine(self, line, fgcolor=None, bgcolor=None): @@ -40775,7 +46040,9 @@ class simplecustviewer_t(object): return _idaapi.pyscv_edit_line(self.__this, lineno, self.__make_sl_arg(line, fgcolor, bgcolor)) def PatchLine(self, lineno, offs, value): - """Patches an existing line character at the given offset. This is a low level function. You must know what you're doing""" + """ + Patches an existing line character at the given offset. This is a low level function. You must know what you're doing + """ return _idaapi.pyscv_patch_line(self.__this, lineno, offs, value) def DelLine(self, lineno): @@ -40820,7 +46087,9 @@ class simplecustviewer_t(object): return _idaapi.pyscv_get_pos(self.__this, mouse) def GetLineNo(self, mouse = 0): - """Calls GetPos() and returns the current line number or -1 on failure""" + """ + Calls GetPos() and returns the current line number or -1 on failure + """ r = self.GetPos(mouse) return -1 if not r else r[0] @@ -40845,27 +46114,11 @@ class simplecustviewer_t(object): _idaapi.pyscv_clear_popup_menu(self.__this) def IsFocused(self): - """Returns True if the current view is the focused view""" + """ + Returns True if the current view is the focused view + """ return _idaapi.pyscv_is_focused(self.__this) - def GetTForm(self): - """ - Return the TForm hosting this view. - - @return: The TForm that hosts this view, or None. - """ - return _idaapi.pyscv_get_tform(self.__this) - - def GetTCustomControl(self): - """ - Return the TCustomControl underlying this view. - - @return: The TCustomControl underlying this view, or None. - """ - return _idaapi.pyscv_get_tcustom_control(self.__this) - - - # Here are all the supported events # # def OnClick(self, shift): @@ -40988,7 +46241,9 @@ SCOLOR_COLLAPSED = _idaapi.SCOLOR_COLLAPSED SCOLOR_ADDR = _idaapi.SCOLOR_ADDR def tag_strlen(*args): - """tag_strlen(line) -> ssize_t""" + """ + tag_strlen(line) -> ssize_t + """ return _idaapi.tag_strlen(*args) COLOR_SELECTED = _idaapi.COLOR_SELECTED COLOR_LIBFUNC = _idaapi.COLOR_LIBFUNC @@ -41003,21 +46258,29 @@ COLOR_HIDLINE = _idaapi.COLOR_HIDLINE COLOR_BG_MAX = _idaapi.COLOR_BG_MAX def calc_prefix_color(*args): - """calc_prefix_color(ea) -> color_t""" + """ + calc_prefix_color(ea) -> color_t + """ return _idaapi.calc_prefix_color(*args) def calc_bg_color(*args): - """calc_bg_color(ea) -> bgcolor_t""" + """ + calc_bg_color(ea) -> bgcolor_t + """ return _idaapi.calc_bg_color(*args) class bgcolors_t(object): - """Proxy of C++ bgcolors_t class""" + """ + Proxy of C++ bgcolors_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr prolog_color = _swig_property(_idaapi.bgcolors_t_prolog_color_get, _idaapi.bgcolors_t_prolog_color_set) epilog_color = _swig_property(_idaapi.bgcolors_t_epilog_color_get, _idaapi.bgcolors_t_epilog_color_set) switch_color = _swig_property(_idaapi.bgcolors_t_switch_color_get, _idaapi.bgcolors_t_switch_color_set) - def __init__(self, *args): - """__init__(self) -> bgcolors_t""" + def __init__(self, *args): + """ + __init__(self) -> bgcolors_t + """ this = _idaapi.new_bgcolors_t(*args) try: self.this.append(this) except: self.this = this @@ -41077,121 +46340,215 @@ COLOR_RESERVED1 = cvar.COLOR_RESERVED1 def add_sourcefile(*args): - """add_sourcefile(ea1, ea2, filename) -> bool""" + """ + add_sourcefile(ea1, ea2, filename) -> bool + """ return _idaapi.add_sourcefile(*args) def get_sourcefile(*args): - """get_sourcefile(ea, bounds=None) -> char const *""" + """ + get_sourcefile(ea, bounds=None) -> char const * + """ return _idaapi.get_sourcefile(*args) def del_sourcefile(*args): - """del_sourcefile(ea) -> bool""" + """ + del_sourcefile(ea) -> bool + """ return _idaapi.del_sourcefile(*args) def MakeLine(*args): - """MakeLine(contents, indent=-1) -> bool""" + """ + MakeLine(contents, indent=-1) -> bool + """ return _idaapi.MakeLine(*args) def printf_line(*args): - """printf_line(indent, format) -> bool""" + """ + printf_line(indent, format) -> bool + """ return _idaapi.printf_line(*args) def MakeNull(*args): - """MakeNull() -> bool""" + """ + MakeNull() -> bool + """ return _idaapi.MakeNull(*args) def MakeBorder(*args): - """MakeBorder() -> bool""" + """ + MakeBorder() -> bool + """ return _idaapi.MakeBorder(*args) def MakeSolidBorder(*args): - """MakeSolidBorder() -> bool""" + """ + MakeSolidBorder() -> bool + """ return _idaapi.MakeSolidBorder(*args) def gen_cmt_line(*args): - """gen_cmt_line(format) -> bool""" + """ + gen_cmt_line(format) -> bool + """ return _idaapi.gen_cmt_line(*args) def gen_collapsed_line(*args): - """gen_collapsed_line(format) -> bool""" + """ + gen_collapsed_line(format) -> bool + """ return _idaapi.gen_collapsed_line(*args) def generate_big_comment(*args): - """generate_big_comment(cmt, color) -> bool""" + """ + generate_big_comment(cmt, color) -> bool + """ return _idaapi.generate_big_comment(*args) def generate_many_lines(*args): - """generate_many_lines(string, color) -> bool""" + """ + generate_many_lines(string, color) -> bool + """ return _idaapi.generate_many_lines(*args) def describe(*args): - """describe(ea, isprev, format)""" + """ + describe(ea, isprev, format) + """ return _idaapi.describe(*args) def add_long_cmt(*args): - """add_long_cmt(ea, isprev, format)""" + """ + add_long_cmt(ea, isprev, format) + """ return _idaapi.add_long_cmt(*args) def add_pgm_cmt(*args): - """add_pgm_cmt(format)""" + """ + add_pgm_cmt(format) + """ return _idaapi.add_pgm_cmt(*args) def generate_disasm_line(*args): - """generate_disasm_line(ea, flags=0) -> bool""" + """ + generate_disasm_line(ea, flags=0) -> bool + """ return _idaapi.generate_disasm_line(*args) GENDSM_FORCE_CODE = _idaapi.GENDSM_FORCE_CODE GENDSM_MULTI_LINE = _idaapi.GENDSM_MULTI_LINE def get_first_free_extra_cmtidx(*args): - """get_first_free_extra_cmtidx(ea, start) -> int""" + """ + get_first_free_extra_cmtidx(ea, start) -> int + """ return _idaapi.get_first_free_extra_cmtidx(*args) def update_extra_cmt(*args): - """update_extra_cmt(ea, what, str)""" + """ + update_extra_cmt(ea, what, str) + """ return _idaapi.update_extra_cmt(*args) def del_extra_cmt(*args): - """del_extra_cmt(ea, what)""" + """ + del_extra_cmt(ea, what) + """ return _idaapi.del_extra_cmt(*args) def get_extra_cmt(*args): - """get_extra_cmt(ea, what) -> ssize_t""" + """ + get_extra_cmt(ea, what) -> ssize_t + """ return _idaapi.get_extra_cmt(*args) def delete_extra_cmts(*args): - """delete_extra_cmts(ea, cmtidx)""" + """ + delete_extra_cmts(ea, cmtidx) + """ return _idaapi.delete_extra_cmts(*args) def ExtraFree(*args): - """ExtraFree(ea, start) -> int""" + """ + ExtraFree(ea, start) -> int + """ return _idaapi.ExtraFree(*args) def set_user_defined_prefix(*args): - """set_user_defined_prefix(width, pycb) -> PyObject *""" + """ + set_user_defined_prefix(width, pycb) -> PyObject * + + + User-defined line-prefixes are displayed just after the autogenerated + line prefixes. In order to use them, the plugin should call the + following function to specify its width and contents. + @param width: the width of the user-defined prefix + @param callback: a get_user_defined_prefix callback to get the contents of the prefix. + Its arguments: + ea - linear address + lnnum - line number + indent - indent of the line contents (-1 means the default instruction) + indent and is used for instruction itself. see explanations for printf_line() + line - the line to be generated. the line usually contains color tags this argument + can be examined to decide whether to generated the prefix + bufsize- the maximum allowed size of the output buffer + It returns a buffer of size < bufsize + + In order to remove the callback before unloading the plugin, specify the width = 0 or the callback = None + """ return _idaapi.set_user_defined_prefix(*args) def tag_remove(*args): - """tag_remove(instr) -> PyObject *""" + """ + tag_remove(instr) -> PyObject * + + + Remove color escape sequences from a string + @param colstr: the colored string with embedded tags + @return: + None on failure + or a new string w/o the tags + """ return _idaapi.tag_remove(*args) def tag_addr(*args): - """tag_addr(ea) -> PyObject *""" + """ + tag_addr(ea) -> PyObject * + """ return _idaapi.tag_addr(*args) def tag_skipcode(*args): - """tag_skipcode(line) -> int""" + """ + tag_skipcode(line) -> int + """ return _idaapi.tag_skipcode(*args) def tag_skipcodes(*args): - """tag_skipcodes(line) -> int""" + """ + tag_skipcodes(line) -> int + """ return _idaapi.tag_skipcodes(*args) def tag_advance(*args): - """tag_advance(line, cnt) -> int""" + """ + tag_advance(line, cnt) -> int + """ return _idaapi.tag_advance(*args) def generate_disassembly(*args): - """generate_disassembly(ea, max_lines, as_stack, notags) -> PyObject *""" + """ + generate_disassembly(ea, max_lines, as_stack, notags) -> PyObject * + + + Generate disassembly lines (many lines) and put them into a buffer + + @param ea: address to generate disassembly for + @param max_lines: how many lines max to generate + @param as_stack: Display undefined items as 2/4/8 bytes + @return: + - None on failure + - tuple(most_important_line_number, tuple(lines)) : Returns a tuple containing + the most important line number and a tuple of generated lines + """ return _idaapi.generate_disassembly(*args) # @@ -41231,14 +46588,18 @@ def COLSTR(str, tag): MAX_FILE_FORMAT_NAME = _idaapi.MAX_FILE_FORMAT_NAME class loader_t(object): - """Proxy of C++ loader_t class""" + """ + Proxy of C++ loader_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr version = _swig_property(_idaapi.loader_t_version_get, _idaapi.loader_t_version_set) flags = _swig_property(_idaapi.loader_t_flags_get, _idaapi.loader_t_flags_set) _UNUSED1_was_init_loader_options = _swig_property(_idaapi.loader_t__UNUSED1_was_init_loader_options_get, _idaapi.loader_t__UNUSED1_was_init_loader_options_set) - def __init__(self, *args): - """__init__(self) -> loader_t""" + def __init__(self, *args): + """ + __init__(self) -> loader_t + """ this = _idaapi.new_loader_t(*args) try: self.this.append(this) except: self.this = this @@ -41269,7 +46630,9 @@ LOADER_EXT = _idaapi.LOADER_EXT LOADER_DLL = _idaapi.LOADER_DLL def load_binary_file(*args): - """load_binary_file(filename, li, _neflags, fileoff, basepara, binoff, nbytes) -> bool""" + """ + load_binary_file(filename, li, _neflags, fileoff, basepara, binoff, nbytes) -> bool + """ return _idaapi.load_binary_file(*args) OFILE_MAP = _idaapi.OFILE_MAP OFILE_EXE = _idaapi.OFILE_EXE @@ -41279,7 +46642,9 @@ OFILE_ASM = _idaapi.OFILE_ASM OFILE_DIF = _idaapi.OFILE_DIF def gen_file(*args): - """gen_file(otype, fp, ea1, ea2, flags) -> int""" + """ + gen_file(otype, fp, ea1, ea2, flags) -> int + """ return _idaapi.gen_file(*args) GENFLG_MAPSEG = _idaapi.GENFLG_MAPSEG GENFLG_MAPNAME = _idaapi.GENFLG_MAPNAME @@ -41291,45 +46656,69 @@ GENFLG_GENHTML = _idaapi.GENFLG_GENHTML GENFLG_ASMINC = _idaapi.GENFLG_ASMINC def file2base(*args): - """file2base(li, pos, ea1, ea2, patchable) -> int""" + """ + file2base(li, pos, ea1, ea2, patchable) -> int + """ return _idaapi.file2base(*args) FILEREG_PATCHABLE = _idaapi.FILEREG_PATCHABLE FILEREG_NOTPATCHABLE = _idaapi.FILEREG_NOTPATCHABLE def base2file(*args): - """base2file(fp, pos, ea1, ea2) -> int""" + """ + base2file(fp, pos, ea1, ea2) -> int + """ return _idaapi.base2file(*args) +def load_loader_module(*args): + """ + load_loader_module(li, lname, fname, is_remote) -> int + """ + return _idaapi.load_loader_module(*args) + def extract_module_from_archive(*args): - """extract_module_from_archive(filename, bufsize, is_remote, temp_file_ptr) -> bool""" + """ + extract_module_from_archive(filename, bufsize, is_remote, temp_file_ptr) -> bool + """ return _idaapi.extract_module_from_archive(*args) def get_basic_file_type(*args): - """get_basic_file_type(li) -> filetype_t""" + """ + get_basic_file_type(li) -> filetype_t + """ return _idaapi.get_basic_file_type(*args) def get_file_type_name(*args): - """get_file_type_name() -> size_t""" + """ + get_file_type_name() -> size_t + """ return _idaapi.get_file_type_name(*args) def load_ids_module(*args): - """load_ids_module(fname) -> int""" + """ + load_ids_module(fname) -> int + """ return _idaapi.load_ids_module(*args) def get_plugin_options(*args): - """get_plugin_options(plugin) -> char const *""" + """ + get_plugin_options(plugin) -> char const * + """ return _idaapi.get_plugin_options(*args) PLUGIN_EXT = _idaapi.PLUGIN_EXT PLUGIN_DLL = _idaapi.PLUGIN_DLL class idp_name_t(object): - """Proxy of C++ idp_name_t class""" + """ + Proxy of C++ idp_name_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr lname = _swig_property(_idaapi.idp_name_t_lname_get, _idaapi.idp_name_t_lname_set) sname = _swig_property(_idaapi.idp_name_t_sname_get, _idaapi.idp_name_t_sname_set) hidden = _swig_property(_idaapi.idp_name_t_hidden_get, _idaapi.idp_name_t_hidden_set) - def __init__(self, *args): - """__init__(self) -> idp_name_t""" + def __init__(self, *args): + """ + __init__(self) -> idp_name_t + """ this = _idaapi.new_idp_name_t(*args) try: self.this.append(this) except: self.this = this @@ -41339,7 +46728,9 @@ idp_name_t_swigregister = _idaapi.idp_name_t_swigregister idp_name_t_swigregister(idp_name_t) class idp_desc_t(object): - """Proxy of C++ idp_desc_t class""" + """ + Proxy of C++ idp_desc_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr path = _swig_property(_idaapi.idp_desc_t_path_get, _idaapi.idp_desc_t_path_set) @@ -41348,8 +46739,10 @@ class idp_desc_t(object): names = _swig_property(_idaapi.idp_desc_t_names_get, _idaapi.idp_desc_t_names_set) is_script = _swig_property(_idaapi.idp_desc_t_is_script_get, _idaapi.idp_desc_t_is_script_set) checked = _swig_property(_idaapi.idp_desc_t_checked_get, _idaapi.idp_desc_t_checked_set) - def __init__(self, *args): - """__init__(self) -> idp_desc_t""" + def __init__(self, *args): + """ + __init__(self) -> idp_desc_t + """ this = _idaapi.new_idp_desc_t(*args) try: self.this.append(this) except: self.this = this @@ -41362,23 +46755,33 @@ IDP_EXT = _idaapi.IDP_EXT IDP_DLL = _idaapi.IDP_DLL def load_and_run_plugin(*args): - """load_and_run_plugin(name, arg) -> bool""" + """ + load_and_run_plugin(name, arg) -> bool + """ return _idaapi.load_and_run_plugin(*args) def get_fileregion_offset(*args): - """get_fileregion_offset(ea) -> int32""" + """ + get_fileregion_offset(ea) -> int32 + """ return _idaapi.get_fileregion_offset(*args) def get_fileregion_ea(*args): - """get_fileregion_ea(offset) -> ea_t""" + """ + get_fileregion_ea(offset) -> ea_t + """ return _idaapi.get_fileregion_ea(*args) def gen_exe_file(*args): - """gen_exe_file(fp) -> int""" + """ + gen_exe_file(fp) -> int + """ return _idaapi.gen_exe_file(*args) def reload_file(*args): - """reload_file(file, is_remote) -> int""" + """ + reload_file(file, is_remote) -> int + """ return _idaapi.reload_file(*args) MAX_DATABASE_DESCRIPTION = _idaapi.MAX_DATABASE_DESCRIPTION SSUF_DESC = _idaapi.SSUF_DESC @@ -41386,15 +46789,21 @@ SSUF_PATH = _idaapi.SSUF_PATH SSUF_FLAGS = _idaapi.SSUF_FLAGS def flush_buffers(*args): - """flush_buffers() -> int""" + """ + flush_buffers() -> int + """ return _idaapi.flush_buffers(*args) def is_trusted_idb(*args): - """is_trusted_idb() -> bool""" + """ + is_trusted_idb() -> bool + """ return _idaapi.is_trusted_idb(*args) def save_database_ex(*args): - """save_database_ex(outfile, flags, root=None, attr=None) -> bool""" + """ + save_database_ex(outfile, flags, root=None, attr=None) -> bool + """ return _idaapi.save_database_ex(*args) DBFL_KILL = _idaapi.DBFL_KILL DBFL_COMP = _idaapi.DBFL_COMP @@ -41402,42 +46811,75 @@ DBFL_BAK = _idaapi.DBFL_BAK DBFL_TEMP = _idaapi.DBFL_TEMP def save_database(*args): - """save_database(outfile, delete_unpacked) -> bool""" + """ + save_database(outfile, delete_unpacked) -> bool + """ return _idaapi.save_database(*args) -def load_loader_module(*args): - """load_loader_module(li, lname, fname, is_remote) -> int""" - return _idaapi.load_loader_module(*args) - def mem2base(*args): - """mem2base(py_mem, ea, fpos=-1) -> int""" + """ + mem2base(py_mem, ea, fpos=-1) -> int + + + Load database from the memory. + @param mem: the buffer + @param ea: start linear addresses + @param fpos: position in the input file the data is taken from. + if == -1, then no file position correspond to the data. + @return: + - Returns zero if the passed buffer was not a string + - Otherwise 1 is returned + """ return _idaapi.mem2base(*args) def load_plugin(*args): - """load_plugin(name) -> PyObject *""" + """ + load_plugin(name) -> PyObject * + + + Loads a plugin + @return: + - None if plugin could not be loaded + - An opaque object representing the loaded plugin + """ return _idaapi.load_plugin(*args) def run_plugin(*args): - """run_plugin(plg, arg) -> bool""" + """ + run_plugin(plg, arg) -> bool + + + Runs a plugin + @param plg: A plugin object (returned by load_plugin()) + @return: Boolean + """ return _idaapi.run_plugin(*args) class graph_location_info_t(object): - """Proxy of C++ graph_location_info_t class""" + """ + Proxy of C++ graph_location_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr zoom = _swig_property(_idaapi.graph_location_info_t_zoom_get, _idaapi.graph_location_info_t_zoom_set) orgx = _swig_property(_idaapi.graph_location_info_t_orgx_get, _idaapi.graph_location_info_t_orgx_set) orgy = _swig_property(_idaapi.graph_location_info_t_orgy_get, _idaapi.graph_location_info_t_orgy_set) - def __init__(self, *args): - """__init__(self) -> graph_location_info_t""" + def __init__(self, *args): + """ + __init__(self) -> graph_location_info_t + """ this = _idaapi.new_graph_location_info_t(*args) try: self.this.append(this) except: self.this = this def __eq__(self, *args): - """__eq__(self, r) -> bool""" + """ + __eq__(self, r) -> bool + """ return _idaapi.graph_location_info_t___eq__(self, *args) def __ne__(self, *args): - """__ne__(self, r) -> bool""" + """ + __ne__(self, r) -> bool + """ return _idaapi.graph_location_info_t___ne__(self, *args) __swig_destroy__ = _idaapi.delete_graph_location_info_t @@ -41448,7 +46890,9 @@ graph_location_info_t_swigregister(graph_location_info_t) CURLOC_SISTACK_ITEMS = _idaapi.CURLOC_SISTACK_ITEMS CURLOC_LIST = _idaapi.CURLOC_LIST class curloc(object): - """Proxy of C++ curloc class""" + """ + Proxy of C++ curloc class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr ea = _swig_property(_idaapi.curloc_ea_get, _idaapi.curloc_ea_set) @@ -41457,7 +46901,7 @@ class curloc(object): lnnum = _swig_property(_idaapi.curloc_lnnum_get, _idaapi.curloc_lnnum_set) flags = _swig_property(_idaapi.curloc_flags_get, _idaapi.curloc_flags_set) target = _swig_property(_idaapi.curloc_target_get, _idaapi.curloc_target_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> curloc __init__(self, stackName) -> curloc @@ -41466,59 +46910,75 @@ class curloc(object): try: self.this.append(this) except: self.this = this def linkTo(self, *args): - """linkTo(self, stackName)""" + """ + linkTo(self, stackName) + """ return _idaapi.curloc_linkTo(self, *args) def setx(self, *args): - """setx(self, xx)""" + """ + setx(self, xx) + """ return _idaapi.curloc_setx(self, *args) def jump_push(self, *args): - """jump_push(self, try_to_unhide, _ea=BADADDR, _lnnum=0, _x=0, _y=0)""" + """ + jump_push(self, try_to_unhide, _ea=BADADDR, _lnnum=0, _x=0, _y=0) + """ return _idaapi.curloc_jump_push(self, *args) def pop(self, *args): - """pop(self, try_tohide) -> bool""" + """ + pop(self, try_tohide) -> bool + """ return _idaapi.curloc_pop(self, *args) def get(self, *args): - """get(self, depth) -> bool""" + """ + get(self, depth) -> bool + """ return _idaapi.curloc_get(self, *args) def get_entry(self, *args): - """get_entry(self, out, depth) -> bool""" + """ + get_entry(self, out, depth) -> bool + """ return _idaapi.curloc_get_entry(self, *args) def size(self, *args): - """size(self) -> size_t""" + """ + size(self) -> size_t + """ return _idaapi.curloc_size(self, *args) def copy_current_location(self, *args): - """copy_current_location(self, loc)""" + """ + copy_current_location(self, loc) + """ return _idaapi.curloc_copy_current_location(self, *args) - def unhide_if_necessary(self, *args): - """unhide_if_necessary(self, tgt)""" - return _idaapi.curloc_unhide_if_necessary(self, *args) - - def hide_if_necessary(self, *args): - """hide_if_necessary(self)""" - return _idaapi.curloc_hide_if_necessary(self, *args) - def mark(self, *args): - """mark(self, marker, title, desc) -> int""" + """ + mark(self, marker, title, desc) -> int + """ return _idaapi.curloc_mark(self, *args) def markedpos(self, *args): - """markedpos(self, marker) -> ea_t""" + """ + markedpos(self, marker) -> ea_t + """ return _idaapi.curloc_markedpos(self, *args) def jump(self, *args): - """jump(self, marker) -> bool""" + """ + jump(self, marker) -> bool + """ return _idaapi.curloc_jump(self, *args) def markdesc(self, *args): - """markdesc(self, marker) -> ssize_t""" + """ + markdesc(self, marker) -> ssize_t + """ return _idaapi.curloc_markdesc(self, *args) __swig_destroy__ = _idaapi.delete_curloc @@ -41533,11 +46993,13 @@ UNHID_AREA = _idaapi.UNHID_AREA MAX_MARK_SLOT = _idaapi.MAX_MARK_SLOT class location_t(curloc): - """Proxy of C++ location_t class""" + """ + Proxy of C++ location_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr gli = _swig_property(_idaapi.location_t_gli_get, _idaapi.location_t_gli_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> location_t __init__(self, name) -> location_t @@ -41546,39 +47008,57 @@ class location_t(curloc): try: self.this.append(this) except: self.this = this def linkTo(self, *args): - """linkTo(self, name)""" + """ + linkTo(self, name) + """ return _idaapi.location_t_linkTo(self, *args) def push_and_jump(self, *args): - """push_and_jump(self, try_to_unhide, _ea=BADADDR, _lnnum=0, _x=0, _y=0, _gli=None)""" + """ + push_and_jump(self, try_to_unhide, _ea=BADADDR, _lnnum=0, _x=0, _y=0, _gli=None) + """ return _idaapi.location_t_push_and_jump(self, *args) def pop(self, *args): - """pop(self, try_tohide) -> bool""" + """ + pop(self, try_tohide) -> bool + """ return _idaapi.location_t_pop(self, *args) def get(self, *args): - """get(self, depth) -> bool""" + """ + get(self, depth) -> bool + """ return _idaapi.location_t_get(self, *args) def get_entry(self, *args): - """get_entry(self, out, depth) -> bool""" + """ + get_entry(self, out, depth) -> bool + """ return _idaapi.location_t_get_entry(self, *args) def copy_current_location(self, *args): - """copy_current_location(self, loc)""" + """ + copy_current_location(self, loc) + """ return _idaapi.location_t_copy_current_location(self, *args) def jump_nopush(self, *args): - """jump_nopush(self, _ea=BADADDR, _lnnum=0, _x=0, _y=0, _gli=None)""" + """ + jump_nopush(self, _ea=BADADDR, _lnnum=0, _x=0, _y=0, _gli=None) + """ return _idaapi.location_t_jump_nopush(self, *args) def mark(self, *args): - """mark(self, marker, title, desc) -> int""" + """ + mark(self, marker, title, desc) -> int + """ return _idaapi.location_t_mark(self, *args) def jump(self, *args): - """jump(self, marker) -> bool""" + """ + jump(self, marker) -> bool + """ return _idaapi.location_t_jump(self, *args) __swig_destroy__ = _idaapi.delete_location_t @@ -41586,333 +47066,12 @@ class location_t(curloc): location_t_swigregister = _idaapi.location_t_swigregister location_t_swigregister(location_t) -MAXNAMELEN = _idaapi.MAXNAMELEN -FUNC_IMPORT_PREFIX = _idaapi.FUNC_IMPORT_PREFIX -SN_CHECK = _idaapi.SN_CHECK -SN_NOCHECK = _idaapi.SN_NOCHECK -SN_PUBLIC = _idaapi.SN_PUBLIC -SN_NON_PUBLIC = _idaapi.SN_NON_PUBLIC -SN_WEAK = _idaapi.SN_WEAK -SN_NON_WEAK = _idaapi.SN_NON_WEAK -SN_AUTO = _idaapi.SN_AUTO -SN_NON_AUTO = _idaapi.SN_NON_AUTO -SN_NOLIST = _idaapi.SN_NOLIST -SN_NOWARN = _idaapi.SN_NOWARN -SN_LOCAL = _idaapi.SN_LOCAL - -def set_name(*args): - """ - set_name(ea, name, flag) -> bool - set_name(ea, name) -> bool - """ - return _idaapi.set_name(*args) - -def del_global_name(*args): - """del_global_name(ea) -> bool""" - return _idaapi.del_global_name(*args) - -def del_local_name(*args): - """del_local_name(ea) -> bool""" - return _idaapi.del_local_name(*args) - -def set_dummy_name(*args): - """set_dummy_name(frm, ea) -> bool""" - return _idaapi.set_dummy_name(*args) - -def make_name_auto(*args): - """make_name_auto(ea) -> bool""" - return _idaapi.make_name_auto(*args) - -def make_name_user(*args): - """make_name_user(ea) -> bool""" - return _idaapi.make_name_user(*args) - -def do_name_anyway(*args): - """do_name_anyway(ea, name, maxlen=0) -> bool""" - return _idaapi.do_name_anyway(*args) - -def validate_name3(*args): - """validate_name3(name) -> bool""" - return _idaapi.validate_name3(*args) - -def is_ident_char(*args): - """is_ident_char(c) -> bool""" - return _idaapi.is_ident_char(*args) - -def is_visible_char(*args): - """is_visible_char(c) -> bool""" - return _idaapi.is_visible_char(*args) - -def isident(*args): - """isident(name) -> bool""" - return _idaapi.isident(*args) - -def is_uname(*args): - """is_uname(name) -> bool""" - return _idaapi.is_uname(*args) - -def is_valid_typename(*args): - """is_valid_typename(name) -> bool""" - return _idaapi.is_valid_typename(*args) - -def extract_name2(*args): - """extract_name2(line, x) -> ssize_t""" - return _idaapi.extract_name2(*args) - -def hide_name(*args): - """hide_name(ea)""" - return _idaapi.hide_name(*args) - -def show_name(*args): - """show_name(ea)""" - return _idaapi.show_name(*args) - -def get_name_ea(*args): - """get_name_ea(frm, name) -> ea_t""" - return _idaapi.get_name_ea(*args) - -def get_name_base_ea(*args): - """get_name_base_ea(frm, to) -> ea_t""" - return _idaapi.get_name_base_ea(*args) - -def get_name_value(*args): - """get_name_value(frm, name) -> int""" - return _idaapi.get_name_value(*args) -NT_NONE = _idaapi.NT_NONE -NT_BYTE = _idaapi.NT_BYTE -NT_LOCAL = _idaapi.NT_LOCAL -NT_STKVAR = _idaapi.NT_STKVAR -NT_ENUM = _idaapi.NT_ENUM -NT_ABS = _idaapi.NT_ABS -NT_SEG = _idaapi.NT_SEG -NT_STROFF = _idaapi.NT_STROFF -NT_BMASK = _idaapi.NT_BMASK -NT_REGVAR = _idaapi.NT_REGVAR -GN_VISIBLE = _idaapi.GN_VISIBLE -GN_COLORED = _idaapi.GN_COLORED -GN_DEMANGLED = _idaapi.GN_DEMANGLED -GN_STRICT = _idaapi.GN_STRICT -GN_SHORT = _idaapi.GN_SHORT -GN_LONG = _idaapi.GN_LONG -GN_LOCAL = _idaapi.GN_LOCAL -GN_INSNLOC = _idaapi.GN_INSNLOC - -def get_colored_short_name(*args): - """get_colored_short_name(ea, gtn_flags=0) -> ssize_t""" - return _idaapi.get_colored_short_name(*args) - -def get_colored_long_name(*args): - """get_colored_long_name(ea, gtn_flags=0) -> ssize_t""" - return _idaapi.get_colored_long_name(*args) - -def get_visible_name(*args): - """get_visible_name(ea, gtn_flags=0) -> qstring""" - return _idaapi.get_visible_name(*args) - -def get_short_name(*args): - """get_short_name(ea, gtn_flags=0) -> qstring""" - return _idaapi.get_short_name(*args) - -def get_long_name(*args): - """get_long_name(ea, gtn_flags=0) -> qstring""" - return _idaapi.get_long_name(*args) - -def get_name_color(*args): - """get_name_color(frm, ea) -> color_t""" - return _idaapi.get_name_color(*args) -GETN_APPZERO = _idaapi.GETN_APPZERO -GETN_NOFIXUP = _idaapi.GETN_NOFIXUP -GETN_NODUMMY = _idaapi.GETN_NODUMMY - -def get_name_expr(*args): - """get_name_expr(frm, n, ea, off, flags=0x0001) -> ssize_t""" - return _idaapi.get_name_expr(*args) - -def get_nice_colored_name(*args): - """get_nice_colored_name(ea, flags=0) -> ssize_t""" - return _idaapi.get_nice_colored_name(*args) -GNCN_NOSEG = _idaapi.GNCN_NOSEG -GNCN_NOCOLOR = _idaapi.GNCN_NOCOLOR -GNCN_NOLABEL = _idaapi.GNCN_NOLABEL -GNCN_NOFUNC = _idaapi.GNCN_NOFUNC -GNCN_SEG_FUNC = _idaapi.GNCN_SEG_FUNC -GNCN_SEGNUM = _idaapi.GNCN_SEGNUM -GNCN_REQFUNC = _idaapi.GNCN_REQFUNC -GNCN_REQNAME = _idaapi.GNCN_REQNAME -GNCN_NODBGNM = _idaapi.GNCN_NODBGNM - -def append_struct_fields2(*args): - """append_struct_fields2(n, path, plen, flags, disp, delta, appzero) -> flags_t""" - return _idaapi.append_struct_fields2(*args) - -def is_public_name(*args): - """is_public_name(ea) -> bool""" - return _idaapi.is_public_name(*args) - -def make_name_public(*args): - """make_name_public(ea)""" - return _idaapi.make_name_public(*args) - -def make_name_non_public(*args): - """make_name_non_public(ea)""" - return _idaapi.make_name_non_public(*args) - -def gen_name_decl(*args): - """gen_name_decl(ea, name) -> int""" - return _idaapi.gen_name_decl(*args) - -def is_weak_name(*args): - """is_weak_name(ea) -> bool""" - return _idaapi.is_weak_name(*args) - -def make_name_weak(*args): - """make_name_weak(ea)""" - return _idaapi.make_name_weak(*args) - -def make_name_non_weak(*args): - """make_name_non_weak(ea)""" - return _idaapi.make_name_non_weak(*args) - -def get_nlist_size(*args): - """get_nlist_size() -> size_t""" - return _idaapi.get_nlist_size(*args) - -def get_nlist_idx(*args): - """get_nlist_idx(ea) -> size_t""" - return _idaapi.get_nlist_idx(*args) - -def is_in_nlist(*args): - """is_in_nlist(ea) -> bool""" - return _idaapi.is_in_nlist(*args) - -def get_nlist_ea(*args): - """get_nlist_ea(idx) -> ea_t""" - return _idaapi.get_nlist_ea(*args) - -def get_nlist_name(*args): - """get_nlist_name(idx) -> char const *""" - return _idaapi.get_nlist_name(*args) - -def rebuild_nlist(*args): - """rebuild_nlist()""" - return _idaapi.rebuild_nlist(*args) - -def reorder_dummy_names(*args): - """reorder_dummy_names()""" - return _idaapi.reorder_dummy_names(*args) -DEBNAME_EXACT = _idaapi.DEBNAME_EXACT -DEBNAME_LOWER = _idaapi.DEBNAME_LOWER -DEBNAME_UPPER = _idaapi.DEBNAME_UPPER -DEBNAME_NICE = _idaapi.DEBNAME_NICE -class ea_name_t(object): - """Proxy of C++ ea_name_t class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - ea = _swig_property(_idaapi.ea_name_t_ea_get, _idaapi.ea_name_t_ea_set) - name = _swig_property(_idaapi.ea_name_t_name_get, _idaapi.ea_name_t_name_set) - def __init__(self, *args): - """ - __init__(self) -> ea_name_t - __init__(self, _ea, _name) -> ea_name_t - """ - this = _idaapi.new_ea_name_t(*args) - try: self.this.append(this) - except: self.this = this - __swig_destroy__ = _idaapi.delete_ea_name_t - __del__ = lambda self : None; -ea_name_t_swigregister = _idaapi.ea_name_t_swigregister -ea_name_t_swigregister(ea_name_t) - - -def set_debug_name(*args): - """set_debug_name(ea, name) -> bool""" - return _idaapi.set_debug_name(*args) - -def get_debug_name2(*args): - """get_debug_name2(ea_ptr, how) -> ssize_t""" - return _idaapi.get_debug_name2(*args) - -def del_debug_names(*args): - """del_debug_names(ea1, ea2)""" - return _idaapi.del_debug_names(*args) - -def get_debug_name_ea(*args): - """get_debug_name_ea(name) -> ea_t""" - return _idaapi.get_debug_name_ea(*args) -DQT_NPURGED_8 = _idaapi.DQT_NPURGED_8 -DQT_NPURGED_4 = _idaapi.DQT_NPURGED_4 -DQT_NPURGED_2 = _idaapi.DQT_NPURGED_2 -DQT_COMPILER = _idaapi.DQT_COMPILER -DQT_NAME_TYPE = _idaapi.DQT_NAME_TYPE -DQT_FULL = _idaapi.DQT_FULL - -def demangle_name2(*args): - """demangle_name2(name, disable_mask, demreq=DQT_FULL) -> int32""" - return _idaapi.demangle_name2(*args) - -def is_name_defined_locally(*args): - """is_name_defined_locally(pfn, name, ignore, ea1=BADADDR, ea2=BADADDR) -> bool""" - return _idaapi.is_name_defined_locally(*args) - -def validate_name(*args): - """validate_name(name) -> char *""" - return _idaapi.validate_name(*args) - -def validate_name2(*args): - """validate_name2(name, bufsize) -> char *""" - return _idaapi.validate_name2(*args) - -def get_true_name(*args): - """ - get_true_name(ea) -> qstring - get_true_name(frm, ea) -> char * - """ - return _idaapi.get_true_name(*args) - -def get_name(*args): - """get_name(frm, ea) -> char *""" - return _idaapi.get_name(*args) - -def get_colored_name(*args): - """ - get_colored_name(ea) -> qstring - get_colored_name(frm, ea) -> char * - """ - return _idaapi.get_colored_name(*args) - -def demangle_name(*args): - """demangle_name(name, disable_mask) -> int32""" - return _idaapi.demangle_name(*args) - -def make_visible_name(*args): - """make_visible_name(srcname, dstsize) -> char *""" - return _idaapi.make_visible_name(*args) - -def extract_name(*args): - """extract_name(line, x) -> char *""" - return _idaapi.extract_name(*args) - -def get_demangled_name(*args): - """ - get_demangled_name(ea, inhibitor, demform, gtn_flags=0) -> ssize_t - get_demangled_name(frm, ea, inhibitor, demform, strict) -> char * - """ - return _idaapi.get_demangled_name(*args) - -def get_colored_demangled_name(*args): - """ - get_colored_demangled_name(ea, inhibitor, demform, gtn_flags=0) -> ssize_t - get_colored_demangled_name(frm, ea, inhibitor, demform, strict) -> char * - """ - return _idaapi.get_colored_demangled_name(*args) def get_debug_names(*args): - """get_debug_names(ea1, ea2) -> PyObject *""" + """ + get_debug_names(ea1, ea2) -> PyObject * + """ return _idaapi.get_debug_names(*args) - -def get_ea_name(*args): - """get_ea_name(ea, gtn_flags=0) -> qstring""" - return _idaapi.get_ea_name(*args) # class NearestName: @@ -41924,7 +47083,9 @@ class NearestName: def update(self, ea_names): - """Updates the ea/names map""" + """ + Updates the ea/names map + """ self._names = ea_names self._addrs = ea_names.keys() self._addrs.sort() @@ -41957,98 +47118,480 @@ class NearestName: def __getitem__(self, index): - """Returns the tupple (ea, name, index)""" + """ + Returns the tupple (ea, name, index) + """ if index > len(self._addrs): raise StopIteration return self._get_item(index) -extract_name = extract_name2 - # +MAXNAMELEN = _idaapi.MAXNAMELEN +FUNC_IMPORT_PREFIX = _idaapi.FUNC_IMPORT_PREFIX +SN_CHECK = _idaapi.SN_CHECK +SN_NOCHECK = _idaapi.SN_NOCHECK +SN_PUBLIC = _idaapi.SN_PUBLIC +SN_NON_PUBLIC = _idaapi.SN_NON_PUBLIC +SN_WEAK = _idaapi.SN_WEAK +SN_NON_WEAK = _idaapi.SN_NON_WEAK +SN_AUTO = _idaapi.SN_AUTO +SN_NON_AUTO = _idaapi.SN_NON_AUTO +SN_NOLIST = _idaapi.SN_NOLIST +SN_NOWARN = _idaapi.SN_NOWARN +SN_LOCAL = _idaapi.SN_LOCAL + +def set_name(*args): + """ + set_name(ea, name, flag) -> bool + set_name(ea, name) -> bool + """ + return _idaapi.set_name(*args) + +def del_global_name(*args): + """ + del_global_name(ea) -> bool + """ + return _idaapi.del_global_name(*args) + +def del_local_name(*args): + """ + del_local_name(ea) -> bool + """ + return _idaapi.del_local_name(*args) + +def set_dummy_name(*args): + """ + set_dummy_name(frm, ea) -> bool + """ + return _idaapi.set_dummy_name(*args) + +def make_name_auto(*args): + """ + make_name_auto(ea) -> bool + """ + return _idaapi.make_name_auto(*args) + +def make_name_user(*args): + """ + make_name_user(ea) -> bool + """ + return _idaapi.make_name_user(*args) + +def do_name_anyway(*args): + """ + do_name_anyway(ea, name, maxlen=0) -> bool + """ + return _idaapi.do_name_anyway(*args) + +def validate_name2(*args): + """ + validate_name2(name, bufsize) -> char * + """ + return _idaapi.validate_name2(*args) + +def is_ident_char(*args): + """ + is_ident_char(c) -> bool + """ + return _idaapi.is_ident_char(*args) + +def is_visible_char(*args): + """ + is_visible_char(c) -> bool + """ + return _idaapi.is_visible_char(*args) + +def make_visible_name(*args): + """ + make_visible_name(srcname, dstsize) -> char * + """ + return _idaapi.make_visible_name(*args) + +def isident(*args): + """ + isident(name) -> bool + """ + return _idaapi.isident(*args) + +def is_uname(*args): + """ + is_uname(name) -> bool + """ + return _idaapi.is_uname(*args) + +def is_valid_typename(*args): + """ + is_valid_typename(name) -> bool + """ + return _idaapi.is_valid_typename(*args) + +def hide_name(*args): + """ + hide_name(ea) + """ + return _idaapi.hide_name(*args) + +def show_name(*args): + """ + show_name(ea) + """ + return _idaapi.show_name(*args) + +def get_name_ea(*args): + """ + get_name_ea(frm, name) -> ea_t + """ + return _idaapi.get_name_ea(*args) + +def get_name_base_ea(*args): + """ + get_name_base_ea(frm, to) -> ea_t + """ + return _idaapi.get_name_base_ea(*args) +NT_NONE = _idaapi.NT_NONE +NT_BYTE = _idaapi.NT_BYTE +NT_LOCAL = _idaapi.NT_LOCAL +NT_STKVAR = _idaapi.NT_STKVAR +NT_ENUM = _idaapi.NT_ENUM +NT_ABS = _idaapi.NT_ABS +NT_SEG = _idaapi.NT_SEG +NT_STROFF = _idaapi.NT_STROFF +NT_BMASK = _idaapi.NT_BMASK +NT_REGVAR = _idaapi.NT_REGVAR + +def get_name_value(*args): + """ + get_name_value(frm, name) -> int + """ + return _idaapi.get_name_value(*args) + +def get_true_name(*args): + """ + get_true_name(frm, ea) -> char * + """ + return _idaapi.get_true_name(*args) + +def get_name(*args): + """ + get_name(frm, ea) -> char * + """ + return _idaapi.get_name(*args) + +def get_colored_name(*args): + """ + get_colored_name(frm, ea) -> char * + """ + return _idaapi.get_colored_name(*args) + +def get_name_color(*args): + """ + get_name_color(frm, ea) -> color_t + """ + return _idaapi.get_name_color(*args) + +def get_demangled_name(*args): + """ + get_demangled_name(frm, ea, inhibitor, demform, strict) -> char * + """ + return _idaapi.get_demangled_name(*args) + +def get_colored_demangled_name(*args): + """ + get_colored_demangled_name(frm, ea, inhibitor, demform, strict) -> char * + """ + return _idaapi.get_colored_demangled_name(*args) +GETN_APPZERO = _idaapi.GETN_APPZERO +GETN_NOFIXUP = _idaapi.GETN_NOFIXUP +GETN_NODUMMY = _idaapi.GETN_NODUMMY + +def get_name_expr(*args): + """ + get_name_expr(frm, n, ea, off, flags=0x0001) -> ssize_t + """ + return _idaapi.get_name_expr(*args) +GNCN_NOSEG = _idaapi.GNCN_NOSEG +GNCN_NOCOLOR = _idaapi.GNCN_NOCOLOR +GNCN_NOLABEL = _idaapi.GNCN_NOLABEL +GNCN_NOFUNC = _idaapi.GNCN_NOFUNC +GNCN_SEG_FUNC = _idaapi.GNCN_SEG_FUNC +GNCN_SEGNUM = _idaapi.GNCN_SEGNUM +GNCN_REQFUNC = _idaapi.GNCN_REQFUNC +GNCN_REQNAME = _idaapi.GNCN_REQNAME +GNCN_NODBGNM = _idaapi.GNCN_NODBGNM + +def get_nice_colored_name(*args): + """ + get_nice_colored_name(ea, flags=0) -> ssize_t + """ + return _idaapi.get_nice_colored_name(*args) + +def is_public_name(*args): + """ + is_public_name(ea) -> bool + """ + return _idaapi.is_public_name(*args) + +def make_name_public(*args): + """ + make_name_public(ea) + """ + return _idaapi.make_name_public(*args) + +def make_name_non_public(*args): + """ + make_name_non_public(ea) + """ + return _idaapi.make_name_non_public(*args) + +def gen_name_decl(*args): + """ + gen_name_decl(ea, name) -> int + """ + return _idaapi.gen_name_decl(*args) + +def is_weak_name(*args): + """ + is_weak_name(ea) -> bool + """ + return _idaapi.is_weak_name(*args) + +def make_name_weak(*args): + """ + make_name_weak(ea) + """ + return _idaapi.make_name_weak(*args) + +def make_name_non_weak(*args): + """ + make_name_non_weak(ea) + """ + return _idaapi.make_name_non_weak(*args) + +def get_nlist_size(*args): + """ + get_nlist_size() -> size_t + """ + return _idaapi.get_nlist_size(*args) + +def get_nlist_idx(*args): + """ + get_nlist_idx(ea) -> size_t + """ + return _idaapi.get_nlist_idx(*args) + +def is_in_nlist(*args): + """ + is_in_nlist(ea) -> bool + """ + return _idaapi.is_in_nlist(*args) + +def get_nlist_ea(*args): + """ + get_nlist_ea(idx) -> ea_t + """ + return _idaapi.get_nlist_ea(*args) + +def get_nlist_name(*args): + """ + get_nlist_name(idx) -> char const * + """ + return _idaapi.get_nlist_name(*args) + +def rebuild_nlist(*args): + """ + rebuild_nlist() + """ + return _idaapi.rebuild_nlist(*args) + +def reorder_dummy_names(*args): + """ + reorder_dummy_names() + """ + return _idaapi.reorder_dummy_names(*args) +DEBNAME_EXACT = _idaapi.DEBNAME_EXACT +DEBNAME_LOWER = _idaapi.DEBNAME_LOWER +DEBNAME_UPPER = _idaapi.DEBNAME_UPPER +DEBNAME_NICE = _idaapi.DEBNAME_NICE +class ea_name_t(object): + """ + Proxy of C++ ea_name_t class + """ + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + ea = _swig_property(_idaapi.ea_name_t_ea_get, _idaapi.ea_name_t_ea_set) + name = _swig_property(_idaapi.ea_name_t_name_get, _idaapi.ea_name_t_name_set) + def __init__(self, *args): + """ + __init__(self) -> ea_name_t + __init__(self, _ea, _name) -> ea_name_t + """ + this = _idaapi.new_ea_name_t(*args) + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _idaapi.delete_ea_name_t + __del__ = lambda self : None; +ea_name_t_swigregister = _idaapi.ea_name_t_swigregister +ea_name_t_swigregister(ea_name_t) + + +def set_debug_name(*args): + """ + set_debug_name(ea, name) -> bool + """ + return _idaapi.set_debug_name(*args) + +def del_debug_names(*args): + """ + del_debug_names(ea1, ea2) + """ + return _idaapi.del_debug_names(*args) + +def get_debug_name_ea(*args): + """ + get_debug_name_ea(name) -> ea_t + """ + return _idaapi.get_debug_name_ea(*args) + +def is_name_defined_locally(*args): + """ + is_name_defined_locally(pfn, name, ignore, ea1=BADADDR, ea2=BADADDR) -> bool + """ + return _idaapi.is_name_defined_locally(*args) + +def demangle_name(*args): + """ + demangle_name(name, disable_mask) -> int32 + """ + return _idaapi.demangle_name(*args) + +def validate_name(*args): + """ + validate_name(name) -> char * + """ + return _idaapi.validate_name(*args) def set_offset(*args): - """set_offset(ea, n, base) -> bool""" + """ + set_offset(ea, n, base) -> bool + """ return _idaapi.set_offset(*args) def op_offset_ex(*args): - """op_offset_ex(ea, n, ri) -> int""" + """ + op_offset_ex(ea, n, ri) -> int + """ return _idaapi.op_offset_ex(*args) def op_offset(*args): - """op_offset(ea, n, type, target=BADADDR, base=0, tdelta=0) -> int""" + """ + op_offset(ea, n, type, target=BADADDR, base=0, tdelta=0) -> int + """ return _idaapi.op_offset(*args) def get_offbase(*args): - """get_offbase(ea, n) -> ea_t""" + """ + get_offbase(ea, n) -> ea_t + """ return _idaapi.get_offbase(*args) def get_offset_expression(*args): - """get_offset_expression(ea, n, frm, offset, getn_flags=0) -> int""" + """ + get_offset_expression(ea, n, frm, offset, getn_flags=0) -> int + """ return _idaapi.get_offset_expression(*args) def get_offset_expr(*args): - """get_offset_expr(ea, n, ri, frm, offset, getn_flags=0) -> int""" + """ + get_offset_expr(ea, n, ri, frm, offset, getn_flags=0) -> int + """ return _idaapi.get_offset_expr(*args) def can_be_off32(*args): - """can_be_off32(ea) -> ea_t""" + """ + can_be_off32(ea) -> ea_t + """ return _idaapi.can_be_off32(*args) def calc_probable_base_by_value(*args): - """calc_probable_base_by_value(ea, off) -> ea_t""" + """ + calc_probable_base_by_value(ea, off) -> ea_t + """ return _idaapi.calc_probable_base_by_value(*args) def get_default_reftype(*args): - """get_default_reftype(ea) -> reftype_t""" + """ + get_default_reftype(ea) -> reftype_t + """ return _idaapi.get_default_reftype(*args) def calc_reference_target(*args): - """calc_reference_target(frm, ri, opval) -> ea_t""" + """ + calc_reference_target(frm, ri, opval) -> ea_t + """ return _idaapi.calc_reference_target(*args) def calc_reference_basevalue(*args): - """calc_reference_basevalue(frm, ri, opval, target) -> ea_t""" + """ + calc_reference_basevalue(frm, ri, opval, target) -> ea_t + """ return _idaapi.calc_reference_basevalue(*args) def calc_target(*args): - """calc_target(frm, ea, n, opval) -> ea_t""" + """ + calc_target(frm, ea, n, opval) -> ea_t + """ return _idaapi.calc_target(*args) def QueueGetMessage(*args): - """QueueGetMessage(t, ea) -> ssize_t""" + """ + QueueGetMessage(t, ea) -> ssize_t + """ return _idaapi.QueueGetMessage(*args) def QueueSet(*args): - """QueueSet(type, ea, $ignore=None)""" + """ + QueueSet(type, ea, $ignore=None) + """ return _idaapi.QueueSet(*args) def QueueGetType(*args): - """QueueGetType(type, lowea) -> ea_t""" + """ + QueueGetType(type, lowea) -> ea_t + """ return _idaapi.QueueGetType(*args) -def QueueDel(*args): - """QueueDel(type, ea)""" - return _idaapi.QueueDel(*args) - def get_long_queue_name(*args): - """get_long_queue_name(type) -> char const *""" + """ + get_long_queue_name(type) -> char const * + """ return _idaapi.get_long_queue_name(*args) def get_short_queue_name(*args): - """get_short_queue_name(type) -> char const *""" + """ + get_short_queue_name(type) -> char const * + """ return _idaapi.get_short_queue_name(*args) def QueueIsPresent(*args): - """QueueIsPresent(t, ea) -> bool""" + """ + QueueIsPresent(t, ea) -> bool + """ return _idaapi.QueueIsPresent(*args) def was_ida_decision(*args): - """was_ida_decision(ea) -> bool""" + """ + was_ida_decision(ea) -> bool + """ return _idaapi.was_ida_decision(*args) +ROLLBACK_CODE = _idaapi.ROLLBACK_CODE +ROLLBACK_DATA = _idaapi.ROLLBACK_DATA +ROLLBACK_ALIGN = _idaapi.ROLLBACK_ALIGN def QueueMark(*args): - """QueueMark(type, ea)""" + """ + QueueMark(type, ea) + """ return _idaapi.QueueMark(*args) SEARCH_UP = _idaapi.SEARCH_UP SEARCH_DOWN = _idaapi.SEARCH_DOWN @@ -42062,59 +47605,87 @@ SEARCH_IDENT = _idaapi.SEARCH_IDENT SEARCH_BRK = _idaapi.SEARCH_BRK def search_down(*args): - """search_down(sflag) -> bool""" + """ + search_down(sflag) -> bool + """ return _idaapi.search_down(*args) def find_error(*args): - """find_error(ea, sflag) -> ea_t""" + """ + find_error(ea, sflag) -> ea_t + """ return _idaapi.find_error(*args) def find_notype(*args): - """find_notype(ea, sflag) -> ea_t""" + """ + find_notype(ea, sflag) -> ea_t + """ return _idaapi.find_notype(*args) def find_unknown(*args): - """find_unknown(ea, sflag) -> ea_t""" + """ + find_unknown(ea, sflag) -> ea_t + """ return _idaapi.find_unknown(*args) def find_defined(*args): - """find_defined(ea, sflag) -> ea_t""" + """ + find_defined(ea, sflag) -> ea_t + """ return _idaapi.find_defined(*args) def find_void(*args): - """find_void(ea, sflag) -> ea_t""" + """ + find_void(ea, sflag) -> ea_t + """ return _idaapi.find_void(*args) def find_data(*args): - """find_data(ea, sflag) -> ea_t""" + """ + find_data(ea, sflag) -> ea_t + """ return _idaapi.find_data(*args) def find_code(*args): - """find_code(ea, sflag) -> ea_t""" + """ + find_code(ea, sflag) -> ea_t + """ return _idaapi.find_code(*args) def find_not_func(*args): - """find_not_func(ea, sflag) -> ea_t""" + """ + find_not_func(ea, sflag) -> ea_t + """ return _idaapi.find_not_func(*args) def find_imm(*args): - """find_imm(newEA, sflag, srchValue) -> ea_t""" + """ + find_imm(newEA, sflag, srchValue) -> ea_t + """ return _idaapi.find_imm(*args) def find_binary(*args): - """find_binary(startea, endea, ubinstr, radix, sflag) -> ea_t""" + """ + find_binary(startea, endea, ubinstr, radix, sflag) -> ea_t + """ return _idaapi.find_binary(*args) def find_text(*args): - """find_text(startEA, y, x, ustr, sflag) -> ea_t""" + """ + find_text(startEA, y, x, ustr, sflag) -> ea_t + """ return _idaapi.find_text(*args) SREG_NUM = _idaapi.SREG_NUM class segment_t(area_t): - """Proxy of C++ segment_t class""" + """ + Proxy of C++ segment_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> segment_t""" + def __init__(self, *args): + """ + __init__(self) -> segment_t + """ this = _idaapi.new_segment_t(*args) try: self.this.append(this) except: self.this = this @@ -42126,72 +47697,106 @@ class segment_t(area_t): perm = _swig_property(_idaapi.segment_t_perm_get, _idaapi.segment_t_perm_set) bitness = _swig_property(_idaapi.segment_t_bitness_get, _idaapi.segment_t_bitness_set) def use32(self, *args): - """use32(self) -> bool""" + """ + use32(self) -> bool + """ return _idaapi.segment_t_use32(self, *args) def use64(self, *args): - """use64(self) -> bool""" + """ + use64(self) -> bool + """ return _idaapi.segment_t_use64(self, *args) def abits(self, *args): - """abits(self) -> int""" + """ + abits(self) -> int + """ return _idaapi.segment_t_abits(self, *args) def abytes(self, *args): - """abytes(self) -> int""" + """ + abytes(self) -> int + """ return _idaapi.segment_t_abytes(self, *args) flags = _swig_property(_idaapi.segment_t_flags_get, _idaapi.segment_t_flags_set) def comorg(self, *args): - """comorg(self) -> bool""" + """ + comorg(self) -> bool + """ return _idaapi.segment_t_comorg(self, *args) def set_comorg(self, *args): - """set_comorg(self)""" + """ + set_comorg(self) + """ return _idaapi.segment_t_set_comorg(self, *args) def clr_comorg(self, *args): - """clr_comorg(self)""" + """ + clr_comorg(self) + """ return _idaapi.segment_t_clr_comorg(self, *args) def ob_ok(self, *args): - """ob_ok(self) -> bool""" + """ + ob_ok(self) -> bool + """ return _idaapi.segment_t_ob_ok(self, *args) def set_ob_ok(self, *args): - """set_ob_ok(self)""" + """ + set_ob_ok(self) + """ return _idaapi.segment_t_set_ob_ok(self, *args) def clr_ob_ok(self, *args): - """clr_ob_ok(self)""" + """ + clr_ob_ok(self) + """ return _idaapi.segment_t_clr_ob_ok(self, *args) def is_visible_segm(self, *args): - """is_visible_segm(self) -> bool""" + """ + is_visible_segm(self) -> bool + """ return _idaapi.segment_t_is_visible_segm(self, *args) def set_visible_segm(self, *args): - """set_visible_segm(self, visible)""" + """ + set_visible_segm(self, visible) + """ return _idaapi.segment_t_set_visible_segm(self, *args) def set_debugger_segm(self, *args): - """set_debugger_segm(self, debseg)""" + """ + set_debugger_segm(self, debseg) + """ return _idaapi.segment_t_set_debugger_segm(self, *args) def is_loader_segm(self, *args): - """is_loader_segm(self) -> bool""" + """ + is_loader_segm(self) -> bool + """ return _idaapi.segment_t_is_loader_segm(self, *args) def set_loader_segm(self, *args): - """set_loader_segm(self, ldrseg)""" + """ + set_loader_segm(self, ldrseg) + """ return _idaapi.segment_t_set_loader_segm(self, *args) def is_hidden_segtype(self, *args): - """is_hidden_segtype(self) -> bool""" + """ + is_hidden_segtype(self) -> bool + """ return _idaapi.segment_t_is_hidden_segtype(self, *args) def set_hidden_segtype(self, *args): - """set_hidden_segtype(self, hide)""" + """ + set_hidden_segtype(self, hide) + """ return _idaapi.segment_t_set_hidden_segtype(self, *args) sel = _swig_property(_idaapi.segment_t_sel_get, _idaapi.segment_t_sel_set) @@ -42199,7 +47804,9 @@ class segment_t(area_t): type = _swig_property(_idaapi.segment_t_type_get, _idaapi.segment_t_type_set) color = _swig_property(_idaapi.segment_t_color_get, _idaapi.segment_t_color_set) def update(self, *args): - """update(self) -> bool""" + """ + update(self) -> bool + """ return _idaapi.segment_t_update(self, *args) startEA = _swig_property(_idaapi.segment_t_startEA_get, _idaapi.segment_t_startEA_set) @@ -42245,7 +47852,6 @@ saRel128Bytes = _idaapi.saRel128Bytes saRel512Bytes = _idaapi.saRel512Bytes saRel1024Bytes = _idaapi.saRel1024Bytes saRel2048Bytes = _idaapi.saRel2048Bytes -saRel_MAX_ALIGN_CODE = _idaapi.saRel_MAX_ALIGN_CODE scPriv = _idaapi.scPriv scGroup = _idaapi.scGroup scPub = _idaapi.scPub @@ -42253,12 +47859,9 @@ scPub2 = _idaapi.scPub2 scStack = _idaapi.scStack scCommon = _idaapi.scCommon scPub3 = _idaapi.scPub3 -sc_MAX_COMB_CODE = _idaapi.sc_MAX_COMB_CODE SEGPERM_EXEC = _idaapi.SEGPERM_EXEC SEGPERM_WRITE = _idaapi.SEGPERM_WRITE SEGPERM_READ = _idaapi.SEGPERM_READ -SEGPERM_MAXVAL = _idaapi.SEGPERM_MAXVAL -SEG_MAX_BITNESS_CODE = _idaapi.SEG_MAX_BITNESS_CODE SFL_COMORG = _idaapi.SFL_COMORG SFL_OBOK = _idaapi.SFL_OBOK SFL_HIDDEN = _idaapi.SFL_HIDDEN @@ -42277,34 +47880,47 @@ SEG_BSS = _idaapi.SEG_BSS SEG_ABSSYM = _idaapi.SEG_ABSSYM SEG_COMM = _idaapi.SEG_COMM SEG_IMEM = _idaapi.SEG_IMEM -SEG_MAX_SEGTYPE_CODE = _idaapi.SEG_MAX_SEGTYPE_CODE def is_visible_segm(*args): - """is_visible_segm(s) -> bool""" + """ + is_visible_segm(s) -> bool + """ return _idaapi.is_visible_segm(*args) def is_finally_visible_segm(*args): - """is_finally_visible_segm(s) -> bool""" + """ + is_finally_visible_segm(s) -> bool + """ return _idaapi.is_finally_visible_segm(*args) def set_visible_segm(*args): - """set_visible_segm(s, visible)""" + """ + set_visible_segm(s, visible) + """ return _idaapi.set_visible_segm(*args) def is_spec_segm(*args): - """is_spec_segm(seg_type) -> bool""" + """ + is_spec_segm(seg_type) -> bool + """ return _idaapi.is_spec_segm(*args) def is_spec_ea(*args): - """is_spec_ea(ea) -> bool""" + """ + is_spec_ea(ea) -> bool + """ return _idaapi.is_spec_ea(*args) class lock_segment(object): - """Proxy of C++ lock_segment class""" + """ + Proxy of C++ lock_segment class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, _segm) -> lock_segment""" + def __init__(self, *args): + """ + __init__(self, _segm) -> lock_segment + """ this = _idaapi.new_lock_segment(*args) try: self.this.append(this) except: self.this = this @@ -42315,55 +47931,81 @@ lock_segment_swigregister(lock_segment) def is_segm_locked(*args): - """is_segm_locked(segm) -> bool""" + """ + is_segm_locked(segm) -> bool + """ return _idaapi.is_segm_locked(*args) def getn_selector(*args): - """getn_selector(n, sel, base) -> bool""" + """ + getn_selector(n, sel, base) -> bool + """ return _idaapi.getn_selector(*args) def get_selector_qty(*args): - """get_selector_qty() -> int""" + """ + get_selector_qty() -> int + """ return _idaapi.get_selector_qty(*args) def setup_selector(*args): - """setup_selector(segbase) -> sel_t""" + """ + setup_selector(segbase) -> sel_t + """ return _idaapi.setup_selector(*args) def allocate_selector(*args): - """allocate_selector(segbase) -> sel_t""" + """ + allocate_selector(segbase) -> sel_t + """ return _idaapi.allocate_selector(*args) def find_free_selector(*args): - """find_free_selector() -> sel_t""" + """ + find_free_selector() -> sel_t + """ return _idaapi.find_free_selector(*args) def set_selector(*args): - """set_selector(selector, paragraph) -> int""" + """ + set_selector(selector, paragraph) -> int + """ return _idaapi.set_selector(*args) def del_selector(*args): - """del_selector(selector)""" + """ + del_selector(selector) + """ return _idaapi.del_selector(*args) def ask_selector(*args): - """ask_selector(selector) -> ea_t""" + """ + ask_selector(selector) -> ea_t + """ return _idaapi.ask_selector(*args) def sel2ea(*args): - """sel2ea(selector) -> ea_t""" + """ + sel2ea(selector) -> ea_t + """ return _idaapi.sel2ea(*args) def find_selector(*args): - """find_selector(base) -> sel_t""" + """ + find_selector(base) -> sel_t + """ return _idaapi.find_selector(*args) def get_segm_by_sel(*args): - """get_segm_by_sel(selector) -> segment_t""" + """ + get_segm_by_sel(selector) -> segment_t + """ return _idaapi.get_segm_by_sel(*args) def add_segm_ex(*args): - """add_segm_ex(s, name, sclass, flags) -> bool""" + """ + add_segm_ex(s, name, sclass, flags) -> bool + """ return _idaapi.add_segm_ex(*args) ADDSEG_NOSREG = _idaapi.ADDSEG_NOSREG ADDSEG_OR_DIE = _idaapi.ADDSEG_OR_DIE @@ -42373,11 +48015,15 @@ ADDSEG_FILLGAP = _idaapi.ADDSEG_FILLGAP ADDSEG_SPARSE = _idaapi.ADDSEG_SPARSE def add_segm(*args): - """add_segm(para, start, end, name, sclass) -> bool""" + """ + add_segm(para, start, end, name, sclass) -> bool + """ return _idaapi.add_segm(*args) def del_segm(*args): - """del_segm(ea, flags) -> bool""" + """ + del_segm(ea, flags) -> bool + """ return _idaapi.del_segm(*args) SEGMOD_KILL = _idaapi.SEGMOD_KILL SEGMOD_KEEP = _idaapi.SEGMOD_KEEP @@ -42385,59 +48031,82 @@ SEGMOD_SILENT = _idaapi.SEGMOD_SILENT SEGMOD_KEEP0 = _idaapi.SEGMOD_KEEP0 SEGMOD_KEEPSEL = _idaapi.SEGMOD_KEEPSEL SEGMOD_NOMOVE = _idaapi.SEGMOD_NOMOVE -SEGMOD_SPARSE = _idaapi.SEGMOD_SPARSE def get_segm_qty(*args): - """get_segm_qty() -> int""" + """ + get_segm_qty() -> int + """ return _idaapi.get_segm_qty(*args) def getseg(*args): - """getseg(ea) -> segment_t""" + """ + getseg(ea) -> segment_t + """ return _idaapi.getseg(*args) def getnseg(*args): - """getnseg(n) -> segment_t""" + """ + getnseg(n) -> segment_t + """ return _idaapi.getnseg(*args) def get_next_seg(*args): - """get_next_seg(ea) -> segment_t""" + """ + get_next_seg(ea) -> segment_t + """ return _idaapi.get_next_seg(*args) def get_prev_seg(*args): - """get_prev_seg(ea) -> segment_t""" + """ + get_prev_seg(ea) -> segment_t + """ return _idaapi.get_prev_seg(*args) def get_first_seg(*args): - """get_first_seg() -> segment_t""" + """ + get_first_seg() -> segment_t + """ return _idaapi.get_first_seg(*args) def get_last_seg(*args): - """get_last_seg() -> segment_t""" + """ + get_last_seg() -> segment_t + """ return _idaapi.get_last_seg(*args) def get_segm_by_name(*args): - """get_segm_by_name(name) -> segment_t""" + """ + get_segm_by_name(name) -> segment_t + """ return _idaapi.get_segm_by_name(*args) def set_segm_end(*args): - """set_segm_end(ea, newend, flags) -> bool""" + """ + set_segm_end(ea, newend, flags) -> bool + """ return _idaapi.set_segm_end(*args) def set_segm_start(*args): - """set_segm_start(ea, newstart, flags) -> bool""" + """ + set_segm_start(ea, newstart, flags) -> bool + """ return _idaapi.set_segm_start(*args) def move_segm_start(*args): - """move_segm_start(ea, newstart, mode) -> bool""" + """ + move_segm_start(ea, newstart, mode) -> bool + """ return _idaapi.move_segm_start(*args) - -def move_segm(*args): - """move_segm(s, to, flags=0) -> int""" - return _idaapi.move_segm(*args) MSF_SILENT = _idaapi.MSF_SILENT MSF_NOFIX = _idaapi.MSF_NOFIX MSF_LDKEEP = _idaapi.MSF_LDKEEP MSF_FIXONCE = _idaapi.MSF_FIXONCE + +def move_segm(*args): + """ + move_segm(s, to, flags=0) -> int + """ + return _idaapi.move_segm(*args) MOVE_SEGM_OK = _idaapi.MOVE_SEGM_OK MOVE_SEGM_PARAM = _idaapi.MOVE_SEGM_PARAM MOVE_SEGM_ROOM = _idaapi.MOVE_SEGM_ROOM @@ -42445,81 +48114,114 @@ MOVE_SEGM_IDP = _idaapi.MOVE_SEGM_IDP MOVE_SEGM_CHUNK = _idaapi.MOVE_SEGM_CHUNK MOVE_SEGM_LOADER = _idaapi.MOVE_SEGM_LOADER MOVE_SEGM_ODD = _idaapi.MOVE_SEGM_ODD -MOVE_SEGM_ORPHAN = _idaapi.MOVE_SEGM_ORPHAN def rebase_program(*args): - """rebase_program(delta, flags) -> int""" + """ + rebase_program(delta, flags) -> int + """ return _idaapi.rebase_program(*args) - -def change_segment_status(*args): - """change_segment_status(s, is_deb_segm) -> int""" - return _idaapi.change_segment_status(*args) CSS_OK = _idaapi.CSS_OK CSS_NODBG = _idaapi.CSS_NODBG CSS_NOAREA = _idaapi.CSS_NOAREA CSS_NOMEM = _idaapi.CSS_NOMEM CSS_BREAK = _idaapi.CSS_BREAK +def change_segment_status(*args): + """ + change_segment_status(s, is_deb_segm) -> int + """ + return _idaapi.change_segment_status(*args) + def take_memory_snapshot(*args): - """take_memory_snapshot(only_loader_segs) -> bool""" + """ + take_memory_snapshot(only_loader_segs) -> bool + """ return _idaapi.take_memory_snapshot(*args) def is_miniidb(*args): - """is_miniidb() -> bool""" + """ + is_miniidb() -> bool + """ return _idaapi.is_miniidb(*args) def set_segm_base(*args): - """set_segm_base(s, newbase) -> bool""" + """ + set_segm_base(s, newbase) -> bool + """ return _idaapi.set_segm_base(*args) def set_group_selector(*args): - """set_group_selector(grp, sel) -> int""" + """ + set_group_selector(grp, sel) -> int + """ return _idaapi.set_group_selector(*args) MAX_GROUPS = _idaapi.MAX_GROUPS def get_group_selector(*args): - """get_group_selector(grpsel) -> sel_t""" + """ + get_group_selector(grpsel) -> sel_t + """ return _idaapi.get_group_selector(*args) def add_segment_translation(*args): - """add_segment_translation(segstart, mappedseg) -> bool""" + """ + add_segment_translation(segstart, mappedseg) -> bool + """ return _idaapi.add_segment_translation(*args) MAX_SEGM_TRANSLATIONS = _idaapi.MAX_SEGM_TRANSLATIONS def set_segment_translations(*args): - """set_segment_translations(segstart, transmap) -> bool""" + """ + set_segment_translations(segstart, transmap) -> bool + """ return _idaapi.set_segment_translations(*args) def del_segment_translations(*args): - """del_segment_translations(ea) -> bool""" + """ + del_segment_translations(ea) -> bool + """ return _idaapi.del_segment_translations(*args) def get_segment_translations(*args): - """get_segment_translations(segstart, buf, bufsize) -> ea_t *""" + """ + get_segment_translations(segstart, buf, bufsize) -> ea_t * + """ return _idaapi.get_segment_translations(*args) def get_segment_cmt(*args): - """get_segment_cmt(s, repeatable) -> char *""" + """ + get_segment_cmt(s, repeatable) -> char * + """ return _idaapi.get_segment_cmt(*args) def set_segment_cmt(*args): - """set_segment_cmt(s, cmt, repeatable)""" + """ + set_segment_cmt(s, cmt, repeatable) + """ return _idaapi.set_segment_cmt(*args) def del_segment_cmt(*args): - """del_segment_cmt(s, repeatable)""" + """ + del_segment_cmt(s, repeatable) + """ return _idaapi.del_segment_cmt(*args) def std_gen_segm_footer(*args): - """std_gen_segm_footer(ea)""" + """ + std_gen_segm_footer(ea) + """ return _idaapi.std_gen_segm_footer(*args) def set_segm_name(*args): - """set_segm_name(s, format) -> int""" + """ + set_segm_name(s, format) -> int + """ return _idaapi.set_segm_name(*args) def get_true_segm_name(*args): - """get_true_segm_name(s) -> ssize_t""" + """ + get_true_segm_name(s) -> ssize_t + """ return _idaapi.get_true_segm_name(*args) def get_segm_name(*args): @@ -42530,47 +48232,63 @@ def get_segm_name(*args): return _idaapi.get_segm_name(*args) def get_segm_class(*args): - """get_segm_class(s) -> ssize_t""" + """ + get_segm_class(s) -> ssize_t + """ return _idaapi.get_segm_class(*args) def set_segm_class(*args): - """set_segm_class(s, sclass) -> int""" + """ + set_segm_class(s, sclass) -> int + """ return _idaapi.set_segm_class(*args) def segtype(*args): - """segtype(ea) -> uchar""" + """ + segtype(ea) -> uchar + """ return _idaapi.segtype(*args) def get_segment_alignment(*args): - """get_segment_alignment(align) -> char const *""" + """ + get_segment_alignment(align) -> char const * + """ return _idaapi.get_segment_alignment(*args) def get_segment_combination(*args): - """get_segment_combination(comb) -> char const *""" + """ + get_segment_combination(comb) -> char const * + """ return _idaapi.get_segment_combination(*args) def get_segm_para(*args): - """get_segm_para(s) -> ea_t""" + """ + get_segm_para(s) -> ea_t + """ return _idaapi.get_segm_para(*args) def get_segm_base(*args): - """get_segm_base(s) -> ea_t""" + """ + get_segm_base(s) -> ea_t + """ return _idaapi.get_segm_base(*args) def set_segm_addressing(*args): - """set_segm_addressing(s, bitness) -> bool""" + """ + set_segm_addressing(s, bitness) -> bool + """ return _idaapi.set_segm_addressing(*args) -def update_segm(*args): - """update_segm(s) -> bool""" - return _idaapi.update_segm(*args) - def segm_adjust_diff(*args): - """segm_adjust_diff(s, delta) -> adiff_t""" + """ + segm_adjust_diff(s, delta) -> adiff_t + """ return _idaapi.segm_adjust_diff(*args) def segm_adjust_ea(*args): - """segm_adjust_ea(s, ea) -> ea_t""" + """ + segm_adjust_ea(s, ea) -> ea_t + """ return _idaapi.segm_adjust_ea(*args) SEGDEL_PERM = _idaapi.SEGDEL_PERM SEGDEL_KEEP = _idaapi.SEGDEL_KEEP @@ -42578,11 +48296,15 @@ SEGDEL_SILENT = _idaapi.SEGDEL_SILENT SEGDEL_KEEP0 = _idaapi.SEGDEL_KEEP0 def get_defsr(*args): - """get_defsr(s, reg) -> sel_t""" + """ + get_defsr(s, reg) -> sel_t + """ return _idaapi.get_defsr(*args) def set_defsr(*args): - """set_defsr(s, reg, value)""" + """ + set_defsr(s, reg, value) + """ return _idaapi.set_defsr(*args) R_es = _idaapi.R_es R_cs = _idaapi.R_cs @@ -42590,100 +48312,48 @@ R_ss = _idaapi.R_ss R_ds = _idaapi.R_ds R_fs = _idaapi.R_fs R_gs = _idaapi.R_gs -class segreg_area_t(area_t): - """Proxy of C++ segreg_area_t class""" - thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') - __repr__ = _swig_repr - val = _swig_property(_idaapi.segreg_area_t_val_get, _idaapi.segreg_area_t_val_set) - tag = _swig_property(_idaapi.segreg_area_t_tag_get, _idaapi.segreg_area_t_tag_set) - def __init__(self, *args): - """__init__(self) -> segreg_area_t""" - this = _idaapi.new_segreg_area_t(*args) - try: self.this.append(this) - except: self.this = this - __swig_destroy__ = _idaapi.delete_segreg_area_t - __del__ = lambda self : None; -segreg_area_t_swigregister = _idaapi.segreg_area_t_swigregister -segreg_area_t_swigregister(segreg_area_t) -SR_inherit = _idaapi.SR_inherit -SR_user = _idaapi.SR_user -SR_auto = _idaapi.SR_auto -SR_autostart = _idaapi.SR_autostart - - -def get_segreg(*args): - """get_segreg(ea, rg) -> sel_t""" - return _idaapi.get_segreg(*args) - -def split_srarea(*args): - """split_srarea(ea, rg, v, tag, silent=False) -> bool""" - return _idaapi.split_srarea(*args) - -def set_default_segreg_value(*args): - """set_default_segreg_value(sg, rg, value) -> bool""" - return _idaapi.set_default_segreg_value(*args) - -def set_sreg_at_next_code(*args): - """set_sreg_at_next_code(ea1, ea2, rg, value)""" - return _idaapi.set_sreg_at_next_code(*args) - -def get_srarea2(*args): - """get_srarea2(out, ea, rg) -> bool""" - return _idaapi.get_srarea2(*args) - -def get_prev_srarea(*args): - """get_prev_srarea(out, ea, rg) -> bool""" - return _idaapi.get_prev_srarea(*args) - -def set_default_dataseg(*args): - """set_default_dataseg(ds_sel)""" - return _idaapi.set_default_dataseg(*args) - -def get_srareas_qty2(*args): - """get_srareas_qty2(rg) -> size_t""" - return _idaapi.get_srareas_qty2(*args) - -def getn_srarea2(*args): - """getn_srarea2(out, rg, n) -> bool""" - return _idaapi.getn_srarea2(*args) - -def get_srarea_num(*args): - """get_srarea_num(rg, ea) -> int""" - return _idaapi.get_srarea_num(*args) - -def del_srarea(*args): - """del_srarea(rg, ea) -> bool""" - return _idaapi.del_srarea(*args) - -def copy_srareas(*args): - """copy_srareas(dst_rg, src_rg, map_selector=False)""" - return _idaapi.copy_srareas(*args) class segreg_t(area_t): - """Proxy of C++ segreg_t class""" + """ + Proxy of C++ segreg_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr def reg(self, *args): - """reg(self, n) -> sel_t const &""" + """ + reg(self, n) -> sel_t + reg(self, n) -> sel_t const & + """ return _idaapi.segreg_t_reg(self, *args) def tag(self, *args): - """tag(self, n) -> uchar const &""" + """ + tag(self, n) -> uchar + tag(self, n) -> uchar const & + """ return _idaapi.segreg_t_tag(self, *args) def undefregs(self, *args): - """undefregs(self)""" + """ + undefregs(self) + """ return _idaapi.segreg_t_undefregs(self, *args) def setregs(self, *args): - """setregs(self, Regs)""" + """ + setregs(self, Regs) + """ return _idaapi.segreg_t_setregs(self, *args) def settags(self, *args): - """settags(self, v)""" + """ + settags(self, v) + """ return _idaapi.segreg_t_settags(self, *args) - def __init__(self, *args): - """__init__(self) -> segreg_t""" + def __init__(self, *args): + """ + __init__(self) -> segreg_t + """ this = _idaapi.new_segreg_t(*args) try: self.this.append(this) except: self.this = this @@ -42692,24 +48362,16 @@ class segreg_t(area_t): segreg_t_swigregister = _idaapi.segreg_t_swigregister segreg_t_swigregister(segreg_t) - -def get_srarea(*args): - """get_srarea(ea) -> segreg_t""" - return _idaapi.get_srarea(*args) - -def get_srareas_qty(*args): - """get_srareas_qty() -> size_t""" - return _idaapi.get_srareas_qty(*args) - -def getn_srarea(*args): - """getn_srarea(n) -> segreg_t""" - return _idaapi.getn_srarea(*args) class lock_segreg(object): - """Proxy of C++ lock_segreg class""" + """ + Proxy of C++ lock_segreg class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self, arg2) -> lock_segreg""" + def __init__(self, *args): + """ + __init__(self, _sreg) -> lock_segreg + """ this = _idaapi.new_lock_segreg(*args) try: self.this.append(this) except: self.this = this @@ -42720,29 +48382,82 @@ lock_segreg_swigregister(lock_segreg) def is_segreg_locked(*args): - """is_segreg_locked(arg1) -> bool""" + """ + is_segreg_locked(sreg) -> bool + """ return _idaapi.is_segreg_locked(*args) +def get_segreg(*args): + """ + get_segreg(ea, rg) -> sel_t + """ + return _idaapi.get_segreg(*args) + +def set_default_segreg_value(*args): + """ + set_default_segreg_value(sg, rg, value) -> bool + """ + return _idaapi.set_default_segreg_value(*args) + +def split_srarea(*args): + """ + split_srarea(ea, rg, v, tag, silent=False) -> bool + """ + return _idaapi.split_srarea(*args) + +def set_sreg_at_next_code(*args): + """ + set_sreg_at_next_code(ea1, ea2, reg, value) + """ + return _idaapi.set_sreg_at_next_code(*args) + +def get_srareas_qty(*args): + """ + get_srareas_qty() -> size_t + """ + return _idaapi.get_srareas_qty(*args) + +def get_srarea(*args): + """ + get_srarea(ea) -> segreg_t + """ + return _idaapi.get_srarea(*args) + +def getn_srarea(*args): + """ + getn_srarea(n) -> segreg_t + """ + return _idaapi.getn_srarea(*args) + +def set_default_dataseg(*args): + """ + set_default_dataseg(ds_sel) + """ + return _idaapi.set_default_dataseg(*args) + def getSR(*args): - """getSR(ea, rg) -> sel_t""" + """ + getSR(ea, rg) -> sel_t + """ return _idaapi.getSR(*args) def SetDefaultRegisterValue(*args): - """SetDefaultRegisterValue(sg, rg, value) -> bool""" + """ + SetDefaultRegisterValue(sg, rg, value) -> bool + """ return _idaapi.SetDefaultRegisterValue(*args) def splitSRarea1(*args): - """splitSRarea1(ea, rg, v, tag, silent=False) -> bool""" + """ + splitSRarea1(ea, rg, v, tag, silent=False) -> bool + """ return _idaapi.splitSRarea1(*args) class strwinsetup_t(object): - """Proxy of C++ strwinsetup_t class""" + """ + Proxy of C++ strwinsetup_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> strwinsetup_t""" - this = _idaapi.new_strwinsetup_t(*args) - try: self.this.append(this) - except: self.this = this strtypes = _swig_property(_idaapi.strwinsetup_t_strtypes_get, _idaapi.strwinsetup_t_strtypes_set) minlen = _swig_property(_idaapi.strwinsetup_t_minlen_get, _idaapi.strwinsetup_t_minlen_set) display_only_existing_strings = _swig_property(_idaapi.strwinsetup_t_display_only_existing_strings_get, _idaapi.strwinsetup_t_display_only_existing_strings_set) @@ -42750,23 +48465,28 @@ class strwinsetup_t(object): ignore_heads = _swig_property(_idaapi.strwinsetup_t_ignore_heads_get, _idaapi.strwinsetup_t_ignore_heads_set) ea1 = _swig_property(_idaapi.strwinsetup_t_ea1_get, _idaapi.strwinsetup_t_ea1_set) ea2 = _swig_property(_idaapi.strwinsetup_t_ea2_get, _idaapi.strwinsetup_t_ea2_set) - def is_initialized(self, *args): - """is_initialized(self) -> bool""" - return _idaapi.strwinsetup_t_is_initialized(self, *args) - + def __init__(self, *args): + """ + __init__(self) -> strwinsetup_t + """ + this = _idaapi.new_strwinsetup_t(*args) + try: self.this.append(this) + except: self.this = this __swig_destroy__ = _idaapi.delete_strwinsetup_t __del__ = lambda self : None; strwinsetup_t_swigregister = _idaapi.strwinsetup_t_swigregister strwinsetup_t_swigregister(strwinsetup_t) class string_info_t(object): - """Proxy of C++ string_info_t class""" + """ + Proxy of C++ string_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr ea = _swig_property(_idaapi.string_info_t_ea_get, _idaapi.string_info_t_ea_set) length = _swig_property(_idaapi.string_info_t_length_get, _idaapi.string_info_t_length_set) type = _swig_property(_idaapi.string_info_t_type_get, _idaapi.string_info_t_type_set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self) -> string_info_t __init__(self, _ea) -> string_info_t @@ -42775,7 +48495,9 @@ class string_info_t(object): try: self.this.append(this) except: self.this = this def __lt__(self, *args): - """__lt__(self, string_info) -> bool""" + """ + __lt__(self, string_info) -> bool + """ return _idaapi.string_info_t___lt__(self, *args) __swig_destroy__ = _idaapi.delete_string_info_t @@ -42785,23 +48507,33 @@ string_info_t_swigregister(string_info_t) def set_strlist_options(*args): - """set_strlist_options(options) -> bool""" + """ + set_strlist_options(options) -> bool + """ return _idaapi.set_strlist_options(*args) def refresh_strlist(*args): - """refresh_strlist(ea1, ea2)""" + """ + refresh_strlist(ea1, ea2) + """ return _idaapi.refresh_strlist(*args) def get_strlist_qty(*args): - """get_strlist_qty() -> size_t""" + """ + get_strlist_qty() -> size_t + """ return _idaapi.get_strlist_qty(*args) def get_strlist_item(*args): - """get_strlist_item(n, si) -> bool""" + """ + get_strlist_item(n, si) -> bool + """ return _idaapi.get_strlist_item(*args) STRUC_SEPARATOR = _idaapi.STRUC_SEPARATOR class member_t(object): - """Proxy of C++ member_t class""" + """ + Proxy of C++ member_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr id = _swig_property(_idaapi.member_t_id_get, _idaapi.member_t_id_set) @@ -42810,27 +48542,39 @@ class member_t(object): flag = _swig_property(_idaapi.member_t_flag_get, _idaapi.member_t_flag_set) props = _swig_property(_idaapi.member_t_props_get, _idaapi.member_t_props_set) def unimem(self, *args): - """unimem(self) -> bool""" + """ + unimem(self) -> bool + """ return _idaapi.member_t_unimem(self, *args) def has_union(self, *args): - """has_union(self) -> bool""" + """ + has_union(self) -> bool + """ return _idaapi.member_t_has_union(self, *args) def by_til(self, *args): - """by_til(self) -> bool""" + """ + by_til(self) -> bool + """ return _idaapi.member_t_by_til(self, *args) def has_ti(self, *args): - """has_ti(self) -> bool""" + """ + has_ti(self) -> bool + """ return _idaapi.member_t_has_ti(self, *args) def get_soff(self, *args): - """get_soff(self) -> ea_t""" + """ + get_soff(self) -> ea_t + """ return _idaapi.member_t_get_soff(self, *args) - def __init__(self, *args): - """__init__(self) -> member_t""" + def __init__(self, *args): + """ + __init__(self) -> member_t + """ this = _idaapi.new_member_t(*args) try: self.this.append(this) except: self.this = this @@ -42845,7 +48589,9 @@ MF_BYTIL = _idaapi.MF_BYTIL MF_HASTI = _idaapi.MF_HASTI class struc_t(object): - """Proxy of C++ struc_t class""" + """ + Proxy of C++ struc_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr @@ -42855,48 +48601,58 @@ class struc_t(object): age = _swig_property(_idaapi.struc_t_age_get, _idaapi.struc_t_age_set) props = _swig_property(_idaapi.struc_t_props_get, _idaapi.struc_t_props_set) def is_varstr(self, *args): - """is_varstr(self) -> bool""" + """ + is_varstr(self) -> bool + """ return _idaapi.struc_t_is_varstr(self, *args) def is_union(self, *args): - """is_union(self) -> bool""" + """ + is_union(self) -> bool + """ return _idaapi.struc_t_is_union(self, *args) def has_union(self, *args): - """has_union(self) -> bool""" + """ + has_union(self) -> bool + """ return _idaapi.struc_t_has_union(self, *args) def is_choosable(self, *args): - """is_choosable(self) -> bool""" + """ + is_choosable(self) -> bool + """ return _idaapi.struc_t_is_choosable(self, *args) def from_til(self, *args): - """from_til(self) -> bool""" + """ + from_til(self) -> bool + """ return _idaapi.struc_t_from_til(self, *args) def is_hidden(self, *args): - """is_hidden(self) -> bool""" + """ + is_hidden(self) -> bool + """ return _idaapi.struc_t_is_hidden(self, *args) def get_alignment(self, *args): - """get_alignment(self) -> int""" + """ + get_alignment(self) -> int + """ return _idaapi.struc_t_get_alignment(self, *args) - def is_ghost(self, *args): - """is_ghost(self) -> bool""" - return _idaapi.struc_t_is_ghost(self, *args) - def set_alignment(self, *args): - """set_alignment(self, shift)""" + """ + set_alignment(self, shift) + """ return _idaapi.struc_t_set_alignment(self, *args) - def set_ghost(self, *args): - """set_ghost(self, _is_ghost)""" - return _idaapi.struc_t_set_ghost(self, *args) - ordinal = _swig_property(_idaapi.struc_t_ordinal_get, _idaapi.struc_t_ordinal_set) def get_member(self, *args): - """get_member(self, index) -> member_t""" + """ + get_member(self, index) -> member_t + """ return _idaapi.struc_t_get_member(self, *args) __swig_destroy__ = _idaapi.delete_struc_t @@ -42911,51 +48667,72 @@ SF_TYPLIB = _idaapi.SF_TYPLIB SF_HIDDEN = _idaapi.SF_HIDDEN SF_FRAME = _idaapi.SF_FRAME SF_ALIGN = _idaapi.SF_ALIGN -SF_GHOST = _idaapi.SF_GHOST def get_struc_qty(*args): - """get_struc_qty() -> size_t""" + """ + get_struc_qty() -> size_t + """ return _idaapi.get_struc_qty(*args) def get_first_struc_idx(*args): - """get_first_struc_idx() -> uval_t""" + """ + get_first_struc_idx() -> uval_t + """ return _idaapi.get_first_struc_idx(*args) def get_last_struc_idx(*args): - """get_last_struc_idx() -> uval_t""" + """ + get_last_struc_idx() -> uval_t + """ return _idaapi.get_last_struc_idx(*args) def get_prev_struc_idx(*args): - """get_prev_struc_idx(idx) -> uval_t""" + """ + get_prev_struc_idx(idx) -> uval_t + """ return _idaapi.get_prev_struc_idx(*args) def get_next_struc_idx(*args): - """get_next_struc_idx(idx) -> uval_t""" + """ + get_next_struc_idx(idx) -> uval_t + """ return _idaapi.get_next_struc_idx(*args) def get_struc_idx(*args): - """get_struc_idx(id) -> uval_t""" + """ + get_struc_idx(id) -> uval_t + """ return _idaapi.get_struc_idx(*args) def get_struc_by_idx(*args): - """get_struc_by_idx(idx) -> tid_t""" + """ + get_struc_by_idx(idx) -> tid_t + """ return _idaapi.get_struc_by_idx(*args) def get_struc(*args): - """get_struc(id) -> struc_t""" + """ + get_struc(id) -> struc_t + """ return _idaapi.get_struc(*args) def get_struc_id(*args): - """get_struc_id(name) -> tid_t""" + """ + get_struc_id(name) -> tid_t + """ return _idaapi.get_struc_id(*args) def get_struc_name(*args): - """get_struc_name(id) -> ssize_t""" + """ + get_struc_name(id) -> ssize_t + """ return _idaapi.get_struc_name(*args) def get_struc_cmt(*args): - """get_struc_cmt(id, repeatable) -> ssize_t""" + """ + get_struc_cmt(id, repeatable) -> ssize_t + """ return _idaapi.get_struc_cmt(*args) def get_struc_size(*args): @@ -42966,108 +48743,166 @@ def get_struc_size(*args): return _idaapi.get_struc_size(*args) def get_struc_prev_offset(*args): - """get_struc_prev_offset(sptr, offset) -> ea_t""" + """ + get_struc_prev_offset(sptr, offset) -> ea_t + """ return _idaapi.get_struc_prev_offset(*args) def get_struc_next_offset(*args): - """get_struc_next_offset(sptr, offset) -> ea_t""" + """ + get_struc_next_offset(sptr, offset) -> ea_t + """ return _idaapi.get_struc_next_offset(*args) def get_struc_last_offset(*args): - """get_struc_last_offset(sptr) -> ea_t""" + """ + get_struc_last_offset(sptr) -> ea_t + """ return _idaapi.get_struc_last_offset(*args) def get_struc_first_offset(*args): - """get_struc_first_offset(sptr) -> ea_t""" + """ + get_struc_first_offset(sptr) -> ea_t + """ return _idaapi.get_struc_first_offset(*args) def get_max_offset(*args): - """get_max_offset(sptr) -> ea_t""" + """ + get_max_offset(sptr) -> ea_t + """ return _idaapi.get_max_offset(*args) def is_varstr(*args): - """is_varstr(id) -> bool""" + """ + is_varstr(id) -> bool + """ return _idaapi.is_varstr(*args) def is_union(*args): - """is_union(id) -> bool""" + """ + is_union(id) -> bool + """ return _idaapi.is_union(*args) def get_member_struc(*args): - """get_member_struc(fullname) -> struc_t""" + """ + get_member_struc(fullname) -> struc_t + """ return _idaapi.get_member_struc(*args) def get_sptr(*args): - """get_sptr(mptr) -> struc_t""" + """ + get_sptr(mptr) -> struc_t + """ return _idaapi.get_sptr(*args) def get_member(*args): - """get_member(sptr, offset) -> member_t""" + """ + get_member(sptr, offset) -> member_t + """ return _idaapi.get_member(*args) def get_member_by_name(*args): - """get_member_by_name(sptr, membername) -> member_t""" + """ + get_member_by_name(sptr, membername) -> member_t + """ return _idaapi.get_member_by_name(*args) def get_member_by_fullname(*args): - """get_member_by_fullname(fullname, sptr_place) -> member_t""" + """ + get_member_by_fullname(fullname, sptr_place) -> member_t + """ return _idaapi.get_member_by_fullname(*args) def get_member_fullname(*args): - """get_member_fullname(mid) -> ssize_t""" + """ + get_member_fullname(mid) -> ssize_t + """ return _idaapi.get_member_fullname(*args) -def get_member_name2(*args): - """get_member_name2(mid) -> ssize_t""" - return _idaapi.get_member_name2(*args) +def get_member_name(*args): + """ + get_member_name(mid) -> ssize_t + """ + return _idaapi.get_member_name(*args) def get_member_cmt(*args): - """get_member_cmt(mid, repeatable) -> ssize_t""" + """ + get_member_cmt(mid, repeatable) -> ssize_t + """ return _idaapi.get_member_cmt(*args) def get_member_size(*args): - """get_member_size(mptr) -> asize_t""" + """ + get_member_size(mptr) -> asize_t + """ return _idaapi.get_member_size(*args) def is_varmember(*args): - """is_varmember(mptr) -> bool""" + """ + is_varmember(mptr) -> bool + """ return _idaapi.is_varmember(*args) def get_best_fit_member(*args): - """get_best_fit_member(sptr, offset) -> member_t""" + """ + get_best_fit_member(sptr, offset) -> member_t + """ return _idaapi.get_best_fit_member(*args) def get_next_member_idx(*args): - """get_next_member_idx(sptr, off) -> ssize_t""" + """ + get_next_member_idx(sptr, off) -> ssize_t + """ return _idaapi.get_next_member_idx(*args) def get_prev_member_idx(*args): - """get_prev_member_idx(sptr, off) -> ssize_t""" + """ + get_prev_member_idx(sptr, off) -> ssize_t + """ return _idaapi.get_prev_member_idx(*args) def add_struc(*args): - """add_struc(idx, name, is_union=False) -> tid_t""" + """ + add_struc(idx, name, is_union=False) -> tid_t + """ return _idaapi.add_struc(*args) def del_struc(*args): - """del_struc(sptr) -> bool""" + """ + del_struc(sptr) -> bool + """ return _idaapi.del_struc(*args) def set_struc_idx(*args): - """set_struc_idx(sptr, idx) -> bool""" + """ + set_struc_idx(sptr, idx) -> bool + """ return _idaapi.set_struc_idx(*args) def set_struc_align(*args): - """set_struc_align(sptr, shift) -> bool""" + """ + set_struc_align(sptr, shift) -> bool + """ return _idaapi.set_struc_align(*args) def set_struc_name(*args): - """set_struc_name(id, name) -> bool""" + """ + set_struc_name(id, name) -> bool + """ return _idaapi.set_struc_name(*args) def set_struc_cmt(*args): - """set_struc_cmt(id, cmt, repeatable) -> bool""" + """ + set_struc_cmt(id, cmt, repeatable) -> bool + """ return _idaapi.set_struc_cmt(*args) + +def add_struc_member(*args): + """ + add_struc_member(sptr, fieldname, offset, flag, mt, nbytes) -> int + """ + return _idaapi.add_struc_member(*args) STRUC_ERROR_MEMBER_OK = _idaapi.STRUC_ERROR_MEMBER_OK STRUC_ERROR_MEMBER_NAME = _idaapi.STRUC_ERROR_MEMBER_NAME STRUC_ERROR_MEMBER_OFFSET = _idaapi.STRUC_ERROR_MEMBER_OFFSET @@ -43078,45 +48913,47 @@ STRUC_ERROR_MEMBER_UNIVAR = _idaapi.STRUC_ERROR_MEMBER_UNIVAR STRUC_ERROR_MEMBER_VARLAST = _idaapi.STRUC_ERROR_MEMBER_VARLAST STRUC_ERROR_MEMBER_NESTED = _idaapi.STRUC_ERROR_MEMBER_NESTED -def add_struc_member(*args): - """add_struc_member(sptr, fieldname, offset, flag, mt, nbytes) -> struc_error_t""" - return _idaapi.add_struc_member(*args) - def del_struc_member(*args): - """del_struc_member(sptr, offset) -> bool""" + """ + del_struc_member(sptr, offset) -> bool + """ return _idaapi.del_struc_member(*args) def del_struc_members(*args): - """del_struc_members(sptr, off1, off2) -> int""" + """ + del_struc_members(sptr, off1, off2) -> int + """ return _idaapi.del_struc_members(*args) def set_member_name(*args): - """set_member_name(sptr, offset, name) -> bool""" + """ + set_member_name(sptr, offset, name) -> bool + """ return _idaapi.set_member_name(*args) def set_member_type(*args): - """set_member_type(sptr, offset, flag, mt, nbytes) -> bool""" + """ + set_member_type(sptr, offset, flag, mt, nbytes) -> bool + """ return _idaapi.set_member_type(*args) def set_member_cmt(*args): - """set_member_cmt(mptr, cmt, repeatable) -> bool""" + """ + set_member_cmt(mptr, cmt, repeatable) -> bool + """ return _idaapi.set_member_cmt(*args) def expand_struc(*args): - """expand_struc(sptr, offset, delta, recalc=True) -> bool""" + """ + expand_struc(sptr, offset, delta, recalc=True) -> bool + """ return _idaapi.expand_struc(*args) def save_struc2(*args): - """save_struc2(sptr, may_update_ltypes=True)""" + """ + save_struc2(sptr, may_update_ltypes=True) + """ return _idaapi.save_struc2(*args) - -def set_struc_hidden(*args): - """set_struc_hidden(sptr, is_hidden)""" - return _idaapi.set_struc_hidden(*args) - -def set_struc_listed(*args): - """set_struc_listed(sptr, is_listed)""" - return _idaapi.set_struc_listed(*args) SMT_BADARG = _idaapi.SMT_BADARG SMT_NOCOMPAT = _idaapi.SMT_NOCOMPAT SMT_WORSE = _idaapi.SMT_WORSE @@ -43128,15 +48965,21 @@ SMT_OK = _idaapi.SMT_OK SMT_KEEP = _idaapi.SMT_KEEP def get_member_tinfo2(*args): - """get_member_tinfo2(mptr, tif) -> bool""" + """ + get_member_tinfo2(mptr, tif) -> bool + """ return _idaapi.get_member_tinfo2(*args) def del_member_tinfo(*args): - """del_member_tinfo(sptr, mptr) -> bool""" + """ + del_member_tinfo(sptr, mptr) -> bool + """ return _idaapi.del_member_tinfo(*args) def set_member_tinfo2(*args): - """set_member_tinfo2(sptr, mptr, memoff, tif, flags) -> smt_code_t""" + """ + set_member_tinfo2(sptr, mptr, memoff, tif, flags) -> smt_code_t + """ return _idaapi.set_member_tinfo2(*args) SET_MEMTI_MAY_DESTROY = _idaapi.SET_MEMTI_MAY_DESTROY SET_MEMTI_COMPATIBLE = _idaapi.SET_MEMTI_COMPATIBLE @@ -43144,42 +48987,51 @@ SET_MEMTI_FUNCARG = _idaapi.SET_MEMTI_FUNCARG SET_MEMTI_BYTIL = _idaapi.SET_MEMTI_BYTIL def get_or_guess_member_tinfo2(*args): - """get_or_guess_member_tinfo2(mptr, tif) -> bool""" + """ + get_or_guess_member_tinfo2(mptr, tif) -> bool + """ return _idaapi.get_or_guess_member_tinfo2(*args) def retrieve_member_info(*args): - """retrieve_member_info(mptr, buf) -> opinfo_t""" + """ + retrieve_member_info(mptr, buf) -> opinfo_t + """ return _idaapi.retrieve_member_info(*args) def is_anonymous_member_name(*args): - """is_anonymous_member_name(name) -> bool""" + """ + is_anonymous_member_name(name) -> bool + """ return _idaapi.is_anonymous_member_name(*args) def is_dummy_member_name(*args): - """is_dummy_member_name(name) -> bool""" + """ + is_dummy_member_name(name) -> bool + """ return _idaapi.is_dummy_member_name(*args) -def get_member_by_id(*args): - """ - get_member_by_id(mid, sptr_place) -> member_t - get_member_by_id(mid, sptr_place=None) -> member_t - """ - return _idaapi.get_member_by_id(*args) - def is_member_id(*args): - """is_member_id(mid) -> bool""" + """ + is_member_id(mid) -> bool + """ return _idaapi.is_member_id(*args) def is_special_member(*args): - """is_special_member(id) -> bool""" + """ + is_special_member(id) -> bool + """ return _idaapi.is_special_member(*args) class struct_field_visitor_t(object): - """Proxy of C++ struct_field_visitor_t class""" + """ + Proxy of C++ struct_field_visitor_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr def visit_field(self, *args): - """visit_field(self, sptr, mptr) -> int""" + """ + visit_field(self, sptr, mptr) -> int + """ return _idaapi.struct_field_visitor_t_visit_field(self, *args) __swig_destroy__ = _idaapi.delete_struct_field_visitor_t @@ -43189,63 +49041,95 @@ struct_field_visitor_t_swigregister(struct_field_visitor_t) def visit_stroff_fields(*args): - """visit_stroff_fields(sfv, path, plen, disp, appzero) -> flags_t""" + """ + visit_stroff_fields(sfv, path, plen, disp, appzero) -> flags_t + """ return _idaapi.visit_stroff_fields(*args) def stroff_as_size(*args): - """stroff_as_size(plen, sptr, value) -> bool""" + """ + stroff_as_size(plen, sptr, value) -> bool + """ return _idaapi.stroff_as_size(*args) def save_struc(*args): - """save_struc(sptr)""" + """ + save_struc(sptr) + """ return _idaapi.save_struc(*args) def get_or_guess_member_type(*args): - """get_or_guess_member_type(mptr, type, tsize) -> bool""" + """ + get_or_guess_member_type(mptr, type, tsize) -> bool + """ return _idaapi.get_or_guess_member_type(*args) def get_member_ti(*args): - """get_member_ti(mptr, buf, bufsize) -> bool""" + """ + get_member_ti(mptr, buf, bufsize) -> bool + """ return _idaapi.get_member_ti(*args) def set_member_ti(*args): - """set_member_ti(sptr, mptr, type, flags) -> bool""" + """ + set_member_ti(sptr, mptr, type, flags) -> bool + """ return _idaapi.set_member_ti(*args) +def del_ti(*args): + """ + del_ti(ea) + del_ti(ea, n) + del_ti(sptr, mptr) -> bool + """ + return _idaapi.del_ti(*args) + def get_or_guess_member_tinfo(*args): - """get_or_guess_member_tinfo(mptr, type, fields) -> bool""" + """ + get_or_guess_member_tinfo(mptr, type, fields) -> bool + """ return _idaapi.get_or_guess_member_tinfo(*args) def get_member_tinfo(*args): - """get_member_tinfo(mptr, buf, fields) -> bool""" + """ + get_member_tinfo(mptr, buf, fields) -> bool + """ return _idaapi.get_member_tinfo(*args) def set_member_tinfo(*args): - """set_member_tinfo(til, sptr, mptr, memoff, type, fields, flags) -> bool""" + """ + set_member_tinfo(til, sptr, mptr, memoff, type, fields, flags) -> bool + """ return _idaapi.set_member_tinfo(*args) -def get_member_name(*args): - """get_member_name(mid) -> ssize_t""" - return _idaapi.get_member_name(*args) - def get_operand_immvals(*args): - """get_operand_immvals(ea, n, v) -> size_t""" + """ + get_operand_immvals(ea, n, v) -> size_t + """ return _idaapi.get_operand_immvals(*args) def dataSeg_opreg(*args): - """dataSeg_opreg(opnum, rgnum) -> ea_t""" + """ + dataSeg_opreg(opnum, rgnum) -> ea_t + """ return _idaapi.dataSeg_opreg(*args) def dataSeg_op(*args): - """dataSeg_op(opnum) -> ea_t""" + """ + dataSeg_op(opnum) -> ea_t + """ return _idaapi.dataSeg_op(*args) def dataSeg(*args): - """dataSeg() -> ea_t""" + """ + dataSeg() -> ea_t + """ return _idaapi.dataSeg(*args) def codeSeg(*args): - """codeSeg(addr, opnum) -> ea_t""" + """ + codeSeg(addr, opnum) -> ea_t + """ return _idaapi.codeSeg(*args) tbo_123 = _idaapi.tbo_123 tbo_132 = _idaapi.tbo_132 @@ -43255,31 +49139,45 @@ tbo_312 = _idaapi.tbo_312 tbo_321 = _idaapi.tbo_321 def ua_next_byte(*args): - """ua_next_byte() -> uint8""" + """ + ua_next_byte() -> uint8 + """ return _idaapi.ua_next_byte(*args) def ua_next_word(*args): - """ua_next_word() -> uint16""" + """ + ua_next_word() -> uint16 + """ return _idaapi.ua_next_word(*args) def ua_next_long(*args): - """ua_next_long() -> uint32""" + """ + ua_next_long() -> uint32 + """ return _idaapi.ua_next_long(*args) def ua_next_qword(*args): - """ua_next_qword() -> uint64""" + """ + ua_next_qword() -> uint64 + """ return _idaapi.ua_next_qword(*args) def OutMnem(*args): - """OutMnem(width=8, postfix=None) -> int""" + """ + OutMnem(width=8, postfix=None) -> int + """ return _idaapi.OutMnem(*args) def OutBadInstruction(*args): - """OutBadInstruction()""" + """ + OutBadInstruction() + """ return _idaapi.OutBadInstruction(*args) def out_one_operand(*args): - """out_one_operand(n) -> bool""" + """ + out_one_operand(n) -> bool + """ return _idaapi.out_one_operand(*args) OOF_SIGNMASK = _idaapi.OOF_SIGNMASK OOFS_IFSIGN = _idaapi.OOFS_IFSIGN @@ -43301,405 +49199,678 @@ OOF_NOBNOT = _idaapi.OOF_NOBNOT OOF_SPACES = _idaapi.OOF_SPACES def out_symbol(*args): - """out_symbol(c)""" + """ + out_symbol(c) + """ return _idaapi.out_symbol(*args) def out_line(*args): - """out_line(str, color)""" + """ + out_line(str, color) + """ return _idaapi.out_line(*args) def out_keyword(*args): - """out_keyword(str)""" + """ + out_keyword(str) + """ return _idaapi.out_keyword(*args) def out_register(*args): - """out_register(str)""" + """ + out_register(str) + """ return _idaapi.out_register(*args) def out_tagon(*args): - """out_tagon(tag)""" + """ + out_tagon(tag) + """ return _idaapi.out_tagon(*args) def out_tagoff(*args): - """out_tagoff(tag)""" + """ + out_tagoff(tag) + """ return _idaapi.out_tagoff(*args) def out_addr_tag(*args): - """out_addr_tag(ea)""" + """ + out_addr_tag(ea) + """ return _idaapi.out_addr_tag(*args) def out_colored_register_line(*args): - """out_colored_register_line(str)""" + """ + out_colored_register_line(str) + """ return _idaapi.out_colored_register_line(*args) def OutLine(*args): - """OutLine(s)""" + """ + OutLine(s) + """ return _idaapi.OutLine(*args) def OutChar(*args): - """OutChar(c)""" + """ + OutChar(c) + """ return _idaapi.OutChar(*args) def OutLong(*args): - """OutLong(Word, radix)""" + """ + OutLong(Word, radix) + """ return _idaapi.OutLong(*args) def out_long(*args): - """out_long(v, radix)""" + """ + out_long(v, radix) + """ return _idaapi.out_long(*args) def ua_dodata2(*args): - """ua_dodata2(opoff, ea, dtype) -> bool""" + """ + ua_dodata2(opoff, ea, dtype) -> bool + """ return _idaapi.ua_dodata2(*args) def ua_add_cref(*args): - """ua_add_cref(opoff, to, type)""" + """ + ua_add_cref(opoff, to, type) + """ return _idaapi.ua_add_cref(*args) def ua_add_dref(*args): - """ua_add_dref(opoff, to, type)""" + """ + ua_add_dref(opoff, to, type) + """ return _idaapi.ua_add_dref(*args) def get_dtyp_flag(*args): - """get_dtyp_flag(dtype) -> flags_t""" + """ + get_dtyp_flag(dtype) -> flags_t + """ return _idaapi.get_dtyp_flag(*args) def get_dtyp_size(*args): - """get_dtyp_size(dtype) -> size_t""" + """ + get_dtyp_size(dtype) -> size_t + """ return _idaapi.get_dtyp_size(*args) def get_dtyp_by_size(*args): - """get_dtyp_by_size(size) -> char""" + """ + get_dtyp_by_size(size) -> char + """ return _idaapi.get_dtyp_by_size(*args) def create_insn(*args): - """create_insn(ea) -> int""" + """ + create_insn(ea) -> int + """ return _idaapi.create_insn(*args) def decode_insn(*args): - """decode_insn(ea) -> int""" + """ + decode_insn(ea) -> int + """ return _idaapi.decode_insn(*args) def ua_outop2(*args): - """ua_outop2(ea, n, flags=0) -> bool""" + """ + ua_outop2(ea, n, flags=0) -> bool + """ return _idaapi.ua_outop2(*args) def ua_mnem(*args): - """ua_mnem(ea) -> char const *""" + """ + ua_mnem(ea) -> char const * + """ return _idaapi.ua_mnem(*args) def decode_prev_insn(*args): - """decode_prev_insn(ea) -> ea_t""" + """ + decode_prev_insn(ea) -> ea_t + """ return _idaapi.decode_prev_insn(*args) def guess_table_address(*args): - """guess_table_address() -> ea_t""" + """ + guess_table_address() -> ea_t + """ return _idaapi.guess_table_address(*args) def guess_table_size(*args): - """guess_table_size(jump_table) -> asize_t""" + """ + guess_table_size(jump_table) -> asize_t + """ return _idaapi.guess_table_size(*args) def ua_dodata(*args): - """ua_dodata(ea, dtype)""" + """ + ua_dodata(ea, dtype) + """ return _idaapi.ua_dodata(*args) def ua_outop(*args): - """ua_outop(ea, n) -> bool""" + """ + ua_outop(ea, n) -> bool + """ return _idaapi.ua_outop(*args) def ua_ana0(*args): - """ua_ana0(ea) -> int""" + """ + ua_ana0(ea) -> int + """ return _idaapi.ua_ana0(*args) def ua_code(*args): - """ua_code(ea) -> int""" + """ + ua_code(ea) -> int + """ return _idaapi.ua_code(*args) def init_output_buffer(*args): - """init_output_buffer(size=1024) -> PyObject *""" + """ + init_output_buffer(size=1024) -> PyObject * + + + This function initialize an output buffer with the given size. + It should be called before using any out_xxxx() functions. + @return: It returns a string. This string should then be passed to MakeLine(). + This function could return None if it failed to create a buffer with the given size. + """ return _idaapi.init_output_buffer(*args) def term_output_buffer(*args): - """term_output_buffer()""" + """ + term_output_buffer() + + + Use this function to terminate an output buffer. + """ return _idaapi.term_output_buffer(*args) def decode_preceding_insn(*args): - """decode_preceding_insn(ea) -> PyObject *""" + """ + decode_preceding_insn(ea) -> PyObject * + + + Decodes the preceding instruction. Please check ua.hpp / decode_preceding_insn() + @param ea: current ea + @return: tuple(preceeding_ea or BADADDR, farref = Boolean) + """ return _idaapi.decode_preceding_insn(*args) def OutValue(*args): - """OutValue(x, outflags=0) -> flags_t""" + """ + OutValue(x, outflags=0) -> flags_t + + + Output immediate value + @param op: operand (of type op_t) + @return: flags of the output value + -1: value is output with COLOR_ERROR + 0: value is output as a number or character or segment + """ return _idaapi.OutValue(*args) def get_stkvar(*args): - """get_stkvar(py_op, py_v) -> PyObject *""" + """ + get_stkvar(py_op, py_v) -> PyObject * + + + Get pointer to stack variable + @param op: reference to instruction operand + @param v: immediate value in the operand (usually op.addr) + @return: + - None on failure + - tuple(member_t, actval) + where actval: actual value used to fetch stack variable + """ return _idaapi.get_stkvar(*args) def add_stkvar3(*args): - """add_stkvar3(py_op, py_v, flags) -> bool""" + """ + add_stkvar3(py_op, py_v, flags) -> bool + + + Automatically add stack variable if doesn't exist + Processor modules should use ua_stkvar2() + @param op: reference to instruction operand + @param v: immediate value in the operand (usually op.addr) + @param flags: combination of STKVAR_... constants + @return: Boolean + """ return _idaapi.add_stkvar3(*args) def apply_type_to_stkarg(*args): - """apply_type_to_stkarg(py_op, py_uv, py_type, name) -> bool""" + """ + apply_type_to_stkarg(py_op, py_uv, py_type, name) -> bool + + + Apply type information to a stack variable + + @param op: reference to instruction operand + @param v: immediate value in the operand (usually op.addr) + @param type: type string. Retrieve from idc.ParseType("type string", flags)[1] + @param name: stack variable name + + @return: Boolean + """ return _idaapi.apply_type_to_stkarg(*args) def OutImmChar(*args): - """OutImmChar(x)""" + """ + OutImmChar(x) + + + Output operand value as a commented character constant + @param op: operand (of type op_t) + @return: None + """ return _idaapi.OutImmChar(*args) def ua_stkvar2(*args): - """ua_stkvar2(x, v, flags) -> bool""" + """ + ua_stkvar2(x, v, flags) -> bool + + + Create or modify a stack variable in the function frame. + Please check ua.hpp / ua_stkvar2() + @param op: operand (of type op_t) + @return: None + """ return _idaapi.ua_stkvar2(*args) def ua_add_off_drefs(*args): - """ua_add_off_drefs(py_op, type) -> ea_t""" + """ + ua_add_off_drefs(py_op, type) -> ea_t + + + Add xrefs for offset operand of the current instruction + Please check ua.hpp / ua_add_off_drefs() + @param op: operand (of type op_t) + @return: None + """ return _idaapi.ua_add_off_drefs(*args) def ua_add_off_drefs2(*args): - """ua_add_off_drefs2(py_op, type, outf) -> ea_t""" + """ + ua_add_off_drefs2(py_op, type, outf) -> ea_t + + + Add xrefs for offset operand of the current instruction + Please check ua.hpp / ua_add_off_drefs2() + @return: ea_t + """ return _idaapi.ua_add_off_drefs2(*args) def out_name_expr(*args): - """out_name_expr(py_op, ea, py_off) -> bool""" + """ + out_name_expr(py_op, ea, py_off) -> bool + + + Output a name expression + @param op: operand (of type op_t) + @param ea: address of expression + @param off: the value of name expression. this parameter is used only to + check that the name expression will have the wanted value. + You may pass BADADDR for this parameter. + @return: true if the name expression has been produced + """ return _idaapi.out_name_expr(*args) -def construct_macro(*args): - """construct_macro(enable, build_macro) -> bool""" - return _idaapi.construct_macro(*args) - def insn_t_get_op_link(*args): - """insn_t_get_op_link(py_insn_lnk, i) -> PyObject *""" + """ + insn_t_get_op_link(py_insn_lnk, i) -> PyObject * + """ return _idaapi.insn_t_get_op_link(*args) def insn_t_create(*args): - """insn_t_create() -> PyObject *""" + """ + insn_t_create() -> PyObject * + """ return _idaapi.insn_t_create(*args) def op_t_create(*args): - """op_t_create() -> PyObject *""" + """ + op_t_create() -> PyObject * + """ return _idaapi.op_t_create(*args) def op_t_assign(*args): - """op_t_assign(self, other) -> bool""" + """ + op_t_assign(self, other) -> bool + """ return _idaapi.op_t_assign(*args) def insn_t_assign(*args): - """insn_t_assign(self, other) -> bool""" + """ + insn_t_assign(self, other) -> bool + """ return _idaapi.insn_t_assign(*args) def op_t_destroy(*args): - """op_t_destroy(py_obj) -> bool""" + """ + op_t_destroy(py_obj) -> bool + """ return _idaapi.op_t_destroy(*args) def insn_t_destroy(*args): - """insn_t_destroy(py_obj) -> bool""" + """ + insn_t_destroy(py_obj) -> bool + """ return _idaapi.insn_t_destroy(*args) def py_get_global_cmd_link(*args): - """py_get_global_cmd_link() -> PyObject *""" + """ + py_get_global_cmd_link() -> PyObject * + """ return _idaapi.py_get_global_cmd_link(*args) def insn_t_is_canon_insn(*args): - """insn_t_is_canon_insn(itype) -> PyObject *""" + """ + insn_t_is_canon_insn(itype) -> PyObject * + """ return _idaapi.insn_t_is_canon_insn(*args) def insn_t_get_canon_feature(*args): - """insn_t_get_canon_feature(itype) -> PyObject *""" + """ + insn_t_get_canon_feature(itype) -> PyObject * + """ return _idaapi.insn_t_get_canon_feature(*args) def insn_t_get_canon_mnem(*args): - """insn_t_get_canon_mnem(itype) -> PyObject *""" + """ + insn_t_get_canon_mnem(itype) -> PyObject * + """ return _idaapi.insn_t_get_canon_mnem(*args) def insn_t_get_cs(*args): - """insn_t_get_cs(self) -> PyObject *""" + """ + insn_t_get_cs(self) -> PyObject * + """ return _idaapi.insn_t_get_cs(*args) def insn_t_set_cs(*args): - """insn_t_set_cs(self, value)""" + """ + insn_t_set_cs(self, value) + """ return _idaapi.insn_t_set_cs(*args) def insn_t_get_ip(*args): - """insn_t_get_ip(self) -> PyObject *""" + """ + insn_t_get_ip(self) -> PyObject * + """ return _idaapi.insn_t_get_ip(*args) def insn_t_set_ip(*args): - """insn_t_set_ip(self, value)""" + """ + insn_t_set_ip(self, value) + """ return _idaapi.insn_t_set_ip(*args) def insn_t_get_ea(*args): - """insn_t_get_ea(self) -> PyObject *""" + """ + insn_t_get_ea(self) -> PyObject * + """ return _idaapi.insn_t_get_ea(*args) def insn_t_set_ea(*args): - """insn_t_set_ea(self, value)""" + """ + insn_t_set_ea(self, value) + """ return _idaapi.insn_t_set_ea(*args) def insn_t_get_itype(*args): - """insn_t_get_itype(self) -> PyObject *""" + """ + insn_t_get_itype(self) -> PyObject * + """ return _idaapi.insn_t_get_itype(*args) def insn_t_set_itype(*args): - """insn_t_set_itype(self, value)""" + """ + insn_t_set_itype(self, value) + """ return _idaapi.insn_t_set_itype(*args) def insn_t_get_size(*args): - """insn_t_get_size(self) -> PyObject *""" + """ + insn_t_get_size(self) -> PyObject * + """ return _idaapi.insn_t_get_size(*args) def insn_t_set_size(*args): - """insn_t_set_size(self, value)""" + """ + insn_t_set_size(self, value) + """ return _idaapi.insn_t_set_size(*args) def insn_t_get_auxpref(*args): - """insn_t_get_auxpref(self) -> PyObject *""" + """ + insn_t_get_auxpref(self) -> PyObject * + """ return _idaapi.insn_t_get_auxpref(*args) def insn_t_set_auxpref(*args): - """insn_t_set_auxpref(self, value)""" + """ + insn_t_set_auxpref(self, value) + """ return _idaapi.insn_t_set_auxpref(*args) def insn_t_get_segpref(*args): - """insn_t_get_segpref(self) -> PyObject *""" + """ + insn_t_get_segpref(self) -> PyObject * + """ return _idaapi.insn_t_get_segpref(*args) def insn_t_set_segpref(*args): - """insn_t_set_segpref(self, value)""" + """ + insn_t_set_segpref(self, value) + """ return _idaapi.insn_t_set_segpref(*args) def insn_t_get_insnpref(*args): - """insn_t_get_insnpref(self) -> PyObject *""" + """ + insn_t_get_insnpref(self) -> PyObject * + """ return _idaapi.insn_t_get_insnpref(*args) def insn_t_set_insnpref(*args): - """insn_t_set_insnpref(self, value)""" + """ + insn_t_set_insnpref(self, value) + """ return _idaapi.insn_t_set_insnpref(*args) def insn_t_get_flags(*args): - """insn_t_get_flags(self) -> PyObject *""" + """ + insn_t_get_flags(self) -> PyObject * + """ return _idaapi.insn_t_get_flags(*args) def insn_t_set_flags(*args): - """insn_t_set_flags(self, value)""" + """ + insn_t_set_flags(self, value) + """ return _idaapi.insn_t_set_flags(*args) def op_t_get_n(*args): - """op_t_get_n(self) -> PyObject *""" + """ + op_t_get_n(self) -> PyObject * + """ return _idaapi.op_t_get_n(*args) def op_t_set_n(*args): - """op_t_set_n(self, value)""" + """ + op_t_set_n(self, value) + """ return _idaapi.op_t_set_n(*args) def op_t_get_type(*args): - """op_t_get_type(self) -> PyObject *""" + """ + op_t_get_type(self) -> PyObject * + """ return _idaapi.op_t_get_type(*args) def op_t_set_type(*args): - """op_t_set_type(self, value)""" + """ + op_t_set_type(self, value) + """ return _idaapi.op_t_set_type(*args) def op_t_get_offb(*args): - """op_t_get_offb(self) -> PyObject *""" + """ + op_t_get_offb(self) -> PyObject * + """ return _idaapi.op_t_get_offb(*args) def op_t_set_offb(*args): - """op_t_set_offb(self, value)""" + """ + op_t_set_offb(self, value) + """ return _idaapi.op_t_set_offb(*args) def op_t_get_offo(*args): - """op_t_get_offo(self) -> PyObject *""" + """ + op_t_get_offo(self) -> PyObject * + """ return _idaapi.op_t_get_offo(*args) def op_t_set_offo(*args): - """op_t_set_offo(self, value)""" + """ + op_t_set_offo(self, value) + """ return _idaapi.op_t_set_offo(*args) def op_t_get_flags(*args): - """op_t_get_flags(self) -> PyObject *""" + """ + op_t_get_flags(self) -> PyObject * + """ return _idaapi.op_t_get_flags(*args) def op_t_set_flags(*args): - """op_t_set_flags(self, value)""" + """ + op_t_set_flags(self, value) + """ return _idaapi.op_t_set_flags(*args) def op_t_get_dtyp(*args): - """op_t_get_dtyp(self) -> PyObject *""" + """ + op_t_get_dtyp(self) -> PyObject * + """ return _idaapi.op_t_get_dtyp(*args) def op_t_set_dtyp(*args): - """op_t_set_dtyp(self, value)""" + """ + op_t_set_dtyp(self, value) + """ return _idaapi.op_t_set_dtyp(*args) def op_t_get_reg_phrase(*args): - """op_t_get_reg_phrase(self) -> PyObject *""" + """ + op_t_get_reg_phrase(self) -> PyObject * + """ return _idaapi.op_t_get_reg_phrase(*args) def op_t_set_reg_phrase(*args): - """op_t_set_reg_phrase(self, value)""" + """ + op_t_set_reg_phrase(self, value) + """ return _idaapi.op_t_set_reg_phrase(*args) def op_t_get_value(*args): - """op_t_get_value(self) -> PyObject *""" + """ + op_t_get_value(self) -> PyObject * + """ return _idaapi.op_t_get_value(*args) def op_t_set_value(*args): - """op_t_set_value(self, value)""" + """ + op_t_set_value(self, value) + """ return _idaapi.op_t_set_value(*args) def op_t_get_addr(*args): - """op_t_get_addr(self) -> PyObject *""" + """ + op_t_get_addr(self) -> PyObject * + """ return _idaapi.op_t_get_addr(*args) def op_t_set_addr(*args): - """op_t_set_addr(self, value)""" + """ + op_t_set_addr(self, value) + """ return _idaapi.op_t_set_addr(*args) def op_t_get_specval(*args): - """op_t_get_specval(self) -> PyObject *""" + """ + op_t_get_specval(self) -> PyObject * + """ return _idaapi.op_t_get_specval(*args) def op_t_set_specval(*args): - """op_t_set_specval(self, value)""" + """ + op_t_set_specval(self, value) + """ return _idaapi.op_t_set_specval(*args) def op_t_get_specflag1(*args): - """op_t_get_specflag1(self) -> PyObject *""" + """ + op_t_get_specflag1(self) -> PyObject * + """ return _idaapi.op_t_get_specflag1(*args) def op_t_set_specflag1(*args): - """op_t_set_specflag1(self, value)""" + """ + op_t_set_specflag1(self, value) + """ return _idaapi.op_t_set_specflag1(*args) def op_t_get_specflag2(*args): - """op_t_get_specflag2(self) -> PyObject *""" + """ + op_t_get_specflag2(self) -> PyObject * + """ return _idaapi.op_t_get_specflag2(*args) def op_t_set_specflag2(*args): - """op_t_set_specflag2(self, value)""" + """ + op_t_set_specflag2(self, value) + """ return _idaapi.op_t_set_specflag2(*args) def op_t_get_specflag3(*args): - """op_t_get_specflag3(self) -> PyObject *""" + """ + op_t_get_specflag3(self) -> PyObject * + """ return _idaapi.op_t_get_specflag3(*args) def op_t_set_specflag3(*args): - """op_t_set_specflag3(self, value)""" + """ + op_t_set_specflag3(self, value) + """ return _idaapi.op_t_set_specflag3(*args) def op_t_get_specflag4(*args): - """op_t_get_specflag4(self) -> PyObject *""" + """ + op_t_get_specflag4(self) -> PyObject * + """ return _idaapi.op_t_get_specflag4(*args) def op_t_set_specflag4(*args): - """op_t_set_specflag4(self, value)""" + """ + op_t_set_specflag4(self, value) + """ return _idaapi.op_t_set_specflag4(*args) # # ----------------------------------------------------------------------- class op_t(py_clinked_object_t): - """Class representing operands""" + """ + Class representing operands + """ def __init__(self, lnk = None): py_clinked_object_t.__init__(self, lnk) @@ -43710,19 +49881,27 @@ class op_t(py_clinked_object_t): return _idaapi.op_t_destroy(lnk) def assign(self, other): - """Copies the contents of 'other' to 'self'""" + """ + Copies the contents of 'other' to 'self' + """ return _idaapi.op_t_assign(self, other) def __eq__(self, other): - """Checks if two register operands are equal by checking the register number and its dtype""" + """ + Checks if two register operands are equal by checking the register number and its dtype + """ return (self.reg == other.reg) and (self.dtyp == other.dtyp) def is_reg(self, r): - """Checks if the register operand is the given processor register""" + """ + Checks if the register operand is the given processor register + """ return self.type == o_reg and self.reg == r def has_reg(self, r): - """Checks if the operand accesses the given processor register""" + """ + Checks if the operand accesses the given processor register + """ return self.reg == r.reg # @@ -43803,7 +49982,9 @@ class op_t(py_clinked_object_t): # ----------------------------------------------------------------------- class insn_t(py_clinked_object_t): - """Class representing instructions""" + """ + Class representing instructions + """ def __init__(self, lnk = None): py_clinked_object_t.__init__(self, lnk) @@ -43821,7 +50002,9 @@ class insn_t(py_clinked_object_t): self.Op6 = self.Operands[5] def assign(self, other): - """Copies the contents of 'other' to 'self'""" + """ + Copies the contents of 'other' to 'self' + """ return _idaapi.insn_t_assign(self, other) # @@ -44064,12 +50247,16 @@ PR_DEFSEG64 = 0x10000000 # segments are 64-bit by default # Misc constants # UA_MAXOP = 6 -"""The maximum number of operands in the insn_t structure""" +""" +The maximum number of operands in the insn_t structure +""" # Create 'cmd' into the global scope cmd = insn_t(_idaapi.py_get_global_cmd_link()) -"""cmd is a global variable of type insn_t. It is contains information about the last decoded instruction. -This variable is also filled by processor modules when they decode instructions.""" +""" +cmd is a global variable of type insn_t. It is contains information about the last decoded instruction. +This variable is also filled by processor modules when they decode instructions. +""" # ---------------------------------------------------------------------- # instruc_t related constants @@ -44100,22 +50287,22 @@ CF_HLL = 0x10000 # Instruction may be present in a high level language functio # # op_t.type -# Description Data field -o_void = 0 # No Operand ---------- -o_reg = 1 # General Register (al,ax,es,ds...) reg -o_mem = 2 # Direct Memory Reference (DATA) addr -o_phrase = 3 # Memory Ref [Base Reg + Index Reg] phrase -o_displ = 4 # Memory Reg [Base Reg + Index Reg + Displacement] phrase+addr -o_imm = 5 # Immediate Value value -o_far = 6 # Immediate Far Address (CODE) addr -o_near = 7 # Immediate Near Address (CODE) addr -o_idpspec0 = 8 # Processor specific type -o_idpspec1 = 9 # Processor specific type -o_idpspec2 = 10 # Processor specific type -o_idpspec3 = 11 # Processor specific type -o_idpspec4 = 12 # Processor specific type -o_idpspec5 = 13 # Processor specific type - # There can be more processor specific types +# Description Data field +o_void = 0 # No Operand ---------- +o_reg = 1 # General Register (al,ax,es,ds...) reg +o_mem = 2 # Direct Memory Reference (DATA) addr +o_phrase = 3 # Memory Ref [Base Reg + Index Reg] phrase +o_displ = 4 # Memory Reg [Base Reg + Index Reg + Displacement] phrase+addr +o_imm = 5 # Immediate Value value +o_far = 6 # Immediate Far Address (CODE) addr +o_near = 7 # Immediate Near Address (CODE) addr +o_idpspec0 = 8 # IDP specific type +o_idpspec1 = 9 # IDP specific type +o_idpspec2 = 10 # IDP specific type +o_idpspec3 = 11 # IDP specific type +o_idpspec4 = 12 # IDP specific type +o_idpspec5 = 13 # IDP specific type +o_last = 14 # first unused type # # op_t.dtyp @@ -44171,7 +50358,9 @@ IDPOPT_BADVALUE = 3 # illegal value (bad range, for example) # ---------------------------------------------------------------------- class processor_t(pyidc_opaque_object_t): - """Base class for all processor module scripts""" + """ + Base class for all processor module scripts + """ def __init__(self): # Take a reference to 'cmd' self.cmd = cmd @@ -44182,14 +50371,18 @@ class processor_t(pyidc_opaque_object_t): short processor names similar to the one in ph.psnames. This method can be overridden to return to the kernel a different IDP description. """ - return '\x01'.join(map(lambda t: '\x01'.join(t), zip(self.plnames, self.psnames))) + return self.plnames[0] + ':' + ':'.join(self.psnames) def get_uFlag(self): - """Use this utility function to retrieve the 'uFlag' global variable""" + """ + Use this utility function to retrieve the 'uFlag' global variable + """ return _idaapi.cvar.uFlag def get_auxpref(self): - """This function returns cmd.auxpref value""" + """ + This function returns cmd.auxpref value + """ return self.cmd.auxpref @@ -44237,26 +50430,38 @@ XREF_MASK = _idaapi.XREF_MASK XREF_PASTEND = _idaapi.XREF_PASTEND def xrefchar(*args): - """xrefchar(xrtype) -> char""" + """ + xrefchar(xrtype) -> char + """ return _idaapi.xrefchar(*args) def add_cref(*args): - """add_cref(frm, to, type) -> bool""" + """ + add_cref(frm, to, type) -> bool + """ return _idaapi.add_cref(*args) def del_cref(*args): - """del_cref(frm, to, expand) -> int""" + """ + del_cref(frm, to, expand) -> int + """ return _idaapi.del_cref(*args) def add_dref(*args): - """add_dref(frm, to, type) -> bool""" + """ + add_dref(frm, to, type) -> bool + """ return _idaapi.add_dref(*args) def del_dref(*args): - """del_dref(frm, to)""" + """ + del_dref(frm, to) + """ return _idaapi.del_dref(*args) class xrefblk_t(object): - """Proxy of C++ xrefblk_t class""" + """ + Proxy of C++ xrefblk_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr frm = _swig_property(_idaapi.xrefblk_t_frm_get, _idaapi.xrefblk_t_frm_set) @@ -44265,11 +50470,15 @@ class xrefblk_t(object): type = _swig_property(_idaapi.xrefblk_t_type_get, _idaapi.xrefblk_t_type_set) user = _swig_property(_idaapi.xrefblk_t_user_get, _idaapi.xrefblk_t_user_set) def first_from(self, *args): - """first_from(self, _from, flags) -> bool""" + """ + first_from(self, _from, flags) -> bool + """ return _idaapi.xrefblk_t_first_from(self, *args) def first_to(self, *args): - """first_to(self, _to, flags) -> bool""" + """ + first_to(self, _to, flags) -> bool + """ return _idaapi.xrefblk_t_first_to(self, *args) def next_from(self, *args): @@ -44286,8 +50495,10 @@ class xrefblk_t(object): """ return _idaapi.xrefblk_t_next_to(self, *args) - def __init__(self, *args): - """__init__(self) -> xrefblk_t""" + def __init__(self, *args): + """ + __init__(self) -> xrefblk_t + """ this = _idaapi.new_xrefblk_t(*args) try: self.this.append(this) except: self.this = this @@ -44301,111 +50512,165 @@ XREF_DATA = _idaapi.XREF_DATA def get_first_dref_from(*args): - """get_first_dref_from(frm) -> ea_t""" + """ + get_first_dref_from(frm) -> ea_t + """ return _idaapi.get_first_dref_from(*args) def get_next_dref_from(*args): - """get_next_dref_from(frm, current) -> ea_t""" + """ + get_next_dref_from(frm, current) -> ea_t + """ return _idaapi.get_next_dref_from(*args) def get_first_dref_to(*args): - """get_first_dref_to(to) -> ea_t""" + """ + get_first_dref_to(to) -> ea_t + """ return _idaapi.get_first_dref_to(*args) def get_next_dref_to(*args): - """get_next_dref_to(to, current) -> ea_t""" + """ + get_next_dref_to(to, current) -> ea_t + """ return _idaapi.get_next_dref_to(*args) def get_first_cref_from(*args): - """get_first_cref_from(frm) -> ea_t""" + """ + get_first_cref_from(frm) -> ea_t + """ return _idaapi.get_first_cref_from(*args) def get_next_cref_from(*args): - """get_next_cref_from(frm, current) -> ea_t""" + """ + get_next_cref_from(frm, current) -> ea_t + """ return _idaapi.get_next_cref_from(*args) def get_first_cref_to(*args): - """get_first_cref_to(to) -> ea_t""" + """ + get_first_cref_to(to) -> ea_t + """ return _idaapi.get_first_cref_to(*args) def get_next_cref_to(*args): - """get_next_cref_to(to, current) -> ea_t""" + """ + get_next_cref_to(frm, current) -> ea_t + """ return _idaapi.get_next_cref_to(*args) def get_first_fcref_from(*args): - """get_first_fcref_from(frm) -> ea_t""" + """ + get_first_fcref_from(frm) -> ea_t + """ return _idaapi.get_first_fcref_from(*args) def get_next_fcref_from(*args): - """get_next_fcref_from(frm, current) -> ea_t""" + """ + get_next_fcref_from(frm, current) -> ea_t + """ return _idaapi.get_next_fcref_from(*args) def get_first_fcref_to(*args): - """get_first_fcref_to(to) -> ea_t""" + """ + get_first_fcref_to(to) -> ea_t + """ return _idaapi.get_first_fcref_to(*args) def get_next_fcref_to(*args): - """get_next_fcref_to(to, current) -> ea_t""" + """ + get_next_fcref_to(to, current) -> ea_t + """ return _idaapi.get_next_fcref_to(*args) def has_external_refs(*args): - """has_external_refs(pfn, ea) -> bool""" + """ + has_external_refs(pfn, ea) -> bool + """ return _idaapi.has_external_refs(*args) def calc_switch_cases(*args): """ calc_switch_cases(insn_ea, py_swi) -> cases_and_targets_t calc_switch_cases(insn_ea, si, casevec, targets) -> bool + + + Get information about a switch's cases. + + The returned information can be used as follows: + + for idx in xrange(len(results.cases)): + cur_case = results.cases[idx] + for cidx in xrange(len(cur_case)): + print "case: %d" % cur_case[cidx] + print " goto 0x%x" % results.targets[idx] + + @param insn_ea: address of the 'indirect jump' instruction + @param si: switch information + + @return: a structure with 2 members: 'cases', and 'targets'. """ return _idaapi.calc_switch_cases(*args) def pygc_refresh(*args): - """pygc_refresh(self)""" + """ + pygc_refresh(self) + """ return _idaapi.pygc_refresh(*args) def pygc_set_node_info(*args): - """pygc_set_node_info(self, py_node_idx, py_node_info, py_flags)""" + """ + pygc_set_node_info(self, py_node_idx, py_node_info, py_flags) + """ return _idaapi.pygc_set_node_info(*args) def pygc_set_nodes_infos(*args): - """pygc_set_nodes_infos(self, values)""" + """ + pygc_set_nodes_infos(self, values) + """ return _idaapi.pygc_set_nodes_infos(*args) def pygc_get_node_info(*args): - """pygc_get_node_info(self, py_node_idx) -> PyObject *""" + """ + pygc_get_node_info(self, py_node_idx) -> PyObject * + """ return _idaapi.pygc_get_node_info(*args) def pygc_del_nodes_infos(*args): - """pygc_del_nodes_infos(self, py_nodes)""" + """ + pygc_del_nodes_infos(self, py_nodes) + """ return _idaapi.pygc_del_nodes_infos(*args) def pygc_get_current_renderer_type(*args): - """pygc_get_current_renderer_type(self) -> PyObject *""" + """ + pygc_get_current_renderer_type(self) -> PyObject * + """ return _idaapi.pygc_get_current_renderer_type(*args) def pygc_set_current_renderer_type(*args): - """pygc_set_current_renderer_type(self, py_rt)""" + """ + pygc_set_current_renderer_type(self, py_rt) + """ return _idaapi.pygc_set_current_renderer_type(*args) def pygc_create_groups(*args): - """pygc_create_groups(self, groups_infos) -> PyObject *""" + """ + pygc_create_groups(self, groups_infos) -> PyObject * + """ return _idaapi.pygc_create_groups(*args) def pygc_delete_groups(*args): - """pygc_delete_groups(self, groups, new_current) -> PyObject *""" + """ + pygc_delete_groups(self, groups, new_current) -> PyObject * + """ return _idaapi.pygc_delete_groups(*args) def pygc_set_groups_visibility(*args): - """pygc_set_groups_visibility(self, groups, expand, new_current) -> PyObject *""" + """ + pygc_set_groups_visibility(self, groups, expand, new_current) -> PyObject * + """ return _idaapi.pygc_set_groups_visibility(*args) - -def pycim_get_tform(*args): - """pycim_get_tform(self) -> TForm *""" - return _idaapi.pycim_get_tform(*args) - -def pycim_get_tcustom_control(*args): - """pycim_get_tcustom_control(self) -> TCustomControl *""" - return _idaapi.pycim_get_tcustom_control(*args) # class CustomIDAMemo(object): def Refresh(self): @@ -44511,36 +50776,19 @@ class CustomIDAMemo(object): """ return _idaapi.pygc_set_groups_visibility(self, groups, expand, new_current) - def GetTForm(self): - """ - Return the TForm hosting this view. - - @return: The TForm that hosts this view, or None. - """ - return _idaapi.pycim_get_tform(self) - - def GetTCustomControl(self): - """ - Return the TCustomControl underlying this view. - - @return: The TCustomControl underlying this view, or None. - """ - return _idaapi.pycim_get_tcustom_control(self) - - # def pyidag_bind(*args): - """pyidag_bind(self) -> bool""" + """ + pyidag_bind(self) -> bool + """ return _idaapi.pyidag_bind(*args) - -def pyidag_unbind(*args): - """pyidag_unbind(self) -> bool""" - return _idaapi.pyidag_unbind(*args) # class IDAViewWrapper(CustomIDAMemo): - """This class wraps access to native IDA views. See kernwin.hpp file""" + """ + This class wraps access to native IDA views. See kernwin.hpp file + """ def __init__(self, title): """ Constructs the IDAViewWrapper object around the view @@ -44552,10 +50800,6 @@ class IDAViewWrapper(CustomIDAMemo): def Bind(self): return _idaapi.pyidag_bind(self) - - def Unbind(self): - return _idaapi.pyidag_unbind(self) - # NIF_BG_COLOR = _idaapi.NIF_BG_COLOR @@ -44564,11 +50808,15 @@ NIF_EA = _idaapi.NIF_EA NIF_TEXT = _idaapi.NIF_TEXT NIF_ALL = _idaapi.NIF_ALL class node_info_t(object): - """Proxy of C++ node_info_t class""" + """ + Proxy of C++ node_info_t class + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr - def __init__(self, *args): - """__init__(self) -> node_info_t""" + def __init__(self, *args): + """ + __init__(self) -> node_info_t + """ this = _idaapi.new_node_info_t(*args) try: self.this.append(this) except: self.this = this @@ -44577,23 +50825,33 @@ class node_info_t(object): ea = _swig_property(_idaapi.node_info_t_ea_get, _idaapi.node_info_t_ea_set) text = _swig_property(_idaapi.node_info_t_text_get, _idaapi.node_info_t_text_set) def valid_bg_color(self, *args): - """valid_bg_color(self) -> bool""" + """ + valid_bg_color(self) -> bool + """ return _idaapi.node_info_t_valid_bg_color(self, *args) def valid_frame_color(self, *args): - """valid_frame_color(self) -> bool""" + """ + valid_frame_color(self) -> bool + """ return _idaapi.node_info_t_valid_frame_color(self, *args) def valid_ea(self, *args): - """valid_ea(self) -> bool""" + """ + valid_ea(self) -> bool + """ return _idaapi.node_info_t_valid_ea(self, *args) def valid_text(self, *args): - """valid_text(self) -> bool""" + """ + valid_text(self) -> bool + """ return _idaapi.node_info_t_valid_text(self, *args) def get_flags_for_valid(self, *args): - """get_flags_for_valid(self) -> uint32""" + """ + get_flags_for_valid(self) -> uint32 + """ return _idaapi.node_info_t_get_flags_for_valid(self, *args) __swig_destroy__ = _idaapi.delete_node_info_t @@ -44603,47 +50861,69 @@ node_info_t_swigregister(node_info_t) def get_node_info2(*args): - """get_node_info2(out, gid, node) -> bool""" + """ + get_node_info2(out, gid, node) -> bool + """ return _idaapi.get_node_info2(*args) def set_node_info2(*args): - """set_node_info2(gid, node, ni, flags)""" + """ + set_node_info2(gid, node, ni, flags) + """ return _idaapi.set_node_info2(*args) def del_node_info2(*args): - """del_node_info2(gid, node)""" + """ + del_node_info2(gid, node) + """ return _idaapi.del_node_info2(*args) def clr_node_info2(*args): - """clr_node_info2(gid, node, flags)""" + """ + clr_node_info2(gid, node, flags) + """ return _idaapi.clr_node_info2(*args) def set_node_info(*args): - """set_node_info(ea, node, pcolor, pea2, text)""" + """ + set_node_info(ea, node, pcolor, pea2, text) + """ return _idaapi.set_node_info(*args) def get_node_info(*args): - """get_node_info(ea, node, pcolor, pea) -> char *""" + """ + get_node_info(ea, node, pcolor, pea) -> char * + """ return _idaapi.get_node_info(*args) def pyg_close(*args): - """pyg_close(self)""" + """ + pyg_close(self) + """ return _idaapi.pyg_close(*args) def pyg_add_command(*args): - """pyg_add_command(self, title, hotkey) -> PyObject *""" + """ + pyg_add_command(self, title, hotkey) -> PyObject * + """ return _idaapi.pyg_add_command(*args) def pyg_select_node(*args): - """pyg_select_node(self, nid)""" + """ + pyg_select_node(self, nid) + """ return _idaapi.pyg_select_node(*args) def pyg_show(*args): - """pyg_show(self) -> bool""" + """ + pyg_show(self) -> bool + """ return _idaapi.pyg_show(*args) # class GraphViewer(CustomIDAMemo): - """This class wraps the user graphing facility provided by the graph.hpp file""" + """ + This class wraps the user graphing facility provided by the graph.hpp file + """ def __init__(self, title, close_open = False): """ Constructs the GraphView object. @@ -44658,17 +50938,23 @@ class GraphViewer(CustomIDAMemo): self._close_open = close_open def AddNode(self, obj): - """Creates a node associated with the given object and returns the node id""" + """ + Creates a node associated with the given object and returns the node id + """ id = len(self._nodes) self._nodes.append(obj) return id def AddEdge(self, src_node, dest_node): - """Creates an edge between two given node ids""" + """ + Creates an edge between two given node ids + """ self._edges.append( (src_node, dest_node) ) def Clear(self): - """Clears all the nodes and edges""" + """ + Clears all the nodes and edges + """ self._nodes = [] self._edges = [] @@ -44678,14 +50964,18 @@ class GraphViewer(CustomIDAMemo): def __getitem__(self, idx): - """Returns a reference to the object associated with this node id""" + """ + Returns a reference to the object associated with this node id + """ if idx >= len(self._nodes): raise KeyError else: return self._nodes[idx] def Count(self): - """Returns the node count""" + """ + Returns the node count + """ return len(self._nodes) def Close(self): @@ -44708,14 +50998,17 @@ class GraphViewer(CustomIDAMemo): return _idaapi.pyg_show(self) def Select(self, node_id): - """Selects a node on the graph""" + """ + Selects a node on the graph + """ _idaapi.pyg_select_node(self, node_id) def AddCommand(self, title, hotkey): """ - Deprecated: Use - - register_action() - - attach_action_to_popup() + Adds a menu command to the graph. Call this command after the graph is shown (with Show()). + Once a command is added, a command id is returned. The commands are handled inside the OnCommand() handler + + @return: 0 on failure or the command id """ return _idaapi.pyg_add_command(self, title, hotkey) @@ -44797,209 +51090,219 @@ class GraphViewer(CustomIDAMemo): # # def OnCommand(self, cmd_id): # """ -# Deprecated +# Triggered when a menu command is selected through the menu or its hotkey +# @return: None # """ -# pass +# print "command:", cmd_id # # class qfile_t(object): - """Proxy of C++ qfile_t class""" + """ + Proxy of C++ qfile_t class + + + A helper class to work with FILE related functions. + """ thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') __repr__ = _swig_repr __idc_cvt_id__ = _swig_property(_idaapi.qfile_t___idc_cvt_id___get, _idaapi.qfile_t___idc_cvt_id___set) - def __init__(self, *args): + def __init__(self, *args): """ __init__(self, rhs) -> qfile_t __init__(self, pycobject=None) -> qfile_t + + + Closes the file """ this = _idaapi.new_qfile_t(*args) try: self.this.append(this) except: self.this = this def opened(self, *args): - """opened(self) -> bool""" + """ + opened(self) -> bool + + + Checks if the file is opened or not + """ return _idaapi.qfile_t_opened(self, *args) def close(self, *args): - """close(self)""" + """ + close(self) + """ return _idaapi.qfile_t_close(self, *args) __swig_destroy__ = _idaapi.delete_qfile_t __del__ = lambda self : None; def open(self, *args): - """open(self, filename, mode) -> bool""" + """ + open(self, filename, mode) -> bool + + + Opens a file + @param filename: the file name + @param mode: The mode string, ala fopen() style + @return: Boolean + """ return _idaapi.qfile_t_open(self, *args) def from_fp(*args): - """from_fp(fp) -> qfile_t""" + """ + from_fp(fp) -> qfile_t + """ return _idaapi.qfile_t_from_fp(*args) from_fp = staticmethod(from_fp) def from_cobject(*args): - """from_cobject(pycobject) -> qfile_t""" + """ + from_cobject(pycobject) -> qfile_t + """ return _idaapi.qfile_t_from_cobject(*args) from_cobject = staticmethod(from_cobject) def tmpfile(*args): - """tmpfile() -> qfile_t""" + """ + tmpfile() -> qfile_t + + + A static method to construct an instance using a temporary file + """ return _idaapi.qfile_t_tmpfile(*args) tmpfile = staticmethod(tmpfile) def get_fp(self, *args): - """get_fp(self) -> FILE *""" + """ + get_fp(self) -> FILE * + """ return _idaapi.qfile_t_get_fp(self, *args) def seek(self, *args): - """seek(self, offset, whence=SEEK_SET) -> int""" + """ + seek(self, offset, whence=SEEK_SET) -> int + + + Set input source position + @return: the new position (not 0 as fseek!) + """ return _idaapi.qfile_t_seek(self, *args) def tell(self, *args): - """tell(self) -> int32""" + """ + tell(self) -> int32 + + + Returns the current position + """ return _idaapi.qfile_t_tell(self, *args) def readbytes(self, *args): - """readbytes(self, size, big_endian) -> PyObject *""" + """ + readbytes(self, size, big_endian) -> PyObject * + + + Similar to read() but it respect the endianness + """ return _idaapi.qfile_t_readbytes(self, *args) def read(self, *args): - """read(self, size) -> PyObject *""" + """ + read(self, size) -> PyObject * + + + Reads from the file. Returns the buffer or None + """ return _idaapi.qfile_t_read(self, *args) def gets(self, *args): - """gets(self, size) -> PyObject *""" + """ + gets(self, size) -> PyObject * + + + Reads a line from the input file. Returns the read line or None + """ return _idaapi.qfile_t_gets(self, *args) def writebytes(self, *args): - """writebytes(self, py_buf, big_endian) -> int""" + """ + writebytes(self, py_buf, big_endian) -> int + + + Similar to write() but it respect the endianness + """ return _idaapi.qfile_t_writebytes(self, *args) def write(self, *args): - """write(self, py_buf) -> int""" + """ + write(self, py_buf) -> int + + + Writes to the file. Returns 0 or the number of bytes written + """ return _idaapi.qfile_t_write(self, *args) def puts(self, *args): - """puts(self, str) -> int""" + """ + puts(self, str) -> int + """ return _idaapi.qfile_t_puts(self, *args) def size(self, *args): - """size(self) -> int32""" + """ + size(self) -> int32 + """ return _idaapi.qfile_t_size(self, *args) def flush(self, *args): - """flush(self) -> int""" + """ + flush(self) -> int + + + Reads a single character from the file. Returns None if EOF or the read character + """ return _idaapi.qfile_t_flush(self, *args) def filename(self, *args): - """filename(self) -> PyObject *""" + """ + filename(self) -> PyObject * + """ return _idaapi.qfile_t_filename(self, *args) def get_char(self, *args): - """get_char(self) -> PyObject *""" + """ + get_char(self) -> PyObject * + """ return _idaapi.qfile_t_get_char(self, *args) def put_char(self, *args): - """put_char(self, chr) -> int""" + """ + put_char(self, chr) -> int + + + Writes a single character to the file + """ return _idaapi.qfile_t_put_char(self, *args) qfile_t_swigregister = _idaapi.qfile_t_swigregister qfile_t_swigregister(qfile_t) def qfile_t_from_fp(*args): - """qfile_t_from_fp(fp) -> qfile_t""" + """ + qfile_t_from_fp(fp) -> qfile_t + """ return _idaapi.qfile_t_from_fp(*args) def qfile_t_from_cobject(*args): - """qfile_t_from_cobject(pycobject) -> qfile_t""" + """ + qfile_t_from_cobject(pycobject) -> qfile_t + """ return _idaapi.qfile_t_from_cobject(*args) def qfile_t_tmpfile(*args): - """qfile_t_tmpfile() -> qfile_t""" + """ + qfile_t_tmpfile() -> qfile_t + """ return _idaapi.qfile_t_tmpfile(*args) -def reg_read_string(*args): - """reg_read_string(name, subkey=None, _def=None) -> PyObject *""" - return _idaapi.reg_read_string(*args) - -def reg_data_type(*args): - """reg_data_type(name, subkey=None) -> regval_type_t""" - return _idaapi.reg_data_type(*args) - -def reg_read_binary(*args): - """reg_read_binary(name, subkey=None) -> PyObject *""" - return _idaapi.reg_read_binary(*args) - -def reg_write_binary(*args): - """reg_write_binary(name, py_bytes, subkey=None)""" - return _idaapi.reg_write_binary(*args) - -def reg_subkey_subkeys(*args): - """reg_subkey_subkeys(name) -> PyObject *""" - return _idaapi.reg_subkey_subkeys(*args) - -def reg_subkey_values(*args): - """reg_subkey_values(name) -> PyObject *""" - return _idaapi.reg_subkey_values(*args) -ROOT_KEY_NAME = _idaapi.ROOT_KEY_NAME -reg_unknown = _idaapi.reg_unknown -reg_sz = _idaapi.reg_sz -reg_binary = _idaapi.reg_binary -reg_dword = _idaapi.reg_dword - -def reg_delete_subkey(*args): - """reg_delete_subkey(name) -> bool""" - return _idaapi.reg_delete_subkey(*args) - -def reg_delete(*args): - """reg_delete(name, subkey=None) -> bool""" - return _idaapi.reg_delete(*args) - -def reg_subkey_exists(*args): - """reg_subkey_exists(name) -> bool""" - return _idaapi.reg_subkey_exists(*args) - -def reg_exists(*args): - """reg_exists(name, subkey=None) -> bool""" - return _idaapi.reg_exists(*args) - -def reg_read_strlist(*args): - """reg_read_strlist(subkey, list)""" - return _idaapi.reg_read_strlist(*args) - -def reg_update_strlist(*args): - """reg_update_strlist(subkey, add, maxrecs, rem=None, ignorecase=False)""" - return _idaapi.reg_update_strlist(*args) - -def reg_write_string(*args): - """reg_write_string(name, utf8, subkey=None)""" - return _idaapi.reg_write_string(*args) - -def reg_read_int(*args): - """reg_read_int(name, defval, subkey=None) -> int""" - return _idaapi.reg_read_int(*args) - -def reg_write_int(*args): - """reg_write_int(name, value, subkey=None)""" - return _idaapi.reg_write_int(*args) - -def reg_read_bool(*args): - """reg_read_bool(name, defval, subkey=None) -> bool""" - return _idaapi.reg_read_bool(*args) - -def reg_write_bool(*args): - """reg_write_bool(name, value, subkey=None)""" - return _idaapi.reg_write_bool(*args) - -def reg_update_filestrlist(*args): - """reg_update_filestrlist(subkey, add, maxrecs, rem=None)""" - return _idaapi.reg_update_filestrlist(*args) - -def reg_load(*args): - """reg_load()""" - return _idaapi.reg_load(*args) - -def reg_flush(*args): - """reg_flush()""" - return _idaapi.reg_flush(*args) - diff --git a/Genius3/python/idaapi.pyc b/Genius3/python/idaapi.pyc index b611424..b9bbedb 100644 Binary files a/Genius3/python/idaapi.pyc and b/Genius3/python/idaapi.pyc differ diff --git a/Genius3/python/idautils.py b/Genius3/python/idautils.py index 65baa5f..9599a8b 100644 --- a/Genius3/python/idautils.py +++ b/Genius3/python/idautils.py @@ -374,8 +374,8 @@ def DecodePreviousInstruction(ea): @param ea: address to decode @return: None or a new insn_t instance """ - prev_addr = idaapi.decode_prev_insn(ea) - if prev_addr == idaapi.BADADDR: + inslen = idaapi.decode_prev_insn(ea) + if inslen == 0: return None return idaapi.cmd.copy() @@ -462,8 +462,7 @@ def GetInputFileMD5(): class Strings(object): """ - Allows iterating over the string list. The set of strings will not be modified. - , unless asked explicitly at setup()-time.. + Returns the string list. Example: s = Strings() @@ -484,34 +483,8 @@ class Strings(object): self.length = si.length """string length""" - def is_1_byte_encoding(self): - return not self.is_2_bytes_encoding() and not self.is_4_bytes_encoding() - - def is_2_bytes_encoding(self): - return (self.type & 7) in [idaapi.ASCSTR_UTF16, idaapi.ASCSTR_ULEN2, idaapi.ASCSTR_ULEN4] - - def is_4_bytes_encoding(self): - return (self.type & 7) == idaapi.ASCSTR_UTF32 - - def _toseq(self, as_unicode): - if self.is_2_bytes_encoding(): - conv = idaapi.ACFOPT_UTF16 - pyenc = "utf-16" - elif self.is_4_bytes_encoding(): - conv = idaapi.ACFOPT_UTF8 - pyenc = "utf-8" - else: - conv = idaapi.ACFOPT_ASCII - pyenc = 'ascii' - strbytes = idaapi.get_ascii_contents2(self.ea, self.length, self.type, conv) - return unicode(strbytes, pyenc, 'replace') if as_unicode else strbytes - def __str__(self): - return self._toseq(False) - - def __unicode__(self): - return self._toseq(True) - + return idc.GetString(self.ea, self.length, self.type) STR_C = 0x0001 """C-style ASCII string""" @@ -532,7 +505,8 @@ class Strings(object): """Clears the strings list cache""" self.refresh(0, 0) # when ea1=ea2 the kernel will clear the cache - def __init__(self, default_setup = False): + + def __init__(self, default_setup = True): """ Initializes the Strings enumeration helper class @@ -541,11 +515,10 @@ class Strings(object): self.size = 0 if default_setup: self.setup() - else: - self.refresh() self._si = idaapi.string_info_t() + def refresh(self, ea1=None, ea2=None): """Refreshes the strings list""" if ea1 is None: diff --git a/Genius3/python/idautils.pyc b/Genius3/python/idautils.pyc index 500eb47..b50942a 100644 Binary files a/Genius3/python/idautils.pyc and b/Genius3/python/idautils.pyc differ diff --git a/Genius3/python/idc.py b/Genius3/python/idc.py index b34277c..4fc2345 100644 --- a/Genius3/python/idc.py +++ b/Genius3/python/idc.py @@ -1450,11 +1450,7 @@ def PatchByte(ea, value): @param ea: linear address @param value: new value of the byte - @return: 1 if the database has been modified, - 0 if either the debugger is running and the process' memory - has value 'value' at address 'ea', - or the debugger is not running, and the IDB - has value 'value' at address 'ea already. + @return: 1 if successful, 0 if not """ return idaapi.patch_byte(ea, value) @@ -1466,11 +1462,7 @@ def PatchWord(ea, value): @param ea: linear address @param value: new value of the word - @return: 1 if the database has been modified, - 0 if either the debugger is running and the process' memory - has value 'value' at address 'ea', - or the debugger is not running, and the IDB - has value 'value' at address 'ea already. + @return: 1 if successful, 0 if not """ return idaapi.patch_word(ea, value) @@ -1482,31 +1474,11 @@ def PatchDword(ea, value): @param ea: linear address @param value: new value of the double word - @return: 1 if the database has been modified, - 0 if either the debugger is running and the process' memory - has value 'value' at address 'ea', - or the debugger is not running, and the IDB - has value 'value' at address 'ea already. + @return: 1 if successful, 0 if not """ return idaapi.patch_long(ea, value) -def PatchQword(ea, value): - """ - Change value of a quad word - - @param ea: linear address - @param value: new value of the quad word - - @return: 1 if the database has been modified, - 0 if either the debugger is running and the process' memory - has value 'value' at address 'ea', - or the debugger is not running, and the IDB - has value 'value' at address 'ea already. - """ - return idaapi.patch_qword(ea, value) - - def SetFlags(ea, flags): """ Set new value of flags @@ -1908,7 +1880,7 @@ def GetFloat(ea): Get value of a floating point number (4 bytes) This function assumes number stored using IEEE format and in the same endianness as integers. - + @param ea: linear address @return: float @@ -2281,7 +2253,7 @@ def GetOpnd(ea, n): @return: the current text representation of operand or "" """ - + if not isCode(idaapi.get_flags_novalue(ea)): return "" @@ -2308,21 +2280,21 @@ def GetOpType(ea, n): return -1 if inslen == 0 else idaapi.cmd.Operands[n].type -o_void = idaapi.o_void # No Operand ---------- -o_reg = idaapi.o_reg # General Register (al,ax,es,ds...) reg -o_mem = idaapi.o_mem # Direct Memory Reference (DATA) addr -o_phrase = idaapi.o_phrase # Memory Ref [Base Reg + Index Reg] phrase -o_displ = idaapi.o_displ # Memory Reg [Base Reg + Index Reg + Displacement] phrase+addr -o_imm = idaapi.o_imm # Immediate Value value -o_far = idaapi.o_far # Immediate Far Address (CODE) addr -o_near = idaapi.o_near # Immediate Near Address (CODE) addr -o_idpspec0 = idaapi.o_idpspec0 # Processor specific type -o_idpspec1 = idaapi.o_idpspec1 # Processor specific type -o_idpspec2 = idaapi.o_idpspec2 # Processor specific type -o_idpspec3 = idaapi.o_idpspec3 # Processor specific type -o_idpspec4 = idaapi.o_idpspec4 # Processor specific type -o_idpspec5 = idaapi.o_idpspec5 # Processor specific type - # There can be more processor specific types +o_void = idaapi.o_void # No Operand ---------- +o_reg = idaapi.o_reg # General Register (al,ax,es,ds...) reg +o_mem = idaapi.o_mem # Direct Memory Reference (DATA) addr +o_phrase = idaapi.o_phrase # Memory Ref [Base Reg + Index Reg] phrase +o_displ = idaapi.o_displ # Memory Reg [Base Reg + Index Reg + Displacement] phrase+addr +o_imm = idaapi.o_imm # Immediate Value value +o_far = idaapi.o_far # Immediate Far Address (CODE) addr +o_near = idaapi.o_near # Immediate Near Address (CODE) addr +o_idpspec0 = idaapi.o_idpspec0 # IDP specific type +o_idpspec1 = idaapi.o_idpspec1 # IDP specific type +o_idpspec2 = idaapi.o_idpspec2 # IDP specific type +o_idpspec3 = idaapi.o_idpspec3 # IDP specific type +o_idpspec4 = idaapi.o_idpspec4 # IDP specific type +o_idpspec5 = idaapi.o_idpspec5 # IDP specific type +o_last = idaapi.o_last # first unused type # x86 o_trreg = idaapi.o_idpspec0 # trace register @@ -2336,7 +2308,7 @@ o_xmmreg = idaapi.o_idpspec5 # xmm register o_reglist = idaapi.o_idpspec1 # Register list (for LDM/STM) o_creglist = idaapi.o_idpspec2 # Coprocessor register list (for CDP) o_creg = idaapi.o_idpspec3 # Coprocessor register (for LDC/STC) -o_fpreg_arm = idaapi.o_idpspec4 # Floating point register +o_fpreg = idaapi.o_idpspec4 # Floating point register o_fpreglist = idaapi.o_idpspec5 # Floating point register list o_text = (idaapi.o_idpspec5+1) # Arbitrary text stored in the operand @@ -3144,20 +3116,6 @@ def Message(msg): idaapi.msg(msg) -def UMessage(msg): - """ - Display an UTF-8 string in the message window - - The result of the stringification of the arguments - will be treated as an UTF-8 string. - - @param msg: message to print (formatting is done in Python) - - This function can be used to debug IDC scripts - """ - idaapi.umsg(msg) - - def Warning(msg): """ Display a message in a message box @@ -3632,7 +3590,7 @@ def GetSegmentAttr(segea, attr): seg = idaapi.getseg(segea) assert seg, "could not find segment at 0x%x" % segea if attr in [ SEGATTR_ES, SEGATTR_CS, SEGATTR_SS, SEGATTR_DS, SEGATTR_FS, SEGATTR_GS ]: - return idaapi.get_defsr(seg, _SEGATTRMAP[attr][1]) + return idaapi.get_defsr(seg, _SEGATTRMAP[attr]) else: return _IDC_GetAttr(seg, _SEGATTRMAP, attr) @@ -3651,7 +3609,7 @@ def SetSegmentAttr(segea, attr, value): seg = idaapi.getseg(segea) assert seg, "could not find segment at 0x%x" % segea if attr in [ SEGATTR_ES, SEGATTR_CS, SEGATTR_SS, SEGATTR_DS, SEGATTR_FS, SEGATTR_GS ]: - idaapi.set_defsr(seg, _SEGATTRMAP[attr][1], value) + idaapi.set_defsr(seg, _SEGATTRMAP[attr], value) else: _IDC_SetAttr(seg, _SEGATTRMAP, attr, value) return seg.update() @@ -3995,11 +3953,7 @@ def SaveFile(filepath, pos, ea, size): @return: 0 - error, 1 - ok """ - if ( os.path.isfile(filepath) ): - of = idaapi.fopenM(filepath) - else: - of = idaapi.fopenWB(filepath) - + of = idaapi.fopenM(filepath) if of: retval = idaapi.base2file(of, pos, ea, ea+size) @@ -5588,23 +5542,6 @@ def SetMemberComment(sid, member_offset, comment, repeatable): return idaapi.set_member_cmt(m, comment, repeatable) -def ExpandStruc(sid, offset, delta, recalc): - """ - Expand or shrink a structure type - @param id: structure type ID - @param offset: offset in the structure - @param delta: how many bytes to add or remove - @param recalc: recalculate the locations where the structure - type is used - @return: != 0 - ok - """ - s = idaapi.get_struc(sid) - if not s: - return 0 - - return idaapi.expand_struc(s, offset, delta, recalc) - - def GetFchunkAttr(ea, attr): """ Get a function chunk attribute @@ -6980,16 +6917,16 @@ def ApplyType(ea, py_type, flags = TINFO_DEFINITE): @return: Boolean """ - if py_type is None: - py_type = "" - if isinstance(py_type, basestring) and len(py_type) == 0: - pt = ("", "") - else: + if py_type != None: if len(py_type) == 3: pt = py_type[1:] # skip name component else: pt = py_type - return idaapi.apply_type(idaapi.cvar.idati, pt[0], pt[1], ea, flags) + return idaapi.apply_type(idaapi.cvar.idati, pt[0], pt[1], ea, flags) + if idaapi.has_ti(ea): + idaapi.del_tinfo(ea) + return True + return False def SetType(ea, newtype): """ @@ -7004,7 +6941,7 @@ def SetType(ea, newtype): @return: 1-ok, 0-failed. """ if newtype is not '': - pt = ParseType(newtype, 1) # silent + pt = ParseType(newtype, 0) if pt is None: # parsing failed return None diff --git a/Genius3/python/idc.pyc b/Genius3/python/idc.pyc index 3f122e9..d1d14db 100644 Binary files a/Genius3/python/idc.pyc and b/Genius3/python/idc.pyc differ diff --git a/Genius3/python/init.py b/Genius3/python/init.py index 06b74b4..9d56940 100644 --- a/Genius3/python/init.py +++ b/Genius3/python/init.py @@ -28,8 +28,9 @@ class IDAPythonStdOut: Dummy file-like class that receives stout and stderr """ def write(self, text): - # NB: in case 'text' is Unicode, msg() will decode it - # and call umsg() to print it + # Swap out the unprintable characters + text = text.decode('ascii', 'replace').encode('ascii', 'replace') + # Print to IDA message window _idaapi.msg(text) def flush(self): diff --git a/Genius3/raw-feature-extractor/cfg_constructor.py b/Genius3/raw-feature-extractor/cfg_constructor.py index 268a3f4..72c0437 100644 --- a/Genius3/raw-feature-extractor/cfg_constructor.py +++ b/Genius3/raw-feature-extractor/cfg_constructor.py @@ -1,9 +1,3 @@ -import copy -import networkx as nx -from idautils import * -from idaapi import * -from idc import * - import copy import networkx as nx from idautils import * @@ -99,11 +93,11 @@ def filtering(cfg): bb_start = bb[0] bb_end = bb[1] re = remove(bb_start, bb_end) - print bb_id, re, bb_start, bb_end + print(bb_id, re, bb_start, bb_end) if re: - print re, bb_id + print(re, bb_id) rm_sets.append(bb_id) - print rm_sets + print(rm_sets) for bb_id in rm_sets: cfg.remove_node(bb_id) @@ -160,16 +154,16 @@ def attributingRe(cfg, externs_eas, ea_externs): def attributing(cfg): ga = graph_analysis() ga.gwithoffspring(cfg) - print "finishing offspring" + print("finishing offspring") for node in cfg: stmt_num = getStmtNum(node) binary_value = getBinaryValue(node) cfg.node[node]['stmt_num'] = stmt_num cfg.node[node]['binary_value'] = binary_value ga.domChecking(cfg) - print "finishing domChecking" + print("finishing domChecking") ga.loopChecking(cfg) - print "finishing loopChecking" + print("finishing loopChecking") def getStmtNum(node): @@ -190,17 +184,17 @@ def getBinaryValue(node): for x in xrange((inst_addr - start)-1): addr = start + x y = GetOriginalByte(addr) - print value, addr, y + print(value, addr, y) value = value | y value = value << 8 - print value + print(value) addr = inst_addr - 1 y = GetOriginalByte(addr) - print value, addr, y + print(value, addr, y) value = value | y - print node - print bin(value) + print(node) + print(bin(value)) return value diff --git a/Genius3/raw-feature-extractor/cfg_constructor.pyc b/Genius3/raw-feature-extractor/cfg_constructor.pyc index a0b7c8f..04d1a23 100644 Binary files a/Genius3/raw-feature-extractor/cfg_constructor.pyc and b/Genius3/raw-feature-extractor/cfg_constructor.pyc differ diff --git a/Genius3/raw-feature-extractor/convert_pkl_to_json.py b/Genius3/raw-feature-extractor/convert_pkl_to_json.py new file mode 100644 index 0000000..7eeceb4 --- /dev/null +++ b/Genius3/raw-feature-extractor/convert_pkl_to_json.py @@ -0,0 +1,60 @@ +# coding=utf-8 +import pickle as pk +import re +import json +import os + + +def convert(): + # for workflow in range(0, 20): + workflow = 0 + cfg_dir = "D:\\hkn\\infected\\datasets\\virusshare_infected{}_cfg".format(workflow) + output_dir = "D:\\hkn\\infected\\datasets\\virusshare_infected{}_json".format(workflow) + dot_path = "D:\\hkn\\infected\\datasets\\virusshare_infected{}_dot".format(workflow) + + for cfg in os.listdir(cfg_dir): + name = cfg[:-4] # 纯文件名，不带后缀 + cfg_file = open(os.path.join(cfg_dir, name + '.ida'), 'r') + data = pk.load(cfg_file) + cfg_file.close() + + # 打开dot文件获取fcg + raw_function_edges = [] + with open(os.path.join(dot_path, name + '.dot'), 'r') as dot: + for line in dot: + if '->' in line: + raw_function_edges.append(re.findall(r'\b\d+\b', line)) + + # 为当前pe文件创建json对象 + json_obj = { + 'hash': data.binary_name[11:], + 'function_number': data.raw_graph_list.__len__(), + 'function_edges': [[d[0] for d in raw_function_edges], [d[1] for d in raw_function_edges]], + 'acfg_list': [], + 'function_names': [] + } + # 读取pkl文件，一个acfg由一个函数分解而来 + for acfg in data.raw_graph_list: + # 这里2是因为Genius框架提取特征时将后代数量放在2 + offspring = [d.get('v')[2] for d in acfg.g.node.values()] + # 将后代数量的特征放入bb_features中 + for i, f in enumerate(acfg.bb_features): + f.append(offspring[i]) + + acfg_item = { + 'block_number': acfg.g.__len__(), + 'block_edges': [[d[0] for d in acfg.g.edges], [d[1] for d in acfg.g.edges]], + 'block_features': acfg.bb_features + } + + json_obj['acfg_list'].append(acfg_item) + json_obj['function_names'].append(acfg.funcname) + + # 将结果写入json本地文件 + result = json.dumps(json_obj) + with open(os.path.join(output_dir, name + '.jsonl'), 'w') as out: + out.write(result) + + +if __name__ == '__main__': + convert() diff --git a/Genius3/raw-feature-extractor/discovRe.py b/Genius3/raw-feature-extractor/discovRe.py index 6201b8a..451999e 100644 --- a/Genius3/raw-feature-extractor/discovRe.py +++ b/Genius3/raw-feature-extractor/discovRe.py @@ -1,3 +1,4 @@ +# coding=utf-8 # # Reference Lister # @@ -6,130 +7,164 @@ # Implemented with the idautils module # import networkx as nx -import cPickle as pickle import pdb from graph_analysis_ida import * from graph_property import * -#import wingdbstub -#wingdbstub.Ensure() + + +# import wingdbstub +# wingdbstub.Ensure() def get_funcs(ea): - funcs = {} - # Get current ea - # Loop from start to end in the current segment - for funcea in Functions(SegStart(ea)): - funcname = GetFunctionName(funcea) - func = get_func(funcea) - blocks = FlowChart(func) - funcs[funcname] = [] - for bl in blocks: - start = bl.startEA - end = bl.endEA - funcs[funcname].append((start, end)) - return funcs - -def get_funcs_for_discoverRe(ea): - features = {} + funcs = {} + # Get current ea + # Loop from start to end in the current segment for funcea in Functions(SegStart(ea)): funcname = GetFunctionName(funcea) - print funcname func = get_func(funcea) - feature = get_discoverRe_feature(func) - features[funcname] = feature - return features + blocks = FlowChart(func) + funcs[funcname] = [] + for bl in blocks: + start = bl.startEA + end = bl.endEA + funcs[funcname].append((start, end)) + return funcs + + +# 似乎是没用的函数 +# def get_funcs_for_discoverRe(ea): +# features = {} +# for funcea in Functions(SegStart(ea)): +# funcname = GetFunctionName(funcea) +# print(funcname) +# func = get_func(funcea) +# feature = get_discoverRe_feature(func) +# features[funcname] = feature +# return features + + +# 获取所有bb的11维属性特征 +# 调用/传输/算术/逻辑/比较/移动/终止/数据声明/总指令数/字符串或整数常量/后代的数量 +def get_bb_features(func): + bb_features = [] + blocks = [(v.startEA, v.endEA) for v in FlowChart(func)] + for bl in blocks: + calls = calCalls(bl) + transferIns = calTransferIns(bl) + mathematicsIns = calArithmeticIns(bl) + logicIns = calLogicInstructions(bl) + cmpIns = calIns(bl, {'cmp': 1, 'cmps': 1, 'cmpsb': 1, 'cmppd': 1, 'cmpps': 1, 'fcom': 1, 'fcomp': 1, 'fcompp': 1, 'ficom': 1, 'ficomp': 1, 'ptest': 1, 'test': 1}) + movIns = calIns(bl, {'mov': 1, 'movb': 1, 'movw': 1, 'movl': 1, 'movq': 1, 'movabsq': 1, 'push': 1, 'pop': 1, 'lea': 1}) + interruptIns = calIns(bl, {'int1': 1, 'int3': 1, 'into': 1, 'iret': 1, 'iretd': 1, 'iretq': 1}) + declareIns = calIns(bl, {'dw': 1, 'dd': 1, 'db': 1}) + totalIns = calInsts(bl) + consts = getBBconsts(bl) + stringOrIntConsts = len(consts[0]) + len(consts[1]) + bb_features.append([calls, transferIns, mathematicsIns, logicIns, cmpIns, movIns, + interruptIns, declareIns, totalIns, stringOrIntConsts]) + return bb_features + def get_discoverRe_feature(func, icfg): start = func.startEA end = func.endEA features = [] FunctionCalls = getFuncCalls(func) - #1 + # 1 features.append(FunctionCalls) LogicInstr = getLogicInsts(func) - #2 + # 2 features.append(LogicInstr) Transfer = getTransferInsts(func) - #3 + # 3 features.append(Transfer) Locals = getLocalVariables(func) - #4 + # 4 features.append(Locals) BB = getBasicBlocks(func) - #5 + # 5 features.append(BB) Edges = len(icfg.edges()) - #6 + # 6 features.append(Edges) Incoming = getIncommingCalls(func) - #7 + # 7 features.append(Incoming) - #8 + # 8 Instrs = getIntrs(func) features.append(Instrs) between = retrieveGP(icfg) - #9 + # 9 features.append(between) strings, consts = getfunc_consts(func) + # 10 features.append(strings) + # 11 features.append(consts) return features + def get_func_names(ea): funcs = {} for funcea in Functions(SegStart(ea)): - funcname = GetFunctionName(funcea) - funcs[funcname] = funcea + funcname = GetFunctionName(funcea) + funcs[funcname] = funcea return funcs + def get_func_bases(ea): - funcs = {} - for funcea in Functions(SegStart(ea)): - funcname = GetFunctionName(funcea) - funcs[funcea] = funcname - return funcs + funcs = {} + for funcea in Functions(SegStart(ea)): + funcname = GetFunctionName(funcea) + funcs[funcea] = funcname + return funcs + def get_func_range(ea): - funcs = {} - for funcea in Functions(SegStart(ea)): - funcname = GetFunctionName(funcea) - func = get_func(funcea) - funcs[funcname] = (func.startEA, func.endEA) - return funcs + funcs = {} + for funcea in Functions(SegStart(ea)): + funcname = GetFunctionName(funcea) + func = get_func(funcea) + funcs[funcname] = (func.startEA, func.endEA) + return funcs + def get_func_sequences(ea): - funcs_bodylist = {} - funcs = get_funcs(ea) - for funcname in funcs: - if funcname not in funcs_bodylist: - funcs_bodylist[funcname] = [] - for start, end in funcs[funcname]: - inst_addr = start - while inst_addr <= end: - opcode = GetMnem(inst_addr) - funcs_bodylist[funcname].append(opcode) - inst_addr = NextHead(inst_addr) - return funcs_bodylist + funcs_bodylist = {} + funcs = get_funcs(ea) + for funcname in funcs: + if funcname not in funcs_bodylist: + funcs_bodylist[funcname] = [] + for start, end in funcs[funcname]: + inst_addr = start + while inst_addr <= end: + opcode = GetMnem(inst_addr) + funcs_bodylist[funcname].append(opcode) + inst_addr = NextHead(inst_addr) + return funcs_bodylist + def get_func_cfgs(ea): func_cfglist = {} i = 0 start, end = get_section('LOAD') - #print start, end + # print start, end for funcea in Functions(SegStart(ea)): if start <= funcea <= end: funcname = GetFunctionName(funcea) func = get_func(funcea) - print i + print(i) i += 1 try: icfg = cfg.cfg_construct(func) func_cfglist[funcname] = icfg except: pass - + return func_cfglist + def get_section(t): base = SegByName(t) start = SegByBase(base) @@ -144,7 +179,7 @@ def get_func_cfg_sequences(func_cfglist): cfg = func_cfglist[funcname][0] for start, end in cfg: codesq = get_sequences(start, end) - func_cfg_seqlist[funcname][(start,end)] = codesq + func_cfg_seqlist[funcname][(start, end)] = codesq return func_cfg_seqlist @@ -158,28 +193,30 @@ def get_sequences(start, end): inst_addr = NextHead(inst_addr) return seq + def get_stack_arg(func_addr): - print func_addr + print(func_addr) args = [] stack = GetFrame(func_addr) if not stack: - return [] + return [] firstM = GetFirstMember(stack) lastM = GetLastMember(stack) i = firstM - while i <=lastM: - mName = GetMemberName(stack,i) - mSize = GetMemberSize(stack,i) + while i <= lastM: + mName = GetMemberName(stack, i) + mSize = GetMemberSize(stack, i) if mSize: - i = i + mSize + i = i + mSize else: - i = i+4 + i = i + 4 if mName not in args and mName and ' s' not in mName and ' r' not in mName: args.append(mName) return args - #pickle.dump(funcs, open('C:/Documents and Settings/Administrator/Desktop/funcs','w')) - + # pickle.dump(funcs, open('C:/Documents and Settings/Administrator/Desktop/funcs','w')) + + def processDataSegs(): funcdata = {} datafunc = {} @@ -195,7 +232,7 @@ def processDataSegs(): refs = [v for v in DataRefsTo(cur)] for fea in refs: name = GetFunctionName(fea) - if len(name)== 0: + if len(name) == 0: continue if name not in funcdata: funcdata[name] = [cur] @@ -208,6 +245,7 @@ def processDataSegs(): cur = NextHead(cur) return funcdata, datafunc + def obtainDataRefs(callgraph): datarefs = {} funcdata, datafunc = processDataSegs() @@ -218,11 +256,9 @@ def obtainDataRefs(callgraph): refs = datafunc[dd] refs = list(set(refs)) if node in datarefs: - print refs + print(refs) datarefs[node] += refs datarefs[node] = list(set(datarefs[node])) else: datarefs[node] = refs return datarefs - - diff --git a/Genius3/raw-feature-extractor/discovRe.pyc b/Genius3/raw-feature-extractor/discovRe.pyc index 27c2158..cbd715c 100644 Binary files a/Genius3/raw-feature-extractor/discovRe.pyc and b/Genius3/raw-feature-extractor/discovRe.pyc differ diff --git a/Genius3/raw-feature-extractor/func.py b/Genius3/raw-feature-extractor/func.py index 7c77cc5..6e67820 100644 --- a/Genius3/raw-feature-extractor/func.py +++ b/Genius3/raw-feature-extractor/func.py @@ -11,283 +11,302 @@ from idaapi import * from idc import * import networkx as nx import cfg_constructor as cfg -import cPickle as pickle import pdb from raw_graphs import * #from discovRe_feature.discovRe import * from discovRe import * + +sys.path.append("D:\\hkn\\project_folder\\Gencoding3\\Genius3\\python") #import wingdbstub #wingdbstub.Ensure() + + def print_obj(obj): - "打印对象的所有属性" + # "打印对象的所有属性" print(obj.__dict__) + def gt_funcNames(ea): - funcs = [] - plt_func, plt_data = processpltSegs() - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - if funcname in plt_func: - print funcname - continue - funcs.append(funcname) - return funcs + funcs = [] + plt_func, plt_data = processpltSegs() + for funcea in Functions(SegStart(ea)): + funcname = get_unified_funcname(funcea) + if funcname in plt_func: + print(funcname) + continue + funcs.append(funcname) + return funcs + def get_funcs(ea): - funcs = {} - # Get current ea - # Loop from start to end in the current segment - plt_func, plt_data = processpltSegs() - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - if funcname in plt_func: - continue - func = get_func(funcea) - blocks = FlowChart(func) - funcs[funcname] = [] - for bl in blocks: - start = bl.startEA - end = bl.endEA - funcs[funcname].append((start, end)) - return funcs + funcs = {} + # Get current ea + # Loop from start to end in the current segment + plt_func, plt_data = processpltSegs() + for funcea in Functions(SegStart(ea)): + funcname = get_unified_funcname(funcea) + if funcname in plt_func: + continue + func = get_func(funcea) + blocks = FlowChart(func) + funcs[funcname] = [] + for bl in blocks: + start = bl.startEA + end = bl.endEA + funcs[funcname].append((start, end)) + return funcs + # used for the callgraph generation. def get_func_namesWithoutE(ea): - funcs = {} - plt_func, plt_data = processpltSegs() - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - if 'close' in funcname: - print funcea - if funcname in plt_func: - print funcname - continue - funcs[funcname] = funcea - return funcs + funcs = {} + plt_func, plt_data = processpltSegs() + for funcea in Functions(SegStart(ea)): + funcname = get_unified_funcname(funcea) + if 'close' in funcname: + print(funcea) + if funcname in plt_func: + print(funcname) + continue + funcs[funcname] = funcea + return funcs + # used for the callgraph generation. def get_func_names(ea): - funcs = {} - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - funcs[funcname] = funcea - return funcs + funcs = {} + for funcea in Functions(SegStart(ea)): + funcname = get_unified_funcname(funcea) + funcs[funcname] = funcea + return funcs + def get_func_bases(ea): - funcs = {} - plt_func, plt_data = processpltSegs() - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - if funcname in plt_func: - continue - funcs[funcea] = funcname - return funcs + funcs = {} + plt_func, plt_data = processpltSegs() + for funcea in Functions(SegStart(ea)): + funcname = get_unified_funcname(funcea) + if funcname in plt_func: + continue + funcs[funcea] = funcname + return funcs + def get_func_range(ea): - funcs = {} - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - func = get_func(funcea) - funcs[funcname] = (func.startEA, func.endEA) - return funcs + funcs = {} + for funcea in Functions(SegStart(ea)): + funcname = get_unified_funcname(funcea) + func = get_func(funcea) + funcs[funcname] = (func.startEA, func.endEA) + return funcs + def get_unified_funcname(ea): - funcname = GetFunctionName(ea) - if len(funcname) > 0: - if '.' == funcname[0]: - funcname = funcname[1:] - return funcname + funcname = GetFunctionName(ea) + if len(funcname) > 0: + if '.' == funcname[0]: + funcname = funcname[1:] + return funcname + def get_func_sequences(ea): - funcs_bodylist = {} - funcs = get_funcs(ea) - for funcname in funcs: - if funcname not in funcs_bodylist: - funcs_bodylist[funcname] = [] - for start, end in funcs[funcname]: - inst_addr = start - while inst_addr <= end: - opcode = GetMnem(inst_addr) - funcs_bodylist[funcname].append(opcode) - inst_addr = NextHead(inst_addr) - return funcs_bodylist + funcs_bodylist = {} + funcs = get_funcs(ea) + for funcname in funcs: + if funcname not in funcs_bodylist: + funcs_bodylist[funcname] = [] + for start, end in funcs[funcname]: + inst_addr = start + while inst_addr <= end: + opcode = GetMnem(inst_addr) + funcs_bodylist[funcname].append(opcode) + inst_addr = NextHead(inst_addr) + return funcs_bodylist + def get_func_cfgs_c(ea): - # type: (object) -> object - binary_name = idc.GetInputFile() - raw_cfgs = raw_graphs(binary_name) - externs_eas, ea_externs = processpltSegs() - i = 0 - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - func = get_func(funcea) - print i - i += 1 - icfg = cfg.getCfg(func, externs_eas, ea_externs) - func_f = get_discoverRe_feature(func, icfg[0]) - raw_g = raw_graph(funcname, icfg, func_f) #生成一个rawcfg。raw_graph是一个python class，定义在 raw_graph.py.包含g（本文的ACFG）、olg_g（discovRe的acfg）、feature（函数级别的一些特征，以及betweenness） - raw_cfgs.append(raw_g) # raw_graphs 是另一个python class，存储raw_graph的list。定义在 raw_graph.py - #print(raw_g.__dict__) - #print(raw_g) 由于raw_graph、raw_graphs都是class，直接print只会打印，不能打印对象的属性。 #https://blog.51cto.com/steed/2046408 print_obj、 print(obj.__dict__) - return raw_cfgs + # type: (object) -> object + binary_name = idc.GetInputFile() + raw_cfgs = raw_graphs(binary_name) + externs_eas, ea_externs = processpltSegs() + i = 0 + for funcea in Functions(SegStart(ea)): + funcname = get_unified_funcname(funcea) + func = get_func(funcea) + print(i) + i += 1 + icfg = cfg.getCfg(func, externs_eas, ea_externs) + func_f = get_discoverRe_feature(func, icfg[0]) + bb_f = get_bb_features(func) + raw_g = raw_graph(funcname, icfg, func_f, bb_f) # todo 为每个bb生成bb_features + raw_cfgs.append(raw_g) # raw_graphs 是另一个python class，存储raw_graph的list。定义在 raw_graph.py + #print(raw_g.__dict__) + #print(raw_g) 由于raw_graph、raw_graphs都是class，直接print只会打印，不能打印对象的属性。 #https://blog.51cto.com/steed/2046408 print_obj、 print(obj.__dict__) + return raw_cfgs + def get_func_cfgs_ctest(ea): - binary_name = idc.GetInputFile() - raw_cfgs = raw_graphs(binary_name) - externs_eas, ea_externs = processpltSegs() - i = 0 - diffs = {} - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - func = get_func(funcea) - print i - i += 1 - icfg, old_cfg = cfg.getCfg(func, externs_eas, ea_externs) - diffs[funcname] = (icfg, old_cfg) - #raw_g = raw_graph(funcname, icfg) - #raw_cfgs.append(raw_g) - - return diffs + binary_name = idc.GetInputFile() + raw_cfgs = raw_graphs(binary_name) + externs_eas, ea_externs = processpltSegs() + i = 0 + diffs = {} + for funcea in Functions(SegStart(ea)): + funcname = get_unified_funcname(funcea) + func = get_func(funcea) + print(i) + i += 1 + icfg, old_cfg = cfg.getCfg(func, externs_eas, ea_externs) + diffs[funcname] = (icfg, old_cfg) + #raw_g = raw_graph(funcname, icfg) + #raw_cfgs.append(raw_g) + + return diffs + def get_func_cfgs(ea): - func_cfglist = {} - i = 0 - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - func = get_func(funcea) - print i - i += 1 - try: - icfg = cfg.getCfg(func) - func_cfglist[funcname] = icfg - except: - pass - - return func_cfglist + func_cfglist = {} + i = 0 + for funcea in Functions(SegStart(ea)): + funcname = get_unified_funcname(funcea) + func = get_func(funcea) + print(i) + i += 1 + try: + icfg = cfg.getCfg(func) + func_cfglist[funcname] = icfg + except: + pass + + return func_cfglist + def get_func_cfg_sequences(func_cfglist): - func_cfg_seqlist = {} - for funcname in func_cfglist: - func_cfg_seqlist[funcname] = {} - cfg = func_cfglist[funcname][0] - for start, end in cfg: - codesq = get_sequences(start, end) - func_cfg_seqlist[funcname][(start,end)] = codesq + func_cfg_seqlist = {} + for funcname in func_cfglist: + func_cfg_seqlist[funcname] = {} + cfg = func_cfglist[funcname][0] + for start, end in cfg: + codesq = get_sequences(start, end) + func_cfg_seqlist[funcname][(start,end)] = codesq - return func_cfg_seqlist + return func_cfg_seqlist def get_sequences(start, end): - seq = [] - inst_addr = start - while inst_addr <= end: - opcode = GetMnem(inst_addr) - seq.append(opcode) - inst_addr = NextHead(inst_addr) - return seq + seq = [] + inst_addr = start + while inst_addr <= end: + opcode = GetMnem(inst_addr) + seq.append(opcode) + inst_addr = NextHead(inst_addr) + return seq + def get_stack_arg(func_addr): - print func_addr - args = [] - stack = GetFrame(func_addr) - if not stack: - return [] - firstM = GetFirstMember(stack) - lastM = GetLastMember(stack) - i = firstM - while i <=lastM: - mName = GetMemberName(stack,i) - mSize = GetMemberSize(stack,i) - if mSize: - i = i + mSize - else: - i = i+4 - if mName not in args and mName and ' s' not in mName and ' r' not in mName: - args.append(mName) - return args + print(func_addr) + args = [] + stack = GetFrame(func_addr) + if not stack: + return [] + firstM = GetFirstMember(stack) + lastM = GetLastMember(stack) + i = firstM + while i <=lastM: + mName = GetMemberName(stack,i) + mSize = GetMemberSize(stack,i) + if mSize: + i = i + mSize + else: + i = i+4 + if mName not in args and mName and ' s' not in mName and ' r' not in mName: + args.append(mName) + return args + #pickle.dump(funcs, open('C:/Documents and Settings/Administrator/Desktop/funcs','w')) - #pickle.dump(funcs, open('C:/Documents and Settings/Administrator/Desktop/funcs','w')) def processExternalSegs(): - funcdata = {} - datafunc = {} - for n in xrange(idaapi.get_segm_qty()): - seg = idaapi.getnseg(n) - ea = seg.startEA - segtype = idc.GetSegmentAttr(ea, idc.SEGATTR_TYPE) - if segtype in [idc.SEG_XTRN]: - start = idc.SegStart(ea) - end = idc.SegEnd(ea) - cur = start - while cur <= end: - name = get_unified_funcname(cur) - funcdata[name] = hex(cur) - cur = NextHead(cur) - return funcdata + funcdata = {} + datafunc = {} + for n in xrange(idaapi.get_segm_qty()): + seg = idaapi.getnseg(n) + ea = seg.startEA + segtype = idc.GetSegmentAttr(ea, idc.SEGATTR_TYPE) + if segtype in [idc.SEG_XTRN]: + start = idc.SegStart(ea) + end = idc.SegEnd(ea) + cur = start + while cur <= end: + name = get_unified_funcname(cur) + funcdata[name] = hex(cur) + cur = NextHead(cur) + return funcdata + def processpltSegs(): - funcdata = {} - datafunc = {} - for n in xrange(idaapi.get_segm_qty()): - seg = idaapi.getnseg(n) - ea = seg.startEA - segname = SegName(ea) - if segname in ['.plt', 'extern', '.MIPS.stubs']: - start = seg.startEA - end = seg.endEA - cur = start - while cur < end: - name = get_unified_funcname(cur) - funcdata[name] = hex(cur) - datafunc[cur]= name - cur = NextHead(cur) - return funcdata, datafunc + funcdata = {} + datafunc = {} + for n in xrange(idaapi.get_segm_qty()): + seg = idaapi.getnseg(n) + ea = seg.startEA + segname = SegName(ea) + if segname in ['.plt', 'extern', '.MIPS.stubs']: + start = seg.startEA + end = seg.endEA + cur = start + while cur < end: + name = get_unified_funcname(cur) + funcdata[name] = hex(cur) + datafunc[cur]= name + cur = NextHead(cur) + return funcdata, datafunc + - def processDataSegs(): - funcdata = {} - datafunc = {} - for n in xrange(idaapi.get_segm_qty()): - seg = idaapi.getnseg(n) - ea = seg.startEA - segtype = idc.GetSegmentAttr(ea, idc.SEGATTR_TYPE) - if segtype in [idc.SEG_DATA, idc.SEG_BSS]: - start = idc.SegStart(ea) - end = idc.SegEnd(ea) - cur = start - while cur <= end: - refs = [v for v in DataRefsTo(cur)] - for fea in refs: - name = get_unified_funcname(fea) - if len(name)== 0: - continue - if name not in funcdata: - funcdata[name] = [cur] - else: - funcdata[name].append(cur) - if cur not in datafunc: - datafunc[cur] = [name] - else: - datafunc[cur].append(name) - cur = NextHead(cur) - return funcdata, datafunc + funcdata = {} + datafunc = {} + for n in xrange(idaapi.get_segm_qty()): + seg = idaapi.getnseg(n) + ea = seg.startEA + segtype = idc.GetSegmentAttr(ea, idc.SEGATTR_TYPE) + if segtype in [idc.SEG_DATA, idc.SEG_BSS]: + start = idc.SegStart(ea) + end = idc.SegEnd(ea) + cur = start + while cur <= end: + refs = [v for v in DataRefsTo(cur)] + for fea in refs: + name = get_unified_funcname(fea) + if len(name)== 0: + continue + if name not in funcdata: + funcdata[name] = [cur] + else: + funcdata[name].append(cur) + if cur not in datafunc: + datafunc[cur] = [name] + else: + datafunc[cur].append(name) + cur = NextHead(cur) + return funcdata, datafunc + def obtainDataRefs(callgraph): - datarefs = {} - funcdata, datafunc = processDataSegs() - for node in callgraph: - if node in funcdata: - datas = funcdata[node] - for dd in datas: - refs = datafunc[dd] - refs = list(set(refs)) - if node in datarefs: - print refs - datarefs[node] += refs - datarefs[node] = list(set(datarefs[node])) - else: - datarefs[node] = refs - return datarefs + datarefs = {} + funcdata, datafunc = processDataSegs() + for node in callgraph: + if node in funcdata: + datas = funcdata[node] + for dd in datas: + refs = datafunc[dd] + refs = list(set(refs)) + if node in datarefs: + print(refs) + datarefs[node] += refs + datarefs[node] = list(set(datarefs[node])) + else: + datarefs[node] = refs + return datarefs diff --git a/Genius3/raw-feature-extractor/func.pyc b/Genius3/raw-feature-extractor/func.pyc index 3c3cc2c..f85ad3f 100644 Binary files a/Genius3/raw-feature-extractor/func.pyc and b/Genius3/raw-feature-extractor/func.pyc differ diff --git a/Genius3/raw-feature-extractor/graph_analysis_ida.py b/Genius3/raw-feature-extractor/graph_analysis_ida.py index 122efa9..390f8f1 100644 --- a/Genius3/raw-feature-extractor/graph_analysis_ida.py +++ b/Genius3/raw-feature-extractor/graph_analysis_ida.py @@ -1,3 +1,4 @@ +# coding=utf-8 from idautils import * from idaapi import * from idc import * @@ -138,7 +139,7 @@ def get_stackVariables(func_addr): return len(args) - +# 计算算数指令数量 def calArithmeticIns(bl): x86_AI = {'add':1, 'sub':1, 'div':1, 'imul':1, 'idiv':1, 'mul':1, 'shl':1, 'dec':1, 'inc':1} mips_AI = {'add':1, 'addu':1, 'addi':1, 'addiu':1, 'mult':1, 'multu':1, 'div':1, 'divu':1} @@ -156,6 +157,7 @@ def calArithmeticIns(bl): inst_addr = NextHead(inst_addr) return invoke_num +# 计算调用数量 def calCalls(bl): calls = {'call':1, 'jal':1, 'jalr':1} start = bl[0] @@ -169,6 +171,7 @@ def calCalls(bl): inst_addr = NextHead(inst_addr) return invoke_num +# 计算指令数量 def calInsts(bl): start = bl[0] end = bl[1] @@ -196,7 +199,23 @@ def calLogicInstructions(bl): inst_addr = NextHead(inst_addr) return invoke_num + +def calIns(bl, inst): + calls = {} + calls.update(inst) + start = bl[0] + end = bl[1] + invoke_num = 0 + inst_addr = start + while inst_addr < end: + opcode = GetMnem(inst_addr) + if opcode in calls: + invoke_num += 1 + inst_addr = NextHead(inst_addr) + return invoke_num + def calSconstants(bl): + calls = {} start = bl[0] end = bl[1] invoke_num = 0 diff --git a/Genius3/raw-feature-extractor/graph_analysis_ida.pyc b/Genius3/raw-feature-extractor/graph_analysis_ida.pyc index c444cce..9d73ee9 100644 Binary files a/Genius3/raw-feature-extractor/graph_analysis_ida.pyc and b/Genius3/raw-feature-extractor/graph_analysis_ida.pyc differ diff --git a/Genius3/raw-feature-extractor/graph_property.pyc b/Genius3/raw-feature-extractor/graph_property.pyc index bccabd9..d77a23a 100644 Binary files a/Genius3/raw-feature-extractor/graph_property.pyc and b/Genius3/raw-feature-extractor/graph_property.pyc differ diff --git a/Genius3/raw-feature-extractor/ida_batch.py b/Genius3/raw-feature-extractor/ida_batch.py new file mode 100644 index 0000000..1d5ef6f --- /dev/null +++ b/Genius3/raw-feature-extractor/ida_batch.py @@ -0,0 +1,66 @@ +# coding=utf-8 +import os +import subprocess +import multiprocessing +from tqdm import tqdm +import time + +# 单个pe文件处理超时/s +TIMEOUT = 60 + + +def call_preprocess(cmd_line): + subprocess.call(cmd_line, shell=True) + + +def batch_mode(): + for workflow in range(0, 1): + # workflow = 0 + pe_dir = 'D:\\hkn\\infected\\datasets\\virusshare_infected{}'.format(workflow) + # for test + # pe_dir = 'D:\\hkn\\infected\\datasets\\virusshare_test' + log_path = 'D:\\hkn\\infected\\datasets\\logging\\ida_log{}.log'.format(workflow) + process_log_path = 'D:\\hkn\\infected\\datasets\\logging\\ida_process_log{}.log'.format(workflow) + with open(log_path, 'a+') as log, open(process_log_path, 'a+') as process_log: + logged = log.readline() + if logged == '': + log_index = 0 + else: + log_index = int(logged) + + # pe = "VirusShare_bc161e5e792028e8137aa070fda53f82" + for index, pe in enumerate(tqdm(sorted(os.listdir(pe_dir)))): + if index < log_index: + continue + + # for test + # cmd_line = r'idaq64 -c -A -S"D:\hkn\project_folder\Gencoding3\Genius3\raw-feature-extractor\preprocessing_ida.py {}" -oF:\iout {}'.format( + # workflow, os.path.join(pe_dir, pe)) + cmd_line = r'idaq64 -c -A -S"D:\hkn\project_folder\Gencoding3\Genius3\raw-feature-extractor\preprocessing_ida.py {}" -oF:\iout {}'.format(workflow, os.path.join(pe_dir, pe)) + + p = multiprocessing.Process(target=call_preprocess, args=[cmd_line]) + p.start() + flag_kill = True + start = time.time() + while time.time() - start <= TIMEOUT: + if not p.is_alive(): + flag_kill = False + break + else: + time.sleep(1) + + if flag_kill: + subprocess.call('taskkill /im idaq64.exe /f') + process_log.write("index {}, {} in workflow {} stuck, process terminated.\n".format(index, pe, workflow)) + else: + # 正常运行结束 + log.truncate(0) + log.seek(0) + log.write(str(index)) + log.flush() + process_log.write("index {}, {} process done.\n".format(index, pe)) + + +# 注意：该py文件必须放在IDA的根目录下，且必须使用cmd命令执行，否则无法链接到python库 +if __name__ == '__main__': + batch_mode() diff --git a/Genius3/raw-feature-extractor/preprocessing_ida.py b/Genius3/raw-feature-extractor/preprocessing_ida.py index 0fd2a00..fd24ec7 100644 --- a/Genius3/raw-feature-extractor/preprocessing_ida.py +++ b/Genius3/raw-feature-extractor/preprocessing_ida.py @@ -1,56 +1,47 @@ # -*- coding: UTF-8 -*- -import sys - +import pickle from func import * from raw_graphs import * from idc import * +import idautils import os -import argparse -import raw_graphs +import sys -def print_obj(obj): - "打印对象的所有属性" - print(obj.__dict__) -def parse_command(): - parser = argparse.ArgumentParser(description='Process some integers.') - parser.add_argument("--path", type=str, help="The directory where to store the generated .ida file") - args = parser.parse_args() - return args +def preprocess(): + # E:\BaiduNetdiskDownload\IDA_Pro_v6.8\IDA_Pro_v6.8\idaq.exe -c -S"raw-feature-extractor/preprocessing_ida.py --path C:\Program1\pycharmproject\Genius3\acfgs" hpcenter + # print str(sys.argv) #['raw-feature-extractor/preprocessing_ida.py'] + # print str(idc.ARGV) #['raw-feature-extractor/preprocessing_ida.py', '--path', 'C:\\Program1\\pycharmproject\\Genius3\\acfgs'] + # print idc.ARGV[2] + # print type(idc.ARGV[2]) + binary_name = idc.GetInputFile() + + workflow = idc.ARGV[1] + # workflow = 0 + cfg_path = "D:\\hkn\\infected\\datasets\\virusshare_infected{}_cfg".format(workflow) + gdl_path = "D:\\hkn\\infected\\datasets\\virusshare_infected{}_dot\\{}.dot".format(workflow, binary_name) + + analysis_flags = idc.GetShortPrm(idc.INF_START_AF) + analysis_flags &= ~idc.AF_IMMOFF + idc.SetShortPrm(idc.INF_START_AF, analysis_flags) + idaapi.autoWait() + + # 生成pe文件的cfg列表 + cfgs = get_func_cfgs_c(FirstSeg()) + # 生成pe文件的fcg + # idc.GenCallGdl(gdl_path, 'Call Gdl', idc.CHART_GEN_GDL) 这个生成gdl文件，网上几乎找不到gdl这个格式 + idc.GenCallGdl(gdl_path, 'Call Gdl', idaapi.CHART_GEN_DOT) + + full_path = os.path.join(cfg_path, binary_name + '.ida') + pickle.dump(cfgs, open(full_path, 'w')) + + # 由于命令行模式也必须打开ida pro，因此每次结束自动关闭ida + idc.Exit(0) + + +# 通用命令行格式 idaq64 -c -A -S"preprocessing_ida.py arg1 arg2" VirusShare_bca58b12923073 +# 此处使用 idaq64 -c -A -S"preprocessing_ida.py workflow" -oF:\iout pe_path，完整命令行如下 +# F:\kkk\IDA_6.6\idaq64 -c -A -S"D:\hkn\project_folder\Gencoding3\Genius3\raw-feature-extractor\preprocessing_ida.py 0" -oF:\iout D:\hkn\infected\datasets\virusshare_infected0\VirusShare_bc161e5e792028e8137aa070fda53f82 if __name__ == '__main__': - #E:\BaiduNetdiskDownload\IDA_Pro_v6.8\IDA_Pro_v6.8\idaq.exe -c -S"raw-feature-extractor/preprocessing_ida.py --path C:\Program1\pycharmproject\Genius3\acfgs" hpcenter - #print str(sys.argv) #['raw-feature-extractor/preprocessing_ida.py'] - #print str(idc.ARGV) #['raw-feature-extractor/preprocessing_ida.py', '--path', 'C:\\Program1\\pycharmproject\\Genius3\\acfgs'] - #print idc.ARGV[2] - #print type(idc.ARGV[2]) - - # E:\BaiduNetdiskDownload\IDA_Pro_v6.8\IDA_Pro_v6.8\idaq.exe -c -A -S"raw-feature-extractor/preprocessing_ida.py --path C:\Program1\pycharmproject\Genius4\acfgs" hpcenter - #测试生成原始特征的时间。 - start_t = time.clock() - - args = parse_command() - #path = args.path - path = idc.ARGV[2] - analysis_flags = idc.GetShortPrm(idc.INF_START_AF) - analysis_flags &= ~idc.AF_IMMOFF - # turn off "automatically make offset" heuristic - idc.SetShortPrm(idc.INF_START_AF, analysis_flags) - idaapi.autoWait() - cfgs = get_func_cfgs_c(FirstSeg()) - - end_t = time.clock() - print (end_t - start_t) #1.5934438s hpcenter 83.4 KB #35.6745299s SCGDW698 5.5mb #14.1480888s 762kb SCMQTTIot 这个时间包括ida分析二进制文件的时间和脚本生成对应原始特征的时间 - # 应该是随着函数和基本块的数量增加而线性增加的，先不写了。可能ida分析二进制文件的占比比较高 - - binary_name = idc.GetInputFile() + '.ida' - print path - print binary_name - fullpath = os.path.join(path, binary_name) - pickle.dump(cfgs, open(fullpath,'w')) - #print binary_name - - - - #加上这句，脚本执行完就退出IDA - #idc.Exit(0) \ No newline at end of file + preprocess() diff --git a/Genius3/raw-feature-extractor/preprocessing_ida.pyc b/Genius3/raw-feature-extractor/preprocessing_ida.pyc deleted file mode 100644 index 83dda67..0000000 Binary files a/Genius3/raw-feature-extractor/preprocessing_ida.pyc and /dev/null differ diff --git a/Genius3/raw-feature-extractor/raw_graphs.py b/Genius3/raw-feature-extractor/raw_graphs.py index d7d4b33..055e0ad 100644 --- a/Genius3/raw-feature-extractor/raw_graphs.py +++ b/Genius3/raw-feature-extractor/raw_graphs.py @@ -2,24 +2,26 @@ import itertools import sys -sys.path.insert(0, '/usr/local/lib/python2.7/dist-packages/') -sys.path.insert(1, 'C:/Python27/Lib/site-packages') +# sys.path.insert(0, '/usr/local/lib/python2.7/dist-packages/') +# sys.path.insert(1, 'C:/Python27/Lib/site-packages') import networkx as nx -#import numpy as np +import numpy as np from subprocess import Popen, PIPE import pdb import os -import re,mmap -#from graph_edit_new import * +import re +import mmap +# from graph_edit_new import * class raw_graph: - def __init__(self, funcname, g, func_f): + def __init__(self, funcname, g, func_f, bb_f): #print "create" self.funcname = funcname self.old_g = g[0] self.g = nx.DiGraph() self.entry = g[1] + self.bb_features = bb_f # len=bb数量,每个元素都是一个11维向量 self.fun_features = func_f self.attributing() @@ -54,6 +56,9 @@ class raw_graph: offsprings[suc] = 1 self.getOffsprings(g, suc, offsprings) + # 提取acfg的属性特征 + # 调用/传输/算术/逻辑/比较/移动/终止 + # 数据声明/总指令数/字符串或整数常量/后代的数量 def retrieveVec(self, id_, g): feature_vec = [] #numC0 @@ -96,7 +101,7 @@ class raw_graph: def genMotifs(self, n): motifs = {} - subgs = enumerating(n) + subgs = self.enumerating(n) for subg in subgs: if len(motifs) == 0: motifs[subg] = [subg] @@ -182,7 +187,7 @@ class raw_graph: tg.updateG(fang, indexes, self.g) return tg pdb.set_trace() - print "there is g which is none" + print("there is g which is none") def createG(self, binary_str, n): g = nx.DiGraph() diff --git a/Genius3/raw-feature-extractor/raw_graphs.pyc b/Genius3/raw-feature-extractor/raw_graphs.pyc index 61f22dc..4d74634 100644 Binary files a/Genius3/raw-feature-extractor/raw_graphs.pyc and b/Genius3/raw-feature-extractor/raw_graphs.pyc differ diff --git a/Genius3/raw-feature-extractor/read_idaFILE.py b/Genius3/raw-feature-extractor/read_idaFILE.py index ea263ed..8355240 100644 --- a/Genius3/raw-feature-extractor/read_idaFILE.py +++ b/Genius3/raw-feature-extractor/read_idaFILE.py @@ -1,70 +1,71 @@ # -*- coding: UTF-8 -*- import sys -import sys from matplotlib import pyplot as plt -sys.path.insert(0, '/usr/local/lib/python2.7/dist-packages/') -sys.path.insert(1, 'C:/Python27/Lib/site-packages') import networkx as nx +import pickle +# sys.path.insert(0, '/usr/local/lib/python2.7/dist-packages/') +# sys.path.insert(1, 'C:/Python27/Lib/site-packages') + + def print_obj(obj): - "打印对象的所有属性" + # "打印对象的所有属性" print(obj.__dict__) -import pickle -#sub_10F20 308 反编译代码有字符串，但是这个特征提取里没有字符串 constant，可能是间接引用的，不识别。看了下所有函数的特征，几乎都没有字符串常量，可能都是写在别的地方然后引用的。 -#sub_166C4 393 +# sub_10F20 308 反编译代码有字符串，但是这个特征提取里没有字符串 constant，可能是间接引用的，不识别。看了下所有函数的特征，几乎都没有字符串常量，可能都是写在别的地方然后引用的。 +# sub_166C4 393 if __name__ == '__main__': - - - testpath = "C:\Program1\pycharmproject\Genius3/acfgs/hpcenter.ida" + testpath = "D:\\hkn\\infected\\datasets\\virusshare_infected0_cfg\\VirusShare_cd53c6637ca75ac5fc1cbe6d2ced41a1.ida" fr = open(testpath, 'r') - data1 = pickle.load(fr) #一个二进制文件的acfgs - #print(type(data1)) - #print_obj(data1) - #print data1.raw_graph_list[393] - #print_obj(data1.raw_graph_list[393]) - #nx.draw(data1.raw_graph_list[393].g,with_labels=True) - #plt.show() + data = pickle.load(fr) #一个二进制文件的acfgs + fr.close() - print "一个二进制文件的所有函数的原始特征，list。" - print_obj(data1) #acfg list - print "\n" + # print(type(data1)) + # print_obj(data1) + # print data1.raw_graph_list[393] + # print_obj(data1.raw_graph_list[393]) + # nx.draw(data1.raw_graph_list[393].g,with_labels=True) + # plt.show() - print "一个函数的原始特征，由old_g（discovRe方法的ACFG），g（Genius方法的ACFG），fun_feature（表示函数级别的特征的向量）三部分构成" - print_obj(data1.raw_graph_list[393]) #一个函数的acfg - print "\n" - feature=data1.raw_graph_list[393].fun_features - print "函数级别特征： # 1 function calls # 2 logic instructions # 3 TransferIns # 4 LocalVariables # 5 BB basicblocks# 6 Edges # 7 IncommingCalls# 8 Intrs# 9 between # 10 strings # 11 consts" - print feature - print "\n" + print("一个二进制文件的所有函数的原始特征，list。") + print_obj(data) # acfg list + print("\n") + + print("一个函数的原始特征，由old_g（discovRe方法的ACFG），g（Genius方法的ACFG），fun_feature（表示函数级别的特征的向量）三部分构成") + print_obj(data.raw_graph_list[0]) # 一个函数的acfg + print("其中fun_features = 函数级别特征： # 1 function calls # 2 logic instructions # 3 TransferIns # 4 LocalVariables # 5 BB basicblocks# 6 Edges # 7 IncommingCalls# 8 Intrs# 9 between # 10 strings # 11 consts") + # feature = data.raw_graph_list[0].fun_features + print("old_g:{}".format(data.raw_graph_list[0].old_g)) + print("g:{}".format(data.raw_graph_list[0].g)) - # G=data1.raw_graph_list[393].old_g + # G = data1.raw_graph_list[393].old_g # print G.node[0] # G.node[i]是dict # for key, value in G.node[0].items(): # print('{key}:{value}'.format(key=key, value=value)) - # 一个基本块的特征 #1'consts' 数字常量 #2'strings'字符串常量 #3'offs' offspring 字节点数量？ #4'numAs' 算数指令如INC #5'numCalls' 调用指令 #6'numIns' 指令数量 #7'numLIs' LogicInstructions 如AND #8'numTIs' 转移指令数量 - G=data1.raw_graph_list[393].g - print "# 一个基本块的特征 #1'consts' 数字常量 #2'strings'字符串常量 #3'offs' offspring 字节点数量？ #4'numAs' 算数指令如INC #5'numCalls' 调用指令 #6'numIns' 指令数量 #7'numLIs' LogicInstructions 如AND #8'numTIs' 转移指令数量" - print G.node[0] - print "\n" - # for key, value in G.node[0].items(): - # print('{key}:{value}'.format(key=key, value=value)) + # 基本块的特征 #1'consts' 数字常量 #2'strings'字符串常量 #3'offs' offspring 字节点数量？ #4'numAs' 算数指令如INC #5'numCalls' 调用指令 #6'numIns' 指令数量 #7'numLIs' LogicInstructions 如AND #8'numTIs' 转移指令数量 + G = data.raw_graph_list[0].g + print("# 基本块的特征 #1'consts' 数字常量 #2'strings'字符串常量 #3'offs' offspring 后代数量 #4'numAs' 算数指令如INC #5'numCalls' 调用指令 #6'numIns' 指令数量 #7'numLIs' LogicInstructions 逻辑如AND #8'numTIs' 转移指令数量") + # print(G.node[0]) + # print("\n") + # 函数内所有基本快的特征 + for key, value in G.node.items(): + print('{}:{}'.format(key, value)) #oldg就是读取IDA的CFG，所以数量、方向等都一样；g根据old_g生成，也一样 #old g - G = data1.raw_graph_list[393].old_g - nx.draw(G,with_labels=True) + G = data.raw_graph_list[0].old_g + nx.draw(G, with_labels=True) #plt.title('old_g') plt.show() # g - G = data1.raw_graph_list[393].g - nx.draw(G,with_labels=True) + G = data.raw_graph_list[0].g + nx.draw(G, with_labels=True) #plt.title('Genius_g') plt.show() diff --git a/Genius3/raw-feature-extractor/test.py b/Genius3/raw-feature-extractor/test.py index 3aa7edf..3c6cb16 100644 --- a/Genius3/raw-feature-extractor/test.py +++ b/Genius3/raw-feature-extractor/test.py @@ -1,8 +1,70 @@ +import re +import os +import subprocess +import time + + +def func(): + path = "D:\\hkn\\infected\\datasets\\virusshare_infected0_dot\\VirusShare_ccbfc20470b099a188bda55aa8421427.dot" + result = [] + with open(path, 'r') as f: + for line in f: + if '->' in line: + result.append(re.findall(r'\b\d+\b', line)) + print(result) + + +def func1(): + for f in os.listdir("D:\\hkn\\infected\\datasets\\virusshare_infected0_dot"): + print(f[:-4]) + + +def gen_dir(): + parent_dir = "D:\\hkn\\infected\\datasets" + for workflow in range(0, 35): + # infected = "virusshare_infected{}".format(workflow) + # cfg = "virusshare_infected{}_cfg".format(workflow) + # dot = "virusshare_infected{}_dot".format(workflow) + # jsonl = "virusshare_infected{}_json".format(workflow) + iout = "virusshare_infected{}_iout".format(workflow) + + # os.mkdir(os.path.join(parent_dir, infected)) + # os.mkdir(os.path.join(parent_dir, cfg)) + # os.mkdir(os.path.join(parent_dir, dot)) + # os.mkdir(os.path.join(parent_dir, jsonl)) + os.rmdir(os.path.join(parent_dir, iout)) + # os.rmdir(os.path.join(parent_dir, ida)) + + +def change_max_item_lines(): + f = open("F:\\kkk\\IDA_6.6\\cfg\\ida.cfg", 'rb') + s = f.read() + f.close() + index = s.find(b'MAX_ITEM_LINES = 5000') + news = s.replace(b'MAX_ITEM_LINES = 5000', b'MAX_ITEM_LINES = 50000') + # print(news[index:index+50]) + f = open("F:\\kkk\\IDA_6.6\\cfg\\ida.cfg", 'wb') + f.write(news) + f.close() + + +def clock(): + TIMEOUT = 10 + start = time.time() + flag_kill = True + while time.time() - start <= TIMEOUT: + if not p.is_alive(): + flag_kill = False + break + else: + time.sleep(1) # Just to avoid hogging the CPU + + if flag_kill: + subprocess.call('taskkill /im idaq64.exe /f') + + +if __name__ == '__main__': + # gen_dir() + # change_max_item_lines() + subprocess.call('taskkill /im idaq64.exe /f') -import pickle -testpath = "C:\Program1\pycharmproject\Genius3/acfgs/hpcenter.ida" -fr = open(testpath, 'r') -data1 = pickle.load(fr) -print(type(data1)) -# # print_obj(data1) -# print cfgs.raw_graph_list[0] \ No newline at end of file diff --git a/raw-feature-extractor/cfg_constructor.py b/raw-feature-extractor/cfg_constructor.py deleted file mode 100755 index 9bd3bdd..0000000 --- a/raw-feature-extractor/cfg_constructor.py +++ /dev/null @@ -1,286 +0,0 @@ -import copy -import networkx as nx -from idautils import * -from idaapi import * -from idc import * - -import copy -import networkx as nx -from idautils import * -from idaapi import * -from idc import * -from graph_analysis_ida import * - - -def getCfg(func, externs_eas, ea_externs): - func_start = func.startEA - func_end = func.endEA - cfg = nx.DiGraph() - control_blocks, main_blocks = obtain_block_sequence(func) - i = 0 - visited = {} - start_node = None - for bl in control_blocks: - start = control_blocks[bl][0] - end = control_blocks[bl][1] - src_node = (start, end) - if src_node not in visited: - src_id = len(cfg) - visited[src_node] = src_id - cfg.add_node(src_id) - cfg.node[src_id]['label'] = src_node - else: - src_id = visited[src_node] - - #if end in seq_blocks and GetMnem(PrevHead(end)) != 'jmp': - if start == func_start: - cfg.node[src_id]['c'] = "start" - start_node = src_node - if end == func_end: - cfg.node[src_id]['c'] = "end" - #print control_ea, 1 - refs = CodeRefsTo(start, 0) - for ref in refs: - if ref in control_blocks: - dst_node = control_blocks[ref] - if dst_node not in visited: - visited[dst_node] = len(cfg) - dst_id = visited[dst_node] - cfg.add_edge(dst_id, src_id) - cfg.node[dst_id]['label'] = dst_node - #print control_ea, 1 - refs = CodeRefsTo(start, 1) - for ref in refs: - if ref in control_blocks: - dst_node = control_blocks[ref] - if dst_node not in visited: - visited[dst_node] = len(cfg) - dst_id = visited[dst_node] - cfg.add_edge(dst_id, src_id) - cfg.node[dst_id]['label'] = dst_node - #print "attributing" - attributingRe(cfg, externs_eas, ea_externs) - # removing deadnodes - #old_cfg = copy.deepcopy(cfg) - #transform(cfg) - return cfg, 0 - -def transform(cfg): - merging(cfg) - filtering(cfg) - -def merging(cfg): - bb_ids = cfg.nodes() - for bb_id in bb_ids: - try: - bb = cfg.node[bb_id]['label'] - bb_start = bb[0] - bb_end = bb[1] - succs = cfg.successors(bb_id) - #preds = cfg.predecessors(bb_id) - if len(succs) == 1: - preds = cfg.predecessors(succs[0]) - if len(preds) == 1: - domerge(cfg, bb_id, succs[0]) - except: - pass - -def domerge(cfg, bb_id, suc_node): - suc_nodes = cfg.successors(suc_node) - for node in suc_nodes: - cfg.add_edge(bb_id, node) - cfg.remove_node(suc_node) - - -def filtering(cfg): - rm_sets = [] - for bb_id in cfg: - bb = cfg.node[bb_id]['label'] - bb_start = bb[0] - bb_end = bb[1] - re = remove(bb_start, bb_end) - print bb_id, re, bb_start, bb_end - if re: - print re, bb_id - rm_sets.append(bb_id) - print rm_sets - for bb_id in rm_sets: - cfg.remove_node(bb_id) - -def remove(bb_start, bb_end): - seqs = getSequences(bb_start, bb_end) - if matchseq(seqs): - return True - return False - -def matchseq(seqs): - mips = set(['lw', "jr", "addiu"]) - x86 = set(['add', 'pop', 'retn']) - b_mips = set(['b', ('move','$v0')]) - b_x86 = set(['b', ('mov','$eax')]) - re_mips = set([('move','$v0')]) - re_x86 = set([('mov','$eax')]) - diff_mips = set(seqs).difference(set(mips)) - if len(diff_mips) == 0: - return True - diff_x86 = set(seqs).difference(set(x86)) - if len(diff_x86) == 0: - return True - if set(seqs) == b_mips: - return True - if set(seqs) == b_x86: - return True - if set(seqs) == re_mips: - return True - if set(seqs) == re_x86: - return True - return False - -def attributingRe(cfg, externs_eas, ea_externs): - for node_id in cfg: - bl = cfg.node[node_id]['label'] - numIns = calInsts(bl) - cfg.node[node_id]['numIns'] = numIns - numCalls = calCalls(bl) - cfg.node[node_id]['numCalls'] = numCalls - numLIs = calLogicInstructions(bl) - cfg.node[node_id]['numLIs'] = numLIs - numAs = calArithmeticIns(bl) - cfg.node[node_id]['numAs'] = numAs - strings, consts = getBBconsts(bl) - cfg.node[node_id]['numNc'] = len(strings) + len(consts) - cfg.node[node_id]['consts'] = consts - cfg.node[node_id]['strings'] = strings - externs = retrieveExterns(bl, ea_externs) - cfg.node[node_id]['externs'] = externs - numTIs = calTransferIns(bl) - cfg.node[node_id]['numTIs'] = numTIs - - -def attributing(cfg): - ga = graph_analysis() - ga.gwithoffspring(cfg) - print "finishing offspring" - for node in cfg: - stmt_num = getStmtNum(node) - binary_value = getBinaryValue(node) - cfg.node[node]['stmt_num'] = stmt_num - cfg.node[node]['binary_value'] = binary_value - ga.domChecking(cfg) - print "finishing domChecking" - ga.loopChecking(cfg) - print "finishing loopChecking" - - -def getStmtNum(node): - start = node[0] - end = node[1] - stmt_num = 0 - inst_addr = start - while inst_addr < end: - inst_addr = NextHead(inst_addr) - stmt_num += 1 - return stmt_num - -def getBinaryValue(node): - start = node[0] - inst_addr = NextHead(start) - value = 0 - addr = 0 - for x in xrange((inst_addr - start)-1): - addr = start + x - y = GetOriginalByte(addr) - print value, addr, y - value = value | y - value = value << 8 - print value - - addr = inst_addr - 1 - y = GetOriginalByte(addr) - print value, addr, y - value = value | y - print node - print bin(value) - return value - - -def cfg_construct(func): - func_start = func.startEA - func_end = func.endEA - cfg = nx.DiGraph() - seq_blocks, main_blocks = obtain_block_sequence(func) - i = 0 - visited = {} - for bl in seq_blocks: - start = seq_blocks[bl][0] - end = seq_blocks[bl][1] - src_node = (start, end) - if end in seq_blocks and GetMnem(PrevHead(end)) != 'jmp': - next_start = seq_blocks[end][0] - next_end = seq_blocks[end][1] - next_node = (next_start, next_end) - cfg.add_edge(src_node, next_node) - if start == func_start: - cfg.add_node(src_node, c='start') - start_node = src_node - if end == func_end: - cfg.add_node(src_node, c='end') - refs = CodeRefsFrom(PrevHead(end), 0) - - for ref in refs: - #print ref - if ref in seq_blocks: - dst_node = (seq_blocks[ref][0], seq_blocks[ref][1]) - cfg.add_edge(src_node, dst_node) - return cfg, start_node - - -def obtain_allpaths( cfg, node, path, allpaths): - path.append(node) - if 'c' in cfg.node[node] and cfg.node[node]['c'] == 'end': - allpaths.append(path) - return - else: - for suc in cfg.successors(node): - if suc not in path: - path_copy = copy.copy(path) - obtain_allpaths(cfg, suc, path_copy, allpaths) - - -def obtain_block_sequence(func): - control_blocks = {} - main_blocks = {} - blocks = [(v.startEA, v.endEA) for v in FlowChart(func)] - for bl in blocks: - base = bl[0] - end = PrevHead(bl[1]) - control_ea = checkCB(bl) - control_blocks[control_ea] = bl - control_blocks[end] = bl - if func.startEA <= base <= func.endEA: - main_blocks[base] = bl - x = sorted(main_blocks) - return control_blocks, x - -def checkCB(bl): - start = bl[0] - end = bl[1] - ea = start - while ea < end: - if checkCondition(ea): - return ea - ea = NextHead(ea) - - return PrevHead(end) - -def checkCondition(ea): - mips_branch = {"beqz":1, "beq":1, "bne":1, "bgez":1, "b":1, "bnez":1, "bgtz":1, "bltz":1, "blez":1, "bgt":1, "bge":1, "blt":1, "ble":1, "bgtu":1, "bgeu":1, "bltu":1, "bleu":1} - x86_branch = {"jz":1, "jnb":1, "jne":1, "je":1, "jg":1, "jle":1, "jl":1, "jge":1, "ja":1, "jae":1, "jb":1, "jbe":1, "jo":1, "jno":1, "js":1, "jns":1} - arm_branch = {"B":1, "BAL":1, "BNE":1, "BEQ":1, "BPL":1, "BMI":1, "BCC":1, "BLO":1, "BCS":1, "BHS":1, "BVC":1, "BVS":1, "BGT":1, "BGE":1, "BLT":1, "BLE":1, "BHI":1 ,"BLS":1 } - conds = {} - conds.update(mips_branch) - conds.update(x86_branch) - opcode = GetMnem(ea) - if opcode in conds: - return True - return False diff --git a/raw-feature-extractor/discovRe.py b/raw-feature-extractor/discovRe.py deleted file mode 100755 index 997edfb..0000000 --- a/raw-feature-extractor/discovRe.py +++ /dev/null @@ -1,228 +0,0 @@ -# -# Reference Lister -# -# List all functions and all references to them in the current section. -# -# Implemented with the idautils module -# -import networkx as nx -import cPickle as pickle -import pdb -from graph_analysis_ida import * -from graph_property import * -#import wingdbstub -#wingdbstub.Ensure() - -def get_funcs(ea): - funcs = {} - # Get current ea - # Loop from start to end in the current segment - for funcea in Functions(SegStart(ea)): - funcname = GetFunctionName(funcea) - func = get_func(funcea) - blocks = FlowChart(func) - funcs[funcname] = [] - for bl in blocks: - start = bl.startEA - end = bl.endEA - funcs[funcname].append((start, end)) - return funcs - -def get_funcs_for_discoverRe(ea): - features = {} - for funcea in Functions(SegStart(ea)): - funcname = GetFunctionName(funcea) - print funcname - func = get_func(funcea) - feature = get_discoverRe_feature(func) - features[funcname] = feature - return features - -def get_discoverRe_feature(func, icfg): - start = func.startEA - end = func.endEA - features = [] - FunctionCalls = getFuncCalls(func) - #1 - features.append(FunctionCalls) - LogicInstr = getLogicInsts(func) - #2 - features.append(LogicInstr) - Transfer = getTransferInsts(func) - #3 - features.append(Transfer) - Locals = getLocalVariables(func) - #4 - features.append(Locals) - BB = getBasicBlocks(func) - #5 - features.append(BB) - Edges = len(icfg.edges()) - #6 - features.append(Edges) - Incoming = getIncommingCalls(func) - #7 - features.append(Incoming) - #8 - Instrs = getIntrs(func) - features.append(Instrs) - between = retrieveGP(icfg) - #9 - features.append(between) - - strings, consts = getfunc_consts(func) - features.append(strings) - features.append(consts) - return features - -def get_func_names(ea): - funcs = {} - for funcea in Functions(SegStart(ea)): - funcname = GetFunctionName(funcea) - funcs[funcname] = funcea - return funcs - -def get_func_bases(ea): - funcs = {} - for funcea in Functions(SegStart(ea)): - funcname = GetFunctionName(funcea) - funcs[funcea] = funcname - return funcs - -def get_func_range(ea): - funcs = {} - for funcea in Functions(SegStart(ea)): - funcname = GetFunctionName(funcea) - func = get_func(funcea) - funcs[funcname] = (func.startEA, func.endEA) - return funcs - -def get_func_sequences(ea): - funcs_bodylist = {} - funcs = get_funcs(ea) - for funcname in funcs: - if funcname not in funcs_bodylist: - funcs_bodylist[funcname] = [] - for start, end in funcs[funcname]: - inst_addr = start - while inst_addr <= end: - opcode = GetMnem(inst_addr) - funcs_bodylist[funcname].append(opcode) - inst_addr = NextHead(inst_addr) - return funcs_bodylist - -def get_func_cfgs(ea): - func_cfglist = {} - i = 0 - start, end = get_section('LOAD') - #print start, end - for funcea in Functions(SegStart(ea)): - if start <= funcea <= end: - funcname = GetFunctionName(funcea) - func = get_func(funcea) - print i - i += 1 - try: - icfg = cfg.cfg_construct(func) - func_cfglist[funcname] = icfg - except: - pass - - return func_cfglist - -def get_section(t): - base = SegByName(t) - start = SegByBase(base) - end = SegEnd(start) - return start, end - - -def get_func_cfg_sequences(func_cfglist): - func_cfg_seqlist = {} - for funcname in func_cfglist: - func_cfg_seqlist[funcname] = {} - cfg = func_cfglist[funcname][0] - for start, end in cfg: - codesq = get_sequences(start, end) - func_cfg_seqlist[funcname][(start,end)] = codesq - - return func_cfg_seqlist - - -def get_sequences(start, end): - seq = [] - inst_addr = start - while inst_addr <= end: - opcode = GetMnem(inst_addr) - seq.append(opcode) - inst_addr = NextHead(inst_addr) - return seq - -def get_stack_arg(func_addr): - print func_addr - args = [] - stack = GetFrame(func_addr) - if not stack: - return [] - firstM = GetFirstMember(stack) - lastM = GetLastMember(stack) - i = firstM - while i <=lastM: - mName = GetMemberName(stack,i) - mSize = GetMemberSize(stack,i) - if mSize: - i = i + mSize - else: - i = i+4 - if mName not in args and mName and ' s' not in mName and ' r' not in mName: - args.append(mName) - return args - - #pickle.dump(funcs, open('C:/Documents and Settings/Administrator/Desktop/funcs','w')) - -def processDataSegs(): - funcdata = {} - datafunc = {} - for n in xrange(idaapi.get_segm_qty()): - seg = idaapi.getnseg(n) - ea = seg.startEA - segtype = idc.GetSegmentAttr(ea, idc.SEGATTR_TYPE) - if segtype in [idc.SEG_DATA, idc.SEG_BSS]: - start = idc.SegStart(ea) - end = idc.SegEnd(ea) - cur = start - while cur <= end: - refs = [v for v in DataRefsTo(cur)] - for fea in refs: - name = GetFunctionName(fea) - if len(name)== 0: - continue - if name not in funcdata: - funcdata[name] = [cur] - else: - funcdata[name].append(cur) - if cur not in datafunc: - datafunc[cur] = [name] - else: - datafunc[cur].append(name) - cur = NextHead(cur) - return funcdata, datafunc - -def obtainDataRefs(callgraph): - datarefs = {} - funcdata, datafunc = processDataSegs() - for node in callgraph: - if node in funcdata: - datas = funcdata[node] - for dd in datas: - refs = datafunc[dd] - refs = list(set(refs)) - if node in datarefs: - print refs - datarefs[node] += refs - datarefs[node] = list(set(datarefs[node])) - else: - datarefs[node] = refs - return datarefs - - diff --git a/raw-feature-extractor/func.py b/raw-feature-extractor/func.py deleted file mode 100755 index cc0c402..0000000 --- a/raw-feature-extractor/func.py +++ /dev/null @@ -1,285 +0,0 @@ -# -# Reference Lister -# -# List all functions and all references to them in the current section. -# -# Implemented with the idautils module -# -from idautils import * -from idaapi import * -from idc import * -import networkx as nx -import cfg_constructor as cfg -import cPickle as pickle -import pdb -from raw_graphs import * -#from discovRe_feature.discovRe import * -from discovRe import * -#import wingdbstub -#wingdbstub.Ensure() -def gt_funcNames(ea): - funcs = [] - plt_func, plt_data = processpltSegs() - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - if funcname in plt_func: - print funcname - continue - funcs.append(funcname) - return funcs - -def get_funcs(ea): - funcs = {} - # Get current ea - # Loop from start to end in the current segment - plt_func, plt_data = processpltSegs() - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - if funcname in plt_func: - continue - func = get_func(funcea) - blocks = FlowChart(func) - funcs[funcname] = [] - for bl in blocks: - start = bl.startEA - end = bl.endEA - funcs[funcname].append((start, end)) - return funcs - -# used for the callgraph generation. -def get_func_namesWithoutE(ea): - funcs = {} - plt_func, plt_data = processpltSegs() - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - if 'close' in funcname: - print funcea - if funcname in plt_func: - print funcname - continue - funcs[funcname] = funcea - return funcs - -# used for the callgraph generation. -def get_func_names(ea): - funcs = {} - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - funcs[funcname] = funcea - return funcs - -def get_func_bases(ea): - funcs = {} - plt_func, plt_data = processpltSegs() - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - if funcname in plt_func: - continue - funcs[funcea] = funcname - return funcs - -def get_func_range(ea): - funcs = {} - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - func = get_func(funcea) - funcs[funcname] = (func.startEA, func.endEA) - return funcs - -def get_unified_funcname(ea): - funcname = GetFunctionName(ea) - if len(funcname) > 0: - if '.' == funcname[0]: - funcname = funcname[1:] - return funcname - -def get_func_sequences(ea): - funcs_bodylist = {} - funcs = get_funcs(ea) - for funcname in funcs: - if funcname not in funcs_bodylist: - funcs_bodylist[funcname] = [] - for start, end in funcs[funcname]: - inst_addr = start - while inst_addr <= end: - opcode = GetMnem(inst_addr) - funcs_bodylist[funcname].append(opcode) - inst_addr = NextHead(inst_addr) - return funcs_bodylist - -def get_func_cfgs_c(ea): - binary_name = idc.GetInputFile() - raw_cfgs = raw_graphs(binary_name) - externs_eas, ea_externs = processpltSegs() - i = 0 - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - func = get_func(funcea) - print i - i += 1 - icfg = cfg.getCfg(func, externs_eas, ea_externs) - func_f = get_discoverRe_feature(func, icfg[0]) - raw_g = raw_graph(funcname, icfg, func_f) - raw_cfgs.append(raw_g) - - return raw_cfgs - -def get_func_cfgs_ctest(ea): - binary_name = idc.GetInputFile() - raw_cfgs = raw_graphs(binary_name) - externs_eas, ea_externs = processpltSegs() - i = 0 - diffs = {} - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - func = get_func(funcea) - print i - i += 1 - icfg, old_cfg = cfg.getCfg(func, externs_eas, ea_externs) - diffs[funcname] = (icfg, old_cfg) - #raw_g = raw_graph(funcname, icfg) - #raw_cfgs.append(raw_g) - - return diffs - -def get_func_cfgs(ea): - func_cfglist = {} - i = 0 - for funcea in Functions(SegStart(ea)): - funcname = get_unified_funcname(funcea) - func = get_func(funcea) - print i - i += 1 - try: - icfg = cfg.getCfg(func) - func_cfglist[funcname] = icfg - except: - pass - - return func_cfglist - -def get_func_cfg_sequences(func_cfglist): - func_cfg_seqlist = {} - for funcname in func_cfglist: - func_cfg_seqlist[funcname] = {} - cfg = func_cfglist[funcname][0] - for start, end in cfg: - codesq = get_sequences(start, end) - func_cfg_seqlist[funcname][(start,end)] = codesq - - return func_cfg_seqlist - - -def get_sequences(start, end): - seq = [] - inst_addr = start - while inst_addr <= end: - opcode = GetMnem(inst_addr) - seq.append(opcode) - inst_addr = NextHead(inst_addr) - return seq - -def get_stack_arg(func_addr): - print func_addr - args = [] - stack = GetFrame(func_addr) - if not stack: - return [] - firstM = GetFirstMember(stack) - lastM = GetLastMember(stack) - i = firstM - while i <=lastM: - mName = GetMemberName(stack,i) - mSize = GetMemberSize(stack,i) - if mSize: - i = i + mSize - else: - i = i+4 - if mName not in args and mName and ' s' not in mName and ' r' not in mName: - args.append(mName) - return args - - #pickle.dump(funcs, open('C:/Documents and Settings/Administrator/Desktop/funcs','w')) - -def processExternalSegs(): - funcdata = {} - datafunc = {} - for n in xrange(idaapi.get_segm_qty()): - seg = idaapi.getnseg(n) - ea = seg.startEA - segtype = idc.GetSegmentAttr(ea, idc.SEGATTR_TYPE) - if segtype in [idc.SEG_XTRN]: - start = idc.SegStart(ea) - end = idc.SegEnd(ea) - cur = start - while cur <= end: - name = get_unified_funcname(cur) - funcdata[name] = hex(cur) - cur = NextHead(cur) - return funcdata - -def processpltSegs(): - funcdata = {} - datafunc = {} - for n in xrange(idaapi.get_segm_qty()): - seg = idaapi.getnseg(n) - ea = seg.startEA - segname = SegName(ea) - if segname in ['.plt', 'extern', '.MIPS.stubs']: - start = seg.startEA - end = seg.endEA - cur = start - while cur < end: - name = get_unified_funcname(cur) - funcdata[name] = hex(cur) - datafunc[cur]= name - cur = NextHead(cur) - return funcdata, datafunc - - -def processDataSegs(): - funcdata = {} - datafunc = {} - for n in xrange(idaapi.get_segm_qty()): - seg = idaapi.getnseg(n) - ea = seg.startEA - segtype = idc.GetSegmentAttr(ea, idc.SEGATTR_TYPE) - if segtype in [idc.SEG_DATA, idc.SEG_BSS]: - start = idc.SegStart(ea) - end = idc.SegEnd(ea) - cur = start - while cur <= end: - refs = [v for v in DataRefsTo(cur)] - for fea in refs: - name = get_unified_funcname(fea) - if len(name)== 0: - continue - if name not in funcdata: - funcdata[name] = [cur] - else: - funcdata[name].append(cur) - if cur not in datafunc: - datafunc[cur] = [name] - else: - datafunc[cur].append(name) - cur = NextHead(cur) - return funcdata, datafunc - -def obtainDataRefs(callgraph): - datarefs = {} - funcdata, datafunc = processDataSegs() - for node in callgraph: - if node in funcdata: - datas = funcdata[node] - for dd in datas: - refs = datafunc[dd] - refs = list(set(refs)) - if node in datarefs: - print refs - datarefs[node] += refs - datarefs[node] = list(set(datarefs[node])) - else: - datarefs[node] = refs - return datarefs - - diff --git a/raw-feature-extractor/graph_analysis_ida.py b/raw-feature-extractor/graph_analysis_ida.py deleted file mode 100644 index 122efa9..0000000 --- a/raw-feature-extractor/graph_analysis_ida.py +++ /dev/null @@ -1,257 +0,0 @@ -from idautils import * -from idaapi import * -from idc import * - -def getfunc_consts(func): - strings = [] - consts = [] - blocks = [(v.startEA, v.endEA) for v in FlowChart(func)] - for bl in blocks: - strs, conts = getBBconsts(bl) - strings += strs - consts += conts - return strings, consts - -def getConst(ea, offset): - strings = [] - consts = [] - optype1 = GetOpType(ea, offset) - if optype1 == idaapi.o_imm: - imm_value = GetOperandValue(ea, offset) - if 0<= imm_value <= 10: - consts.append(imm_value) - else: - if idaapi.isLoaded(imm_value) and idaapi.getseg(imm_value): - str_value = GetString(imm_value) - if str_value is None: - str_value = GetString(imm_value+0x40000) - if str_value is None: - consts.append(imm_value) - else: - re = all(40 <= ord(c) < 128 for c in str_value) - if re: - strings.append(str_value) - else: - consts.append(imm_value) - else: - re = all(40 <= ord(c) < 128 for c in str_value) - if re: - strings.append(str_value) - else: - consts.append(imm_value) - else: - consts.append(imm_value) - return strings, consts - -def getBBconsts(bl): - strings = [] - consts = [] - start = bl[0] - end = bl[1] - invoke_num = 0 - inst_addr = start - while inst_addr < end: - opcode = GetMnem(inst_addr) - if opcode in ['la','jalr','call', 'jal']: - inst_addr = NextHead(inst_addr) - continue - strings_src, consts_src = getConst(inst_addr, 0) - strings_dst, consts_dst = getConst(inst_addr, 1) - strings += strings_src - strings += strings_dst - consts += consts_src - consts += consts_dst - try: - strings_dst, consts_dst = getConst(inst_addr, 2) - consts += consts_dst - strings += strings_dst - except: - pass - - inst_addr = NextHead(inst_addr) - return strings, consts - -def getFuncCalls(func): - blocks = [(v.startEA, v.endEA) for v in FlowChart(func)] - sumcalls = 0 - for bl in blocks: - callnum = calCalls(bl) - sumcalls += callnum - return sumcalls - -def getLogicInsts(func): - blocks = [(v.startEA, v.endEA) for v in FlowChart(func)] - sumcalls = 0 - for bl in blocks: - callnum = calLogicInstructions(bl) - sumcalls += callnum - return sumcalls - -def getTransferInsts(func): - blocks = [(v.startEA, v.endEA) for v in FlowChart(func)] - sumcalls = 0 - for bl in blocks: - callnum = calTransferIns(bl) - sumcalls += callnum - return sumcalls - -def getIntrs(func): - blocks = [(v.startEA, v.endEA) for v in FlowChart(func)] - sumcalls = 0 - for bl in blocks: - callnum = calInsts(bl) - sumcalls += callnum - return sumcalls - -def getLocalVariables(func): - args_num = get_stackVariables(func.startEA) - return args_num - -def getBasicBlocks(func): - blocks = [(v.startEA, v.endEA) for v in FlowChart(func)] - return len(blocks) - -def getIncommingCalls(func): - refs = CodeRefsTo(func.startEA, 0) - re = len([v for v in refs]) - return re - - -def get_stackVariables(func_addr): - #print func_addr - args = [] - stack = GetFrame(func_addr) - if not stack: - return 0 - firstM = GetFirstMember(stack) - lastM = GetLastMember(stack) - i = firstM - while i <=lastM: - mName = GetMemberName(stack,i) - mSize = GetMemberSize(stack,i) - if mSize: - i = i + mSize - else: - i = i+4 - if mName not in args and mName and 'var_' in mName: - args.append(mName) - return len(args) - - - -def calArithmeticIns(bl): - x86_AI = {'add':1, 'sub':1, 'div':1, 'imul':1, 'idiv':1, 'mul':1, 'shl':1, 'dec':1, 'inc':1} - mips_AI = {'add':1, 'addu':1, 'addi':1, 'addiu':1, 'mult':1, 'multu':1, 'div':1, 'divu':1} - calls = {} - calls.update(x86_AI) - calls.update(mips_AI) - start = bl[0] - end = bl[1] - invoke_num = 0 - inst_addr = start - while inst_addr < end: - opcode = GetMnem(inst_addr) - if opcode in calls: - invoke_num += 1 - inst_addr = NextHead(inst_addr) - return invoke_num - -def calCalls(bl): - calls = {'call':1, 'jal':1, 'jalr':1} - start = bl[0] - end = bl[1] - invoke_num = 0 - inst_addr = start - while inst_addr < end: - opcode = GetMnem(inst_addr) - if opcode in calls: - invoke_num += 1 - inst_addr = NextHead(inst_addr) - return invoke_num - -def calInsts(bl): - start = bl[0] - end = bl[1] - ea = start - num = 0 - while ea < end: - num += 1 - ea = NextHead(ea) - return num - -def calLogicInstructions(bl): - x86_LI = {'and':1, 'andn':1, 'andnpd':1, 'andpd':1, 'andps':1, 'andnps':1, 'test':1, 'xor':1, 'xorpd':1, 'pslld':1} - mips_LI = {'and':1, 'andi':1, 'or':1, 'ori':1, 'xor':1, 'nor':1, 'slt':1, 'slti':1, 'sltu':1} - calls = {} - calls.update(x86_LI) - calls.update(mips_LI) - start = bl[0] - end = bl[1] - invoke_num = 0 - inst_addr = start - while inst_addr < end: - opcode = GetMnem(inst_addr) - if opcode in calls: - invoke_num += 1 - inst_addr = NextHead(inst_addr) - return invoke_num - -def calSconstants(bl): - start = bl[0] - end = bl[1] - invoke_num = 0 - inst_addr = start - while inst_addr < end: - opcode = GetMnem(inst_addr) - if opcode in calls: - invoke_num += 1 - inst_addr = NextHead(inst_addr) - return invoke_num - - -def calNconstants(bl): - start = bl[0] - end = bl[1] - invoke_num = 0 - inst_addr = start - while inst_addr < end: - optype1 = GetOpType(inst_addr, 0) - optype2 = GetOpType(inst_addr, 1) - if optype1 == 5 or optype2 == 5: - invoke_num += 1 - inst_addr = NextHead(inst_addr) - return invoke_num - -def retrieveExterns(bl, ea_externs): - externs = [] - start = bl[0] - end = bl[1] - inst_addr = start - while inst_addr < end: - refs = CodeRefsFrom(inst_addr, 1) - try: - ea = [v for v in refs if v in ea_externs][0] - externs.append(ea_externs[ea]) - except: - pass - inst_addr = NextHead(inst_addr) - return externs - -def calTransferIns(bl): - x86_TI = {'jmp':1, 'jz':1, 'jnz':1, 'js':1, 'je':1, 'jne':1, 'jg':1, 'jle':1, 'jge':1, 'ja':1, 'jnc':1, 'call':1} - mips_TI = {'beq':1, 'bne':1, 'bgtz':1, "bltz":1, "bgez":1, "blez":1, 'j':1, 'jal':1, 'jr':1, 'jalr':1} - arm_TI = {'MVN':1, "MOV":1} - calls = {} - calls.update(x86_TI) - calls.update(mips_TI) - start = bl[0] - end = bl[1] - invoke_num = 0 - inst_addr = start - while inst_addr < end: - opcode = GetMnem(inst_addr) - re = [v for v in calls if opcode in v] - if len(re) > 0: - invoke_num += 1 - inst_addr = NextHead(inst_addr) - return invoke_num \ No newline at end of file diff --git a/raw-feature-extractor/graph_property.py b/raw-feature-extractor/graph_property.py deleted file mode 100644 index 4319292..0000000 --- a/raw-feature-extractor/graph_property.py +++ /dev/null @@ -1,24 +0,0 @@ -import networkx as nx -import pdb -def betweeness(g): - #pdb.set_trace() - betweenness = nx.betweenness_centrality(g) - return betweenness - -def eigenvector(g): - centrality = nx.eigenvector_centrality(g) - return centrality - -def closeness_centrality(g): - closeness = nx.closeness_centrality(g) - return closeness - -def retrieveGP(g): - bf = betweeness(g) - #close = closeness_centrality(g) - #bf_sim = - #close_sim = - x = sorted(bf.values()) - value = sum(x)/len(x) - return round(value,5) - diff --git a/raw-feature-extractor/preprocessing_ida.py b/raw-feature-extractor/preprocessing_ida.py deleted file mode 100644 index 6704223..0000000 --- a/raw-feature-extractor/preprocessing_ida.py +++ /dev/null @@ -1,27 +0,0 @@ -from func import * -from raw_graphs import * -from idc import * -import os -import argparse - -def parse_command(): - parser = argparse.ArgumentParser(description='Process some integers.') - parser.add_argument("--path", type=str, help="The directory where to store the generated .ida file") - args = parser.parse_args() - return args - -if __name__ == '__main__': - - args = parse_command() - path = args.path - analysis_flags = idc.GetShortPrm(idc.INF_START_AF) - analysis_flags &= ~idc.AF_IMMOFF - # turn off "automatically make offset" heuristic - idc.SetShortPrm(idc.INF_START_AF, analysis_flags) - idaapi.autoWait() - cfgs = get_func_cfgs_c(FirstSeg()) - binary_name = idc.GetInputFile() + '.ida' - fullpath = os.path.join(path, binary_name) - pickle.dump(cfgs, open(fullpath,'w')) - print binary_name - idc.Exit(0) \ No newline at end of file diff --git a/raw-feature-extractor/raw_graphs.py b/raw-feature-extractor/raw_graphs.py deleted file mode 100755 index 37bcc5d..0000000 --- a/raw-feature-extractor/raw_graphs.py +++ /dev/null @@ -1,286 +0,0 @@ -import itertools -import sys -sys.path.insert(0, '/usr/local/lib/python2.7/dist-packages/') -import networkx as nx -#import numpy as np -from subprocess import Popen, PIPE -import pdb -import os -import re,mmap -#from graph_edit_new import * - -class raw_graph: - def __init__(self, funcname, g, func_f): - self.funcname = funcname - self.old_g = g[0] - self.g = nx.DiGraph() - self.entry = g[1] - self.fun_features = func_f - self.attributing() - - def __len__(self): - return len(self.g) - - def attributing(self): - self.obtainOffsprings(self.old_g) - for node in self.old_g: - fvector = self.retrieveVec(node, self.old_g) - self.g.add_node(node) - self.g.node[node]['v'] = fvector - - for edge in self.old_g.edges(): - node1 = edge[0] - node2 = edge[1] - self.g.add_edge(node1, node2) - - def obtainOffsprings(self,g): - nodes = g.nodes() - for node in nodes: - offsprings = {} - self.getOffsprings(g, node, offsprings) - g.node[node]['offs'] = len(offsprings) - return g - - def getOffsprings(self, g, node, offsprings): - node_offs = 0 - sucs = g.successors(node) - for suc in sucs: - if suc not in offsprings: - offsprings[suc] = 1 - self.getOffsprings(g, suc, offsprings) - - def retrieveVec(self, id_, g): - feature_vec = [] - #numC0 - numc = g.node[id_]['consts'] - feature_vec.append(numc) - #nums1 - nums = g.node[id_]['strings'] - feature_vec.append(nums) - #offsprings2 - offs = g.node[id_]['offs'] - feature_vec.append(offs) - #numAs3 - numAs = g.node[id_]['numAs'] - feature_vec.append(numAs) - # of calls4 - calls = g.node[id_]['numCalls'] - feature_vec.append(calls) - # of insts5 - insts = g.node[id_]['numIns'] - feature_vec.append(insts) - # of LIs6 - insts = g.node[id_]['numLIs'] - feature_vec.append(insts) - # of TIs7 - insts = g.node[id_]['numTIs'] - feature_vec.append(insts) - return feature_vec - - - def enumerating(self, n): - subgs = [] - #pdb.set_trace() - for sub_nodes in itertools.combinations(self.g.nodes(), n): - subg = self.g.subgraph(sub_nodes) - u_subg = subg.to_undirected() - if nx.is_connected(u_subg): - subgs.append(subg) - return subgs - - - def genMotifs(self, n): - motifs = {} - subgs = enumerating(n) - for subg in subgs: - if len(motifs) == 0: - motifs[subg] = [subg] - else: - nomatch = True - for mt in motifs: - if nx.is_isomorphic(mt, subg): - motifs[mt].append(subg) - nomatch = False - if nomatch: - motifs[subg] = [subg] - return motifs - - def enumerating_efficient(self, n): - #pdb.set_trace() - if len(self.g) >= 200: - return [] - with open('/home/qian/workspace/gEnding/gencoding/encoding/labeled/data/preprocessing/OUTPUT.txt','wb') as f: - nx.write_edgelist(self.g,f,data=False) - #pdb.set_trace() - process = Popen(["/home/qian/workspace/FANMOD-command_line-source/executables/./fanmod_command_line_linux", str(n), "100000", "1", "/home/qian/workspace/gEnding/gencoding/encoding/labeled/data/preprocessing/OUTPUT.txt", "1", "0", "0", "2", "0", "0", "0", "1000", "3", "3", "/home/qian/workspace/gEnding/gencoding/encoding/labeled/data/preprocessing/MotifCount.txt", "0", "1"], stdout=PIPE, stderr=PIPE) - stdout, stderr = process.communicate() - if process.returncode >= 0: - #os.system("/home/qian/software/FANMOD-command_line-source/executables/./fanmod_command_line_linux " +str(n) + " 100000 1 /home/qian/workspace/gEnding/gencoding/encoding/labeled/data/preprocessing/OUTPUT.txt 1 0 0 2 0 0 0 1000 3 3 /home/qian/workspace/gEnding/gencoding/encoding/labeled/data/preprocessing/MotifCount.txt 0 1") - #pdb.set_trace() - #pdb.set_trace() - subgs = self.parseOutput("/home/qian/workspace/gEnding/gencoding/encoding/labeled/data/preprocessing/MotifCount.txt.dump", n) - #pdb.set_trace() - os.remove("/home/qian/workspace/gEnding/gencoding/encoding/labeled/data/preprocessing/MotifCount.txt.dump") - return subgs - return [] - - def parseOutput(self, path, n): - pattern = re.compile('[0-9]+\,[0-9]+\,[0-9]+\,[0-9]+') - subgraphs = [] - with open(path,'r') as f: - data = mmap.mmap(f.fileno(), 0, prot=mmap.PROT_READ) - mo = re.findall(pattern, data) - if mo: - results = [map(int, v.split(',')[1:]) for v in mo] - subgraphs = self.createGraphDirectly(results) - return subgraphs - - def parseOutputByconditions(self, path, n): - pattern = re.compile('[0-9]+\,[0-9]+\,[0-9]+\,[0-9]+') - subgraphs = [] - with open(path,'r') as f: - data = mmap.mmap(f.fileno(), 0, prot=mmap.PROT_READ) - mo = re.findall(pattern, data) - if mo: - results = [map(int, v.split(',')[1:]) for v in mo] - subgraphs = self.create_Graphbycondition_Directly(results) - return subgraphs - - def create_Graphbycondition_Directly(self, results): - subgs = [] - for indexes in results: - tg = template_graph() - subg = self.g.subgraph(indexes) - tg.updateG(subg) - subgs.append(tg) - del tg - return subgs - - def createGraphDirectly(self, results): - #pdb.set_trace() - #subgs = [self.g.subgraph(indexes) for indexes in results] - subgs = [] - for indexes in results: - tg = template_graph() - subg = self.g.subgraph(indexes) - tg.updateG(subg) - subgs.append(tg) - del tg - return subgs - - def createGraph(self, results, n): - binary_value = int(results[0],2) - indexes = [int(v) for v in results[1:]] - fang = self.createG(results[0], n) - if fang: - tg = template_graph(binary_value) - tg.updateG(fang, indexes, self.g) - return tg - pdb.set_trace() - print "there is g which is none" - - def createG(self, binary_str, n): - g = nx.DiGraph() - l = [int(v) for v in binary_str] - #pdb.set_trace() - shape = (n, n) - data = np.array(l) - ad_matrix = data.reshape(shape) - for i in xrange(n): - for j in xrange(n): - if ad_matrix[i][j] == 1: - g.add_edge(i, j) - return g - - - -class raw_graphs: - def __init__(self, binary_name): - self.binary_name = binary_name - self.raw_graph_list = [] - - def append(self, raw_g): - self.raw_graph_list.append(raw_g) - - def __len__(self): - return len(self.raw_graph_list) - - -class graphlets: - def __init__(self, funcname): - self.funcname = funcname - self.graphlets_list = [] - self.binary_name = None - - def updateBN(self, binary_name): - self.binary_name = binary_name - - def append(self, subg): - self.graphlets_list.append(subg) - - def appendSet(self, subgs): - self.graphlets_list += subgs - - def __len__(self): - return len(self.graphlets_list) - -class template_graph: - def __init__(self, value=None): - self.value = value - self.g = None - - def updateG(self,g): - self.g = g - #def updateIndexes(self, indexes): - # self.indexes = indexes - - #def updateAttributes(self, pg, indexes, maing): - # for id_ in xrange(len(indexes)): - # index = indexes[id_] - # gnode = self.findNode(index, maing) - # self.g.node[gnode] = pg.node[index] - - -class template_graphs: - def __init__(self, size): - self.size = size - self.gs = [] - self.bit_len = None - - def enumeratingAll(self): - subgs = [] - binary_value = self.genBinValue() - for i in xrange(binary_value): - if i == 0 : - continue - g = self.createG(i) - if g: - tg = template_graph(i) - tg.updateG(g) - self.gs.append(tg) - - def genBinValue(self): - n = self.size - self.bit_len = n*n - return 2**(self.bit_len) - - def createG(self, i): - g = nx.DiGraph() - l = self.genArray(i) - #pdb.set_trace() - shape = (self.size, self.size) - data = np.array(l) - ad_matrix = data.reshape(shape) - for i in xrange(self.size): - for j in xrange(self.size): - if ad_matrix[i][j] == 1: - g.add_edge(i, j) - u_g = g.to_undirected() - if len(g) == self.size and nx.is_connected(u_g): - return g - return False - - def genArray(self, i): - l = [int(x) for x in bin(i)[2:]] - x = [0 for v in xrange(self.bit_len - len(l))] - return x + l diff --git a/search-engine/db.py b/search-engine/db.py deleted file mode 100644 index bc6c864..0000000 --- a/search-engine/db.py +++ /dev/null @@ -1,356 +0,0 @@ -import cPickle as pickle -from search import * -from nearpy import Engine -from nearpy.hashes import RandomDiscretizedProjections -from nearpy.filters import NearestFilter, UniqueFilter -from nearpy.distances import EuclideanDistance -from nearpy.distances import CosineDistance -from nearpy.hashes import RandomBinaryProjections -from nearpy.experiments import DistanceRatioExperiment -from redis import Redis -from nearpy.storage import RedisStorage -from feature import * -import numpy as np -import os -import pdb -import argparse -import time -import numpy as np -from refactoring import * -import pymongo -from pymongo import MongoClient - -def initDB(): - client = MongoClient() - client = MongoClient('localhost', 27017) - client = MongoClient('mongodb://localhost:27017/') - db = client.test_database - db = client['iot-encoding'] - return db - -db = initDB() -posts = db.posts - -class db: - - def __init__(self): - self.feature_list = {} - self.engine = None - - def loadHashmap(self, feature_size, result_n): - # Create redis storage adapter - redis_object = Redis(host='localhost', port=6379, db=0) - redis_storage = RedisStorage(redis_object) - pdb.set_trace() - try: - # Get hash config from redis - config = redis_storage.load_hash_configuration('test') - # Config is existing, create hash with None parameters - lshash = RandomBinaryProjections(None, None) - # Apply configuration loaded from redis - lshash.apply_config(config) - - except: - # Config is not existing, create hash from scratch, with 10 projections - lshash = RandomBinaryProjections('test', 0) - - - # Create engine for feature space of 100 dimensions and use our hash. - # This will set the dimension of the lshash only the first time, not when - # using the configuration loaded from redis. Use redis storage to store - # buckets. - nearest = NearestFilter(1000) - #self.engine = Engine(feature_size, lshashes=[], vector_filters=[]) - pdb.set_trace() - self.engine = Engine(192, lshashes=[lshash], vector_filters=[nearest], storage=redis_storage, distance=EuclideanDistance()) - - # Do some stuff like indexing or querying with the engine... - - # Finally store hash configuration in redis for later use - redis_storage.store_hash_configuration(lshash) - - def appendToDB(self, binary_name, funcname, fvector, firmware_name=""): - if fvector is None: - return - #ftuple = tuple([fvector]) - self.engine.store_vector(np.asarray(fvector), ".".join((firmware_name,binary_name,funcname))) - - def batch_appendDB(self, binary_name, features, firmware_name=""): - for funcname in features: - feature = features[funcname] - #pdb.set_trace() - self.appendToDB(binary_name, funcname, feature, firmware_name) - - def batch_appendDBbyDir(self, base_dir): - cursor = posts.find({"firmware_name":"ddwrt-r21676_result"}) - i = 0 - for v in cursor: - print i - i+=1 - binary_name = v['binary_name'] - funcname = v['func_name'] - firmware_name = v['firmware_name'] - feature = v['fvector'] - self.appendToDB(binary_name, funcname, feature, firmware_name) - - def batch_appendDBbyDir1(self, base_dir): - image_dir = os.path.join(base_dir, "image") - firmware_featrues={} - bnum = 0 - fnum = 0 - i = 0 - pdb.set_trace() - for firmware_name in os.listdir(image_dir): - print firmware_name - firmware_featrues[firmware_name] = {} - firmware_dir = os.path.join(image_dir, firmware_name) - for binary_name in os.listdir(firmware_dir): - if binary_name.endswith(".features"): - bnum += 1 - featrues_dir = os.path.join(firmware_dir, binary_name) - featrues = pickle.load(open(featrues_dir, "r")) - for funcname in featrues: - fnum +=1 - #pdb.set_trace() - feature = featrues[funcname] - self.appendToDB(binary_name, funcname, feature, firmware_name) - del featrues - print("bnum ", bnum) - print("fnum ", fnum) - - def dump(self, base_dir): - db_dir = os.path.join(base_dir, "data/db/busybox.feature_mapping") - pickle.dump(self.feature_list, open(db_dir, 'w')) - db_dir = os.path.join(base_dir, "data/db/busybox.hashmap") - pickle.dump(self.engine, open(db_dir, 'w')) - - def loadDB(self, base_dir): - db_dir = os.path.join(base_dir, "data/db/busybox.feature_mapping") - self.feature_list = pickle.load(open(db_dir, 'r')) - db_dir = os.path.join(base_dir, "data/db/busybox.hashmap") - self.engine = pickle.load(open(db_dir, 'r')) - - def findF(self, binary_name, funcname): - x = [v for v in self.feature_list if binary_name in self.feature_list[v] and funcname in self.feature_list[v][binary_name]] - return x[0] - -def retrieveFeaturesByDir(n, base_dir): - firmware_featrues={} - i = 0 - for firmware_name in os.listdir(base_dir): - if firmware_name.endWith(".features"): - firmware_featrues[firmware_name] = {} - firmware_dir = os.path.join(base_dir, firmware_name) - if i > 0: - break - i += 1 - pdb.set_trace() - for binary_name in os.listdir(firmware_dir): - featrues_dir = os.path.join(firmware_dir, binary_name + "_cb" + str(n) + ".features") - featrues = pickle.load(open(featrues_dir, "r")) - for funcname in featrues: - feature = featrues[funcname] - self.appendToDB(firmware_name, binary_name, funcname, feature) - del featrues - -def retrieveFeatures(n, base_dir, filename, funcs): - feature_dic = {} - featrues_dir = os.path.join(base_dir, "5000", filename + "_cb" + str(n) + ".features") - featrues = pickle.load(open(featrues_dir, "r")) - #featuresx = retrieveFeaturesx(filename) - for name in featrues: - #if name in funcs: - x = featrues[name] - #+ featuresx[name] - feature_dic[name] = np.asarray(x) - return feature_dic - -def retrieveVuldb(base_input_dir): - vul_path = os.path.join(base_input_dir, "vul") - vul_db = pickle.load(open(vul_path, "r")) - return vul_db - - -def retrieveFeaturesx(filename): - ida_input_dir = os.path.join("./data/", filename + ".features") - featuresx = pickle.load(open(ida_input_dir, "r")) - return featuresx - -def retrieveQueries(n, base_dir, filename1, featrues_src): - queries = {} - featrues_dir = os.path.join(base_dir, "5000", filename1 + "_cb" + str(n) + ".features") - featrues = pickle.load(open(featrues_dir, "r")) - #featuresx = retrieveFeaturesx(filename1) - for name in featrues: - #if name in featrues_src: - x = featrues[name] - #+ featuresx[name] - queries[name] = np.asarray(x) - return queries - -def retrieveQueriesbyDir(n, base_dir, firmware_name, filename1): - queries = {} - featrues_dir = os.path.join(base_dir, firmware_name, filename1 + "_cb" + str(n) + ".features") - featrues = pickle.load(open(featrues_dir, "r")) - for name in featrues: - #del featrues[name][5] - queries[name] = np.asarray(featrues[name]) - return queries - -def retrieveQuery(n, base_dir, filename, funcname): - featrues_dir = os.path.join(base_dir, filename + "_cb" + str(n) + ".features") - featrues = pickle.load(open(featrues_dir, "r")) - f = [featrues[v] for v in featrues if funcname in v ][0] - return np.asarray(f) - -def parse_command(): - parser = argparse.ArgumentParser(description='Process some integers.') - parser.add_argument("--base_input_dir", type=str, help="raw binaries to process for training") - parser.add_argument('--output_dir', type=str, help="output dir") - parser.add_argument("--filename1", type=str, help="the size of each graphlet") - parser.add_argument("--filename2", type=str, help="the size of each graphlet") - parser.add_argument("--size", type=int, help="the size of each graphlet") - #parser.add_argument("--size", type=int, help="the size of each graphlet") - args = parser.parse_args() - return args - -def loadFuncs(path): - funcs = {} - x86_dir = os.path.join(path, "func_candid") - #mips_dir = os.path.join(path, "openssl1.0.1a_mips.ida") - fp = open(x86_dir,"r") - for line in fp: - items = line.split("\n") - funcname = items[0] - funcs[funcname] = 1 - return funcs - -def dump(path, featrues, queries): - fp = open(path + "/" + "matrix", 'w') - for name in featrues: - row = [] - row.append("x86") - row.append(name) - row += featrues[name] - fp.write("%s\t%s\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\n" %tuple(row)) - for name in queries: - row = [] - row.append("mips") - row.append(name) - row += queries[name] - fp.write("%s\t%s\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\n" % tuple(row)) - fp.close() - - -def queryBytwo(base_input_dir, filename1, filename2, n): - threthold = 50 - db_instance = db() - funcs = loadFuncs(base_input_dir) - db_instance.loadHashmap(n, 50000) - #pdb.set_trace() - featrues = retrieveFeatures(n, base_input_dir, filename1, funcs) - queries = retrieveQueries(n, base_input_dir, filename2, funcs) - #queries = refactoring(queries, featrues) - vul_db = retrieveVuldb(base_input_dir) - pdb.set_trace() - #dump(base_input_dir, featrues, queries) - #start = time.time() - #db_instance.batch_appendDBbyDir(base_input_dir) - #end = time.time() - #total = end - start - #print total - db_instance.batch_appendDB(filename1, featrues) - pdb.set_trace() - ranks = [] - times = [] - for threthold in xrange(1, 210, 10): - hit = [] - i = 0 - for name in queries: - #print i - i += 1 - ''' - if i == 1000: - print (sum(times)/len(times)) - pdb.set_trace() - print "s" - ''' - #if name not in vul_db['openssl']: - # continue - if name not in featrues: - continue - #pdb.set_trace() - query = queries[name] - #start = time.time() - x = db_instance.engine.neighbours(query) - #end = time.time() - #total = end - start - #times.append(total) - #print total - #pdb.set_trace() - try: - rank = [v for v in xrange(len(x)) if name in x[v][1]][0] - ranks.append((name, rank)) - if rank <= threthold: - hit.append(1) - else: - hit.append(0) - except: - #pdb.set_trace() - hit.append(0) - pass - #pdb.set_trace() - acc = sum(hit) * 1.0 / len(hit) - print acc - -def queryAll(base_dir, firmware_name, filename1, n): - threthold = 155 - db_instance = db() - db_instance.loadHashmap(n, 50000) - queries = retrieveQueriesbyDir(n, base_dir, firmware_name, filename1) - start = time.time() - pdb.set_trace() - db_instance.batch_appendDBbyDir(n, base_dir) - end = time.time() - dur = end - start - print dur - pdb.set_trace() - hit = [] - i = 0 - times = [] - for name in queries: - print i - i += 1 - query = queries[name] - start = time.clock() - x = db_instance.engine.neighbours(query) - end = time.clock() - dur = end - start - times.append(dur) - #pdb.set_trace() - try: - rank = [v for v in xrange(len(x)) if name in x[v][1]] - if len(rank) > 1: - pdb.set_trace() - print "stop" - if rank[0] <= threthold: - hit.append(1) - else: - hit.append(0) - except: - hit.append(0) - - acc = sum(hit) * 1.0 / len(hit) - mean = np.mean(times) - std = np.std(times) - #pdb.set_trace() - print acc - -if __name__ == "__main__": - args = parse_command() - base_dir = args.base_input_dir - filename1 = args.filename1 - filename2 = args.filename2 - n = args.size - pdb.set_trace() - queryBytwo(base_dir, filename1, filename2, n)